From 13b99c7b5116d9c5b0571f68230c6a20d2f4780b Mon Sep 17 00:00:00 2001
From: Byron <sebastian.thiel@icloud.com>
Date: Thu, 30 Jul 2026 14:17:25 +0200
Subject: [PATCH 001/282] feat: support lazy note lookup in gix-note

Establish the minimal plumbing API needed to query notes efficiently for many objects, such as every commit visible in a history view.

Resolve note blobs through Git notes progressive two-hex-digit fanout trees and use Git tree ordering for direct entry lookup. Load only trees along the requested object path and retain decoded trees in a caller-owned cache that can be reused across lookups and notes roots.

Ignore entries that do not form valid notes instead of mistaking arbitrary tree contents for mappings. Use gix-error for contextual failures and add tests for fanout lookup, cache reuse, and malformed leaf entries.
---
 Cargo.lock          |   7 ++
 gix-note/Cargo.toml |  13 ++++
 gix-note/src/lib.rs | 153 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 173 insertions(+)

diff --git a/Cargo.lock b/Cargo.lock
index f743688b539..c7bf17d2313 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2155,6 +2155,13 @@ dependencies = [
 [[package]]
 name = "gix-note"
 version = "0.0.0"
+dependencies = [
+ "gix-error",
+ "gix-hash",
+ "gix-object",
+ "gix-odb",
+ "gix-testtools",
+]
 
 [[package]]
 name = "gix-object"
diff --git a/gix-note/Cargo.toml b/gix-note/Cargo.toml
index d3e95ae93cd..9a0155491c2 100644
--- a/gix-note/Cargo.toml
+++ b/gix-note/Cargo.toml
@@ -14,4 +14,17 @@ include = ["/src/**/*", "/LICENSE-*"]
 [lib]
 doctest = false
 
+[features]
+## Enable support for the SHA-1 hash by forwarding it to dependencies.
+sha1 = ["gix-hash/sha1", "gix-object/sha1"]
+## Enable support for the SHA-256 hash by forwarding it to dependencies.
+sha256 = ["gix-hash/sha256", "gix-object/sha256"]
+
 [dependencies]
+gix-error = { version = "^0.2.5", path = "../gix-error" }
+gix-hash = { version = "^0.26.0", path = "../gix-hash" }
+gix-object = { version = "^0.63.0", path = "../gix-object" }
+
+[dev-dependencies]
+gix-odb = { path = "../gix-odb" }
+gix-testtools = { path = "../tests/tools" }
diff --git a/gix-note/src/lib.rs b/gix-note/src/lib.rs
index 45278f22481..f9216e7806a 100644
--- a/gix-note/src/lib.rs
+++ b/gix-note/src/lib.rs
@@ -1 +1,154 @@
+//! Read Git notes from notes trees.
+
 #![forbid(unsafe_code)]
+#![deny(missing_docs)]
+
+use std::{cmp::Ordering, collections::HashMap};
+
+use gix_error::{ResultExt, message};
+use gix_hash::{ObjectId, oid};
+use gix_object::{
+    Find, FindExt, Tree,
+    bstr::{BStr, ByteSlice},
+};
+
+/// The error returned by note operations.
+pub type Error = gix_error::Exn<gix_error::Message>;
+
+/// Decoded trees retained across note lookups.
+///
+/// The cache is independent of a particular notes root, allowing callers to
+/// reuse it for all configured notes references.
+#[derive(Default)]
+pub struct Cache {
+    trees: HashMap<ObjectId, Tree>,
+    buf: Vec<u8>,
+}
+
+impl Cache {
+    fn tree(&mut self, id: ObjectId, objects: &impl Find) -> Result<&Tree, Error> {
+        if !self.trees.contains_key(&id) {
+            let tree = objects
+                .find_tree(&id, &mut self.buf)
+                .or_raise(|| message!("Could not load notes tree {id}"))?
+                .into_owned();
+            self.trees.insert(id, tree);
+        }
+        Ok(self.trees.get(&id).expect("tree was inserted or already present"))
+    }
+}
+
+/// Return the blob associated with `object` in the notes tree at `root`.
+///
+/// Trees are loaded lazily along the progressive two-hex-digit fanout path and
+/// retained in `cache`. Entries that do not conform to Git's notes layout are
+/// ignored.
+pub fn get(root: ObjectId, object: &oid, objects: &impl Find, cache: &mut Cache) -> Result<Option<ObjectId>, Error> {
+    let hex = object.to_hex().to_string();
+    let mut remaining = hex.as_bytes().as_bstr();
+    let mut tree_id = root;
+
+    loop {
+        let tree = cache.tree(tree_id, objects)?;
+        if let Some(entry) = entry(tree, remaining, false).filter(|entry| entry.mode.is_blob()) {
+            return Ok(Some(entry.oid));
+        }
+        let Some(component) = remaining.get(..2).filter(|_| remaining.len() > 2) else {
+            return Ok(None);
+        };
+        let Some(subtree) = entry(tree, BStr::new(component), true).filter(|entry| entry.mode.is_tree()) else {
+            return Ok(None);
+        };
+        tree_id = subtree.oid;
+        remaining = remaining[2..].as_bstr();
+    }
+}
+
+fn entry<'a>(tree: &'a Tree, name: &BStr, is_tree: bool) -> Option<&'a gix_object::tree::Entry> {
+    tree.entries
+        .binary_search_by(|candidate| cmp_entry_with_name(candidate, name, is_tree))
+        .ok()
+        .map(|index| &tree.entries[index])
+}
+
+fn cmp_entry_with_name(entry: &gix_object::tree::Entry, name: &BStr, is_tree: bool) -> Ordering {
+    let common = entry.filename.len().min(name.len());
+    entry.filename[..common].cmp(&name[..common]).then_with(|| {
+        let entry = entry
+            .filename
+            .get(common)
+            .or_else(|| entry.mode.is_tree().then_some(&b'/'));
+        let name = name.get(common).or_else(|| is_tree.then_some(&b'/'));
+        entry.cmp(&name)
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use gix_hash::Kind;
+    use gix_object::{
+        Write,
+        bstr::BString,
+        tree::{Entry, EntryKind},
+    };
+
+    use super::*;
+
+    #[test]
+    fn lazily_reads_fanout_trees_and_reuses_them() -> gix_testtools::Result {
+        let objects = gix_odb::memory::Proxy::new(gix_object::find::Never, Kind::Sha1);
+        let annotated = gix_object::compute_hash(Kind::Sha1, gix_object::Kind::Blob, b"annotated")?;
+        let note = objects.write_buf(gix_object::Kind::Blob, b"note")?;
+        let hex = annotated.to_hex().to_string();
+        let subtree = objects.write(&Tree {
+            entries: vec![Entry {
+                mode: EntryKind::Blob.into(),
+                filename: BString::from(&hex[2..]),
+                oid: note,
+            }],
+        })?;
+        let root = objects.write(&Tree {
+            entries: vec![Entry {
+                mode: EntryKind::Tree.into(),
+                filename: BString::from(&hex[..2]),
+                oid: subtree,
+            }],
+        })?;
+
+        let mut cache = Cache::default();
+        assert_eq!(
+            get(root, &annotated, &objects, &mut cache).map_err(gix_error::Exn::into_error)?,
+            Some(note),
+            "the note is found through its fanout path"
+        );
+        assert_eq!(cache.trees.len(), 2, "only the root and matching subtree were loaded");
+        assert_eq!(
+            get(root, &annotated, &objects, &mut cache).map_err(gix_error::Exn::into_error)?,
+            Some(note),
+            "the same lookup remains stable"
+        );
+        assert_eq!(cache.trees.len(), 2, "repeated lookups reuse decoded trees");
+        Ok(())
+    }
+
+    #[test]
+    fn ignores_entries_that_are_not_notes() -> gix_testtools::Result {
+        let objects = gix_odb::memory::Proxy::new(gix_object::find::Never, Kind::Sha1);
+        let annotated = gix_object::compute_hash(Kind::Sha1, gix_object::Kind::Blob, b"annotated")?;
+        let hex = annotated.to_hex().to_string();
+        let root = objects.write(&Tree {
+            entries: vec![Entry {
+                mode: EntryKind::Tree.into(),
+                filename: BString::from(hex),
+                oid: ObjectId::empty_tree(Kind::Sha1),
+            }],
+        })?;
+
+        assert_eq!(
+            get(root, &annotated, &objects, &mut Cache::default()).map_err(gix_error::Exn::into_error)?,
+            None,
+            "a tree at a note leaf is not a note"
+        );
+        Ok(())
+    }
+}

From bad5ec36666c9e8154d866f02b779b6fb0dc67c7 Mon Sep 17 00:00:00 2001
From: Byron <sebastian.thiel@icloud.com>
Date: Thu, 30 Jul 2026 14:20:52 +0200
Subject: [PATCH 002/282] feat: support note mutation in gix-note

Add plumbing operations to insert, replace, and remove note mappings while returning the rewritten root tree and the previous note id.

Rebuild notes using the same dynamic fanout rule as Git so growing and shrinking collections remain compatible with existing notes trees. Preserve unrelated entries during rewriting, reject mixed object-hash kinds, report duplicate mappings, and leave the tree unchanged when removing a missing note.

Keep object persistence delegated through Find and Write traits, allowing callers to decide how commits and refs are updated. Test fanout expansion and collapse, replacement and removal results, and preservation of non-note entries.
---
 crate-status.md     |   2 +-
 gix-note/src/lib.rs | 264 +++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 261 insertions(+), 5 deletions(-)

diff --git a/crate-status.md b/crate-status.md
index 2e35e1b4340..69697a0b4be 100644
--- a/crate-status.md
+++ b/crate-status.md
@@ -619,7 +619,7 @@ Provide a native SSH transport and authentication backend so `gix` users can shi
 
 A mechanism to associate metadata with any object, and keep revisions of it using git itself.
 
-* [ ] CRUD for git notes
+* [x] CRUD for git notes
 
 ### gix-negotiate
 * **algorithms**
diff --git a/gix-note/src/lib.rs b/gix-note/src/lib.rs
index f9216e7806a..97df93c0f70 100644
--- a/gix-note/src/lib.rs
+++ b/gix-note/src/lib.rs
@@ -3,13 +3,17 @@
 #![forbid(unsafe_code)]
 #![deny(missing_docs)]
 
-use std::{cmp::Ordering, collections::HashMap};
+use std::{
+    cmp::Ordering,
+    collections::{BTreeMap, HashMap},
+};
 
-use gix_error::{ResultExt, message};
+use gix_error::{ErrorExt, ResultExt, message};
 use gix_hash::{ObjectId, oid};
 use gix_object::{
-    Find, FindExt, Tree,
-    bstr::{BStr, ByteSlice},
+    Find, FindExt, Tree, Write,
+    bstr::{BStr, BString, ByteSlice},
+    tree::{Editor, EntryKind, EntryMode},
 };
 
 /// The error returned by note operations.
@@ -38,6 +42,15 @@ impl Cache {
     }
 }
 
+/// The result of changing one note mapping.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub struct Edit {
+    /// The root tree containing the changed notes.
+    pub tree: ObjectId,
+    /// The note which was replaced or removed.
+    pub previous: Option<ObjectId>,
+}
+
 /// Return the blob associated with `object` in the notes tree at `root`.
 ///
 /// Trees are loaded lazily along the progressive two-hex-digit fanout path and
@@ -64,6 +77,192 @@ pub fn get(root: ObjectId, object: &oid, objects: &impl Find, cache: &mut Cache)
     }
 }
 
+/// Add or replace the note for `object`, returning the new root tree and any
+/// previous note.
+///
+/// The notes tree is rewritten with the same progressive fanout heuristic as
+/// Git while retaining entries that are not notes.
+pub fn add(
+    root: ObjectId,
+    object: ObjectId,
+    note: ObjectId,
+    objects: &(impl Find + Write),
+    cache: &mut Cache,
+) -> Result<Edit, Error> {
+    if object.kind() != root.kind() || note.kind() != root.kind() {
+        return Err(message("Notes, annotated objects, and their root tree must use the same hash kind").raise());
+    }
+    edit(root, object, Some(note), objects, cache)
+}
+
+/// Remove the note for `object`, returning the new root tree and removed note.
+///
+/// If there is no such note, the root is returned unchanged.
+pub fn remove(
+    root: ObjectId,
+    object: ObjectId,
+    objects: &(impl Find + Write),
+    cache: &mut Cache,
+) -> Result<Edit, Error> {
+    if object.kind() != root.kind() {
+        return Err(message("The annotated object and notes root tree must use the same hash kind").raise());
+    }
+    edit(root, object, None, objects, cache)
+}
+
+fn edit(
+    root: ObjectId,
+    object: ObjectId,
+    note: Option<ObjectId>,
+    objects: &(impl Find + Write),
+    cache: &mut Cache,
+) -> Result<Edit, Error> {
+    let mut notes = BTreeMap::new();
+    let mut non_notes = Vec::new();
+    collect(
+        root,
+        BString::default(),
+        Vec::new(),
+        objects,
+        cache,
+        &mut notes,
+        &mut non_notes,
+    )?;
+    let previous = match note {
+        Some(note) => notes.insert(object, note),
+        None => notes.remove(&object),
+    };
+    if note.is_none() && previous.is_none() {
+        return Ok(Edit { tree: root, previous });
+    }
+    let tree = write(notes, non_notes, root.kind(), objects)?;
+    Ok(Edit { tree, previous })
+}
+
+#[derive(Clone)]
+struct NonNote {
+    path: Vec<BString>,
+    mode: EntryMode,
+    oid: ObjectId,
+}
+
+fn collect(
+    tree_id: ObjectId,
+    hex_prefix: BString,
+    path_prefix: Vec<BString>,
+    objects: &impl Find,
+    cache: &mut Cache,
+    notes: &mut BTreeMap<ObjectId, ObjectId>,
+    non_notes: &mut Vec<NonNote>,
+) -> Result<(), Error> {
+    let entries = cache.tree(tree_id, objects)?.entries.clone();
+    let hex_len = tree_id.kind().len_in_hex();
+    for entry in entries {
+        let mut path = path_prefix.clone();
+        path.push(entry.filename.clone());
+        if entry.mode.is_blob() && entry.filename.len() + hex_prefix.len() == hex_len {
+            let mut hex = hex_prefix.clone();
+            hex.extend_from_slice(&entry.filename);
+            if let Ok(object) = ObjectId::from_hex(&hex) {
+                if notes.insert(object, entry.oid).is_some() {
+                    return Err(message!("Multiple notes map to object {object}").raise());
+                }
+                continue;
+            }
+        }
+        if entry.mode.is_tree()
+            && entry.filename.len() == 2
+            && hex_prefix.len() + 2 < hex_len
+            && entry.filename.iter().all(u8::is_ascii_hexdigit)
+        {
+            let mut prefix = hex_prefix.clone();
+            prefix.extend_from_slice(&entry.filename);
+            collect(entry.oid, prefix, path, objects, cache, notes, non_notes)?;
+        } else {
+            non_notes.push(NonNote {
+                path,
+                mode: entry.mode,
+                oid: entry.oid,
+            });
+        }
+    }
+    Ok(())
+}
+
+fn write(
+    notes: BTreeMap<ObjectId, ObjectId>,
+    non_notes: Vec<NonNote>,
+    hash: gix_hash::Kind,
+    objects: &(impl Find + Write),
+) -> Result<ObjectId, Error> {
+    let mut editor = Editor::new(Tree { entries: Vec::new() }, objects, hash);
+    for entry in non_notes {
+        editor
+            .upsert(entry.path.iter(), entry.mode.kind(), entry.oid)
+            .or_raise(|| message("Could not restore a non-note tree entry"))?;
+    }
+
+    let hexes: Vec<_> = notes.keys().map(|id| id.to_hex().to_string()).collect();
+    let masks = fanout_masks(&hexes);
+    for ((_, note), hex) in notes.into_iter().zip(hexes) {
+        let fanout = fanout(&hex, &masks);
+        let path = note_path(&hex, fanout);
+        editor
+            .upsert(path.split_str("/"), EntryKind::Blob, note)
+            .or_raise(|| message("Could not add a note tree entry"))?;
+    }
+    editor
+        .write(|tree| {
+            objects
+                .write(tree)
+                .map_err(|err| message!("Could not write tree object: {err}").raise())
+        })
+        .or_raise(|| message("Could not write the notes tree"))
+}
+
+fn fanout_masks(hexes: &[String]) -> HashMap<BString, u16> {
+    let mut out = HashMap::new();
+    for hex in hexes {
+        let bytes = hex.as_bytes();
+        for offset in (0..bytes.len().saturating_sub(2)).step_by(2) {
+            let Some(nibble) = hex_nibble(bytes[offset]) else {
+                continue;
+            };
+            *out.entry(BString::from(&bytes[..offset])).or_default() |= 1 << nibble;
+        }
+    }
+    out
+}
+
+fn fanout(hex: &str, masks: &HashMap<BString, u16>) -> usize {
+    let mut fanout = 0;
+    while fanout * 2 < hex.len().saturating_sub(2)
+        && masks.get(BStr::new(&hex.as_bytes()[..fanout * 2])) == Some(&u16::MAX)
+    {
+        fanout += 1;
+    }
+    fanout
+}
+
+fn hex_nibble(byte: u8) -> Option<u8> {
+    match byte {
+        b'0'..=b'9' => Some(byte - b'0'),
+        b'a'..=b'f' => Some(byte - b'a' + 10),
+        b'A'..=b'F' => Some(byte - b'A' + 10),
+        _ => None,
+    }
+}
+
+fn note_path(hex: &str, fanout: usize) -> BString {
+    let mut out = BString::new(Vec::with_capacity(hex.len() + fanout));
+    for component in hex.as_bytes()[..fanout * 2].chunks_exact(2) {
+        out.extend_from_slice(component);
+        out.push(b'/');
+    }
+    out.extend_from_slice(&hex.as_bytes()[fanout * 2..]);
+    out
+}
+
 fn entry<'a>(tree: &'a Tree, name: &BStr, is_tree: bool) -> Option<&'a gix_object::tree::Entry> {
     tree.entries
         .binary_search_by(|candidate| cmp_entry_with_name(candidate, name, is_tree))
@@ -151,4 +350,61 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn mutations_rebalance_like_git_and_preserve_non_notes() -> gix_testtools::Result {
+        let objects = gix_odb::memory::Proxy::new(gix_object::find::Never, Kind::Sha1);
+        let unrelated = objects.write_buf(gix_object::Kind::Blob, b"keep")?;
+        let note = objects.write_buf(gix_object::Kind::Blob, b"note")?;
+        let mut root = objects.write(&Tree {
+            entries: vec![Entry {
+                mode: EntryKind::Blob.into(),
+                filename: "README".into(),
+                oid: unrelated,
+            }],
+        })?;
+        let mut annotated = Vec::new();
+        let mut cache = Cache::default();
+        for nibble in b"0123456789abcdef" {
+            let mut hex = vec![b'0'; Kind::Sha1.len_in_hex()];
+            hex[0] = *nibble;
+            let object = ObjectId::from_hex(&hex)?;
+            annotated.push(object);
+            root = add(root, object, note, &objects, &mut cache)
+                .map_err(gix_error::Exn::into_error)?
+                .tree;
+        }
+
+        let mut buf = Vec::new();
+        let tree = objects.find_tree(&root, &mut buf)?;
+        assert_eq!(
+            tree.entries.iter().filter(|entry| entry.mode.is_tree()).count(),
+            16,
+            "covering all first nibbles causes Git's first fanout level"
+        );
+        assert!(
+            tree.entries
+                .iter()
+                .any(|entry| entry.filename == "README" && entry.oid == unrelated),
+            "non-note entries survive rebalancing"
+        );
+
+        let replacement = objects.write_buf(gix_object::Kind::Blob, b"replacement")?;
+        let outcome = add(root, annotated[0], replacement, &objects, &mut cache).map_err(gix_error::Exn::into_error)?;
+        assert_eq!(
+            outcome.previous,
+            Some(note),
+            "overwriting naturally returns the previous note"
+        );
+        let outcome = remove(outcome.tree, annotated[0], &objects, &mut cache).map_err(gix_error::Exn::into_error)?;
+        assert_eq!(outcome.previous, Some(replacement), "removal returns the removed note");
+        let mut buf = Vec::new();
+        let tree = objects.find_tree(&outcome.tree, &mut buf)?;
+        assert_eq!(
+            tree.entries.iter().filter(|entry| entry.mode.is_blob()).count(),
+            16,
+            "dropping one leading nibble collapses the remaining notes to the root beside README"
+        );
+        Ok(())
+    }
 }

From a3c6528c8cef655e2756199a0661c132f306981b Mon Sep 17 00:00:00 2001
From: Byron <sebastian.thiel@icloud.com>
Date: Thu, 30 Jul 2026 14:24:37 +0200
Subject: [PATCH 003/282] feat: expose repository notes

Add the notes feature and Repository::notes as the porcelain layer over gix-note for repeated queries and mutations.

Select the default notes ref from core.notesRef, including the GIT_NOTES_REF environment override represented in config::tree, and fall back to refs/notes/commits. Discover additional display refs from notes.displayRef or GIT_NOTES_DISPLAY_REF, expand glob patterns, preserve display order, and avoid duplicates.

Retain lazily resolved notes roots and the shared decoded-tree cache so querying all visible commits does not repeatedly traverse the same trees. Return attached note blobs together with their source refs and allow callers to replace the displayed ref set.

For mutations, accept conventional short notes-ref names, write note blobs and notes commits, and update refs with compare-and-swap expectations so concurrent changes are not silently overwritten. Keep cached roots coherent after edits and cover configured-ref lookup, replacement, and removal through the repository API.
---
 Cargo.lock                           |   1 +
 crate-status.md                      |   2 +-
 gix/Cargo.toml                       |   9 +-
 gix/src/config/cache/init.rs         |   4 +
 gix/src/config/tree/sections/core.rs |   4 +
 gix/src/lib.rs                       |   4 +
 gix/src/note.rs                      | 272 +++++++++++++++++++++++++++
 gix/src/repository/mod.rs            |   2 +
 gix/src/repository/note.rs           |   8 +
 gix/tests/gix/repository/mod.rs      |   2 +
 gix/tests/gix/repository/note.rs     |  46 +++++
 11 files changed, 352 insertions(+), 2 deletions(-)
 create mode 100644 gix/src/note.rs
 create mode 100644 gix/src/repository/note.rs
 create mode 100644 gix/tests/gix/repository/note.rs

diff --git a/Cargo.lock b/Cargo.lock
index c7bf17d2313..8bc0c36cdae 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1573,6 +1573,7 @@ dependencies = [
  "gix-mailmap",
  "gix-merge",
  "gix-negotiate",
+ "gix-note",
  "gix-object",
  "gix-odb",
  "gix-pack",
diff --git a/crate-status.md b/crate-status.md
index 69697a0b4be..1a3c43102ae 100644
--- a/crate-status.md
+++ b/crate-status.md
@@ -98,7 +98,7 @@ The top-level crate that acts as hub to all functionality provided by the `gix-*
         * [x] use credential helper configuration and to obtain credentials with `gix_credentials::helper::Cascade`
     * **traverse**
         * [x] commit graphs
-        * [ ] make [git-notes](https://git-scm.com/docs/git-notes) accessible
+        * [x] make [git-notes](https://git-scm.com/docs/git-notes) accessible
         * [x] tree entries
     * **diffs/changes**
         * [x] tree with other tree
diff --git a/gix/Cargo.toml b/gix/Cargo.toml
index 53845b1639c..452b35d5987 100644
--- a/gix/Cargo.toml
+++ b/gix/Cargo.toml
@@ -68,7 +68,8 @@ extras = [
     "status",
     "dirwalk",
     "blame",
-    "merge"
+    "merge",
+    "notes",
 ]
 
 ## Various progress-related features that improve the look of progress message units.
@@ -89,6 +90,7 @@ comfort = [
 sha1 = [
     "gix-hash/sha1",
     "gix-pack/sha1",
+    "gix-note?/sha1",
     "gix-worktree-stream?/sha1",
 ]
 
@@ -97,6 +99,7 @@ sha256 = [
     "gix-hash/sha256",
     "gix-object/sha256",
     "gix-pack/sha256",
+    "gix-note?/sha256",
     "gix-worktree-stream?/sha256",
 ]
 
@@ -144,6 +147,9 @@ attributes = [
 ## Add support for mailmaps, as way of determining the final name of commmiters and authors.
 mailmap = ["dep:gix-mailmap", "revision"]
 
+## Read and mutate Git notes.
+notes = ["dep:gix-note"]
+
 ## Make revspec parsing possible, as well describing revision.
 revision = ["gix-revision/describe", "gix-revision/merge_base", "index"]
 
@@ -357,6 +363,7 @@ gix-traverse = { version = "^0.60.0", path = "../gix-traverse" }
 gix-diff = { version = "^0.66.0", path = "../gix-diff", default-features = false }
 gix-merge = { version = "^0.19.0", path = "../gix-merge", default-features = false, optional = true }
 gix-mailmap = { version = "^0.33.2", path = "../gix-mailmap", optional = true }
+gix-note = { version = "^0.0.0", path = "../gix-note", optional = true }
 gix-features = { version = "^0.49.0", path = "../gix-features", features = [
     "progress",
     "once_cell",
diff --git a/gix/src/config/cache/init.rs b/gix/src/config/cache/init.rs
index d28be822e33..7b6995c5939 100644
--- a/gix/src/config/cache/init.rs
+++ b/gix/src/config/cache/init.rs
@@ -401,6 +401,10 @@ fn apply_environment_overrides(
                     let key = &Core::WORKTREE;
                     (env(key), key.name)
                 },
+                {
+                    let key = &Core::NOTES_REF;
+                    (env(key), key.name)
+                },
                 {
                     let key = &Core::EDITOR;
                     (env(key), key.name)
diff --git a/gix/src/config/tree/sections/core.rs b/gix/src/config/tree/sections/core.rs
index 1b0bb5d1234..9962cbd871c 100644
--- a/gix/src/config/tree/sections/core.rs
+++ b/gix/src/config/tree/sections/core.rs
@@ -44,6 +44,9 @@ impl Core {
         keys::LockTimeout::new_lock_timeout("packedRefsTimeout", &config::Tree::CORE);
     /// The `core.multiPackIndex` key.
     pub const MULTIPACK_INDEX: keys::Boolean = keys::Boolean::new_boolean("multiPackIndex", &config::Tree::CORE);
+    /// The `core.notesRef` key.
+    pub const NOTES_REF: keys::Any =
+        keys::Any::new("notesRef", &config::Tree::CORE).with_environment_override("GIT_NOTES_REF");
     /// The `core.logAllRefUpdates` key.
     pub const LOG_ALL_REF_UPDATES: LogAllRefUpdates =
         LogAllRefUpdates::new_with_validate("logAllRefUpdates", &config::Tree::CORE, validate::LogAllRefUpdates);
@@ -125,6 +128,7 @@ impl Section for Core {
             &Self::FILES_REF_LOCK_TIMEOUT,
             &Self::PACKED_REFS_TIMEOUT,
             &Self::MULTIPACK_INDEX,
+            &Self::NOTES_REF,
             &Self::LOG_ALL_REF_UPDATES,
             &Self::PRECOMPOSE_UNICODE,
             &Self::REPOSITORY_FORMAT_VERSION,
diff --git a/gix/src/lib.rs b/gix/src/lib.rs
index fd3d54be4dd..7d1d1066cca 100644
--- a/gix/src/lib.rs
+++ b/gix/src/lib.rs
@@ -467,6 +467,10 @@ pub mod config;
 #[cfg(feature = "mailmap")]
 pub mod mailmap;
 
+///
+#[cfg(feature = "notes")]
+pub mod note;
+
 ///
 pub mod worktree;
 
diff --git a/gix/src/note.rs b/gix/src/note.rs
new file mode 100644
index 00000000000..0d4d36030c7
--- /dev/null
+++ b/gix/src/note.rs
@@ -0,0 +1,272 @@
+//! Access Git notes.
+
+pub use gix_note::*;
+
+use gix_error::{ErrorExt, ResultExt, message};
+
+use crate::{
+    Blob, Repository,
+    bstr::{BStr, BString, ByteSlice, ByteVec},
+    config::tree::Core,
+    refs::{FullName, transaction::PreviousValue},
+};
+
+/// A note and the reference from which it originated.
+pub struct Note<'a> {
+    /// The source notes reference.
+    pub reference: FullName,
+    /// The note blob.
+    pub blob: Blob<'a>,
+}
+
+/// Cached access to one or more notes references.
+pub struct Platform {
+    pub(crate) repo: Repository,
+    pub(crate) default_ref: Option<FullName>,
+    pub(crate) refs: Vec<FullName>,
+    pub(crate) roots: Vec<Option<Option<gix_hash::ObjectId>>>,
+    pub(crate) cache: gix_note::Cache,
+}
+
+impl Platform {
+    pub(crate) fn new(repo: Repository) -> Result<Self, Error> {
+        let default_ref = match repo.config_snapshot().string(Core::NOTES_REF) {
+            Some(value) if value.is_empty() => None,
+            Some(value) => Some(
+                FullName::try_from(value)
+                    .or_raise(|| message("core.notesRef must be a fully qualified reference name"))?,
+            ),
+            None => Some(
+                FullName::try_from("refs/notes/commits")
+                    .expect("the standard notes reference is a valid full reference name"),
+            ),
+        };
+        let mut refs = default_ref.iter().cloned().collect::<Vec<_>>();
+        let display_from_environment = repo
+            .open_options()
+            .permissions
+            .env
+            .git_prefix
+            .check_opt("GIT_NOTES_DISPLAY_REF")
+            .and_then(std::env::var_os);
+        let display_refs = match display_from_environment {
+            Some(value) => {
+                let value = gix_path::os_string_into_bstring(value)
+                    .or_raise(|| message("GIT_NOTES_DISPLAY_REF is not representable as bytes"))?;
+                value
+                    .split(|byte| *byte == b':')
+                    .filter(|value| !value.is_empty())
+                    .map(BString::from)
+                    .collect()
+            }
+            None => repo
+                .config_snapshot()
+                .plumbing()
+                .strings("notes.displayRef")
+                .unwrap_or_default(),
+        };
+        for pattern in display_refs {
+            add_refs(&repo, pattern.as_bstr(), &mut refs)?;
+        }
+        let roots = vec![None; refs.len()];
+        Ok(Platform {
+            repo,
+            default_ref,
+            refs,
+            roots,
+            cache: Default::default(),
+        })
+    }
+
+    /// Replace configured display references with `refs`.
+    pub fn with_refs(mut self, refs: impl IntoIterator<Item = impl Into<BString>>) -> Result<Self, Error> {
+        let mut selected = Vec::new();
+        for pattern in refs {
+            let pattern = pattern.into();
+            add_refs(&self.repo, pattern.as_bstr(), &mut selected)?;
+        }
+        self.roots = vec![None; selected.len()];
+        self.refs = selected;
+        Ok(self)
+    }
+
+    /// Return the default notes reference selected by configuration.
+    pub fn default_ref(&self) -> Option<&gix_ref::FullNameRef> {
+        self.default_ref.as_ref().map(AsRef::as_ref)
+    }
+
+    /// Return all notes associated with `object` in configured display order.
+    pub fn get(&mut self, object: impl Into<gix_hash::ObjectId>) -> Result<Vec<Note<'_>>, Error> {
+        let object = object.into();
+        let mut found = Vec::new();
+        for index in 0..self.refs.len() {
+            let Some(root) = self.root(index)? else { continue };
+            if let Some(note) = gix_note::get(root, &object, &self.repo, &mut self.cache)
+                .or_raise(|| message!("Could not find notes for {object}"))?
+            {
+                found.push((self.refs[index].clone(), note));
+            }
+        }
+        found
+            .into_iter()
+            .map(|(reference, id)| {
+                let blob = self
+                    .repo
+                    .find_blob(id)
+                    .or_raise(|| message!("Could not load note {id} from {reference}"))?;
+                Ok(Note { reference, blob })
+            })
+            .collect()
+    }
+
+    /// Add or replace a note in `notes_ref`, returning the previous note id.
+    pub fn add(
+        &mut self,
+        notes_ref: impl Into<BString>,
+        object: impl Into<gix_hash::ObjectId>,
+        data: impl AsRef<[u8]>,
+    ) -> Result<Option<gix_hash::ObjectId>, Error> {
+        let notes_ref = expand_notes_ref(notes_ref.into())?;
+        let (root, parent) = self.edit_root(notes_ref.as_ref())?;
+        let object = object.into();
+        let note = self
+            .repo
+            .write_blob(data)
+            .or_raise(|| message!("Could not write note for {object}"))?
+            .detach();
+        let edit = gix_note::add(root, object, note, &self.repo, &mut self.cache)
+            .or_raise(|| message!("Could not add note for {object}"))?;
+        self.commit_edit(notes_ref, parent, edit, "Notes added by gitoxide")?;
+        Ok(edit.previous)
+    }
+
+    /// Remove a note in `notes_ref`, returning the removed note id.
+    pub fn remove(
+        &mut self,
+        notes_ref: impl Into<BString>,
+        object: impl Into<gix_hash::ObjectId>,
+    ) -> Result<Option<gix_hash::ObjectId>, Error> {
+        let notes_ref = expand_notes_ref(notes_ref.into())?;
+        let (root, parent) = self.edit_root(notes_ref.as_ref())?;
+        let object = object.into();
+        let edit = gix_note::remove(root, object, &self.repo, &mut self.cache)
+            .or_raise(|| message!("Could not remove note for {object}"))?;
+        if edit.previous.is_some() {
+            self.commit_edit(notes_ref, parent, edit, "Notes removed by gitoxide")?;
+        }
+        Ok(edit.previous)
+    }
+
+    fn root(&mut self, index: usize) -> Result<Option<gix_hash::ObjectId>, Error> {
+        if let Some(root) = self.roots[index] {
+            return Ok(root);
+        }
+        let name = self.refs[index].clone();
+        let root = match self
+            .repo
+            .try_find_reference(name.as_ref())
+            .or_raise(|| message!("Could not find notes reference {name}"))?
+        {
+            Some(mut reference) => Some(
+                reference
+                    .peel_to_tree()
+                    .or_raise(|| message!("Could not peel notes reference {name} to a tree"))?
+                    .id,
+            ),
+            None => None,
+        };
+        self.roots[index] = Some(root);
+        Ok(root)
+    }
+
+    fn edit_root(
+        &self,
+        notes_ref: &gix_ref::FullNameRef,
+    ) -> Result<(gix_hash::ObjectId, Option<gix_hash::ObjectId>), Error> {
+        match self
+            .repo
+            .try_find_reference(notes_ref)
+            .or_raise(|| message!("Could not find notes reference {notes_ref}"))?
+        {
+            Some(mut reference) => {
+                let parent = reference
+                    .try_id()
+                    .ok_or_else(|| message!("Notes reference {notes_ref} must be direct").raise())?
+                    .detach();
+                let root = reference
+                    .peel_to_tree()
+                    .or_raise(|| message!("Could not peel notes reference {notes_ref} to a tree"))?
+                    .id;
+                Ok((root, Some(parent)))
+            }
+            None => Ok((gix_hash::ObjectId::empty_tree(self.repo.object_hash()), None)),
+        }
+    }
+
+    fn commit_edit(
+        &mut self,
+        notes_ref: FullName,
+        parent: Option<gix_hash::ObjectId>,
+        edit: gix_note::Edit,
+        message: &str,
+    ) -> Result<(), Error> {
+        let commit = self
+            .repo
+            .new_commit(message, edit.tree, parent)
+            .or_raise(|| message!("Could not create commit for {notes_ref}"))?;
+        let expected = parent.map_or(PreviousValue::MustNotExist, |id| {
+            PreviousValue::MustExistAndMatch(gix_ref::Target::Object(id))
+        });
+        self.repo
+            .reference(notes_ref.as_ref(), commit.id, expected, format!("notes: {message}"))
+            .or_raise(|| message!("Could not update notes reference {notes_ref}"))?;
+        for (index, reference) in self.refs.iter().enumerate() {
+            if reference == &notes_ref {
+                self.roots[index] = Some(Some(edit.tree));
+            }
+        }
+        Ok(())
+    }
+}
+
+fn add_refs(repo: &Repository, pattern: &BStr, out: &mut Vec<FullName>) -> Result<(), Error> {
+    let parsed =
+        gix_glob::parse(pattern).ok_or_else(|| message("Notes display references must not be empty").raise())?;
+    if parsed.first_wildcard_pos.is_some() {
+        let platform = repo
+            .references()
+            .or_raise(|| message!("Could not iterate notes references matching {pattern}"))?;
+        let references = platform
+            .all()
+            .or_raise(|| message!("Could not iterate notes references matching {pattern}"))?;
+        for reference in references {
+            let reference = reference.map_err(|err| message!("Could not read reference: {err}").raise())?;
+            if parsed.matches(reference.name().as_bstr(), gix_glob::wildmatch::Mode::empty()) {
+                push_unique(out, reference.inner.name);
+            }
+        }
+    } else {
+        push_unique(
+            out,
+            FullName::try_from(pattern)
+                .or_raise(|| message!("Notes display reference {pattern} is not fully qualified"))?,
+        );
+    }
+    Ok(())
+}
+
+fn push_unique(out: &mut Vec<FullName>, reference: FullName) {
+    if !out.contains(&reference) {
+        out.push(reference);
+    }
+}
+
+fn expand_notes_ref(mut name: BString) -> Result<FullName, Error> {
+    if name.starts_with_str("refs/notes/") {
+    } else if name.starts_with_str("notes/") {
+        name.insert_str(0, "refs/");
+    } else {
+        name.insert_str(0, "refs/notes/");
+    }
+    FullName::try_from(name).or_raise(|| message("The notes reference name is invalid"))
+}
diff --git a/gix/src/repository/mod.rs b/gix/src/repository/mod.rs
index 1114a55291d..19f52b27aa7 100644
--- a/gix/src/repository/mod.rs
+++ b/gix/src/repository/mod.rs
@@ -49,6 +49,8 @@ mod mailmap;
 ///
 #[cfg(feature = "merge")]
 mod merge;
+#[cfg(feature = "notes")]
+mod note;
 mod object;
 #[cfg(feature = "attributes")]
 mod pathspec;
diff --git a/gix/src/repository/note.rs b/gix/src/repository/note.rs
new file mode 100644
index 00000000000..0e054ab5e9e
--- /dev/null
+++ b/gix/src/repository/note.rs
@@ -0,0 +1,8 @@
+use crate::note;
+
+impl crate::Repository {
+    /// Return a platform for repeated Git notes queries and mutations.
+    pub fn notes(&self) -> Result<note::Platform, note::Error> {
+        note::Platform::new(self.clone())
+    }
+}
diff --git a/gix/tests/gix/repository/mod.rs b/gix/tests/gix/repository/mod.rs
index f8f7a3fee9f..cda2ac57fc6 100644
--- a/gix/tests/gix/repository/mod.rs
+++ b/gix/tests/gix/repository/mod.rs
@@ -16,6 +16,8 @@ mod filter;
 mod mailmap;
 #[cfg(feature = "merge")]
 mod merge;
+#[cfg(feature = "notes")]
+mod note;
 mod object;
 mod open;
 #[cfg(feature = "attributes")]
diff --git a/gix/tests/gix/repository/note.rs b/gix/tests/gix/repository/note.rs
new file mode 100644
index 00000000000..3089f7cb203
--- /dev/null
+++ b/gix/tests/gix/repository/note.rs
@@ -0,0 +1,46 @@
+use gix::config::tree::Key;
+
+#[test]
+fn query_and_mutate_a_configured_notes_ref() -> crate::Result {
+    assert_eq!(
+        gix::config::tree::Core::NOTES_REF.environment_override(),
+        Some("GIT_NOTES_REF")
+    );
+
+    let (mut repo, _tmp) = crate::util::basic_rw_repo()?;
+    let mut config = repo.config_snapshot_mut();
+    config.set_value(&gix::config::tree::Core::NOTES_REF, "refs/notes/review")?;
+    config.set_value(&gix::config::tree::User::NAME, "user")?;
+    config.set_value(&gix::config::tree::User::EMAIL, "user@example.com")?;
+    config.commit()?;
+
+    let target = repo.write_blob(b"annotated")?.detach();
+    let mut notes = repo.notes().map_err(gix::Exn::into_error)?;
+    assert_eq!(
+        notes.default_ref().map(ToString::to_string).as_deref(),
+        Some("refs/notes/review")
+    );
+    assert!(notes.get(target).map_err(gix::Exn::into_error)?.is_empty());
+
+    assert_eq!(
+        notes.add("review", target, b"first").map_err(gix::Exn::into_error)?,
+        None
+    );
+    let found = notes.get(target).map_err(gix::Exn::into_error)?;
+    assert_eq!(found.len(), 1);
+    assert_eq!(found[0].reference.to_string(), "refs/notes/review");
+    assert_eq!(found[0].blob.data, b"first");
+    drop(found);
+
+    let previous = notes
+        .add("review", target, b"second")
+        .map_err(gix::Exn::into_error)?
+        .expect("the first note is replaced");
+    assert_eq!(repo.find_blob(previous)?.data, b"first");
+    assert_eq!(
+        notes.remove("review", target).map_err(gix::Exn::into_error)?,
+        Some(repo.write_blob(b"second")?.detach())
+    );
+    assert!(notes.get(target).map_err(gix::Exn::into_error)?.is_empty());
+    Ok(())
+}

From d17e434f2402e309bdb25e41556e204acde26ae0 Mon Sep 17 00:00:00 2001
From: Byron <sebastian.thiel@icloud.com>
Date: Sun, 16 Aug 2026 19:56:17 +0200
Subject: [PATCH 004/282] fix: prefer longest remote prefixes for tracking
 branches

<!-- agent -->
Remote-tracking references can be ambiguous when configured remote names contain
slashes. Prefer the longest matching remote namespace before reverse-mapping
its fetch refspecs, while retaining the all-remotes fallback for custom
destinations.
---
 gix/src/reference/remote.rs               | 34 +++++++--------
 gix/src/repository/config/branch.rs       | 52 +++++++++++++++++------
 gix/tests/gix/repository/config/remote.rs | 12 +++---
 3 files changed, 61 insertions(+), 37 deletions(-)

diff --git a/gix/src/reference/remote.rs b/gix/src/reference/remote.rs
index 35c658a92cc..2533a07fdbb 100644
--- a/gix/src/reference/remote.rs
+++ b/gix/src/reference/remote.rs
@@ -2,7 +2,7 @@ use gix_ref::{Category, FullName};
 
 use crate::{
     Reference,
-    bstr::ByteSlice,
+    bstr::{BStr, ByteSlice},
     remote,
     repository::{branch_remote_ref_name, branch_remote_tracking_ref_name},
 };
@@ -17,23 +17,10 @@ impl<'repo> Reference<'repo> {
         let (category, shortname) = self.name().category_and_short_name()?;
         match category {
             Category::RemoteBranch => {
-                if shortname.find_iter("/").take(2).count() == 1 {
-                    let slash_pos = shortname.find_byte(b'/').expect("it was just found");
-                    shortname[..slash_pos]
-                        .as_bstr()
-                        .to_str()
-                        .ok()
-                        .map(|n| remote::Name::Symbol(n.into()))
-                } else {
-                    let remotes = self.repo.remote_names();
-                    for slash_pos in shortname.rfind_iter("/") {
-                        let candidate = shortname[..slash_pos].as_bstr();
-                        if remotes.contains(candidate) {
-                            return candidate.to_str().ok().map(|n| remote::Name::Symbol(n.into()));
-                        }
-                    }
-                    None
-                }
+                let remotes = self.repo.remote_names();
+                remote_name_from_tracking_branch(shortname, &remotes)
+                    .and_then(|name| name.to_str().ok())
+                    .map(|name| remote::Name::Symbol(name.into()))
             }
             Category::LocalBranch => self.repo.branch_remote_name(shortname, direction),
             _ => None,
@@ -72,3 +59,14 @@ impl<'repo> Reference<'repo> {
         self.repo.branch_remote_tracking_ref_name(self.name(), direction)
     }
 }
+
+pub(crate) fn remote_name_from_tracking_branch<'a>(shortname: &'a BStr, remotes: &remote::Names) -> Option<&'a BStr> {
+    if shortname.find_iter("/").take(2).count() == 1 {
+        let slash_pos = shortname.find_byte(b'/').expect("it was just found");
+        return Some(shortname[..slash_pos].as_bstr());
+    }
+    shortname
+        .rfind_iter("/")
+        .map(|slash_pos| shortname[..slash_pos].as_bstr())
+        .find(|candidate| remotes.contains(*candidate))
+}
diff --git a/gix/src/repository/config/branch.rs b/gix/src/repository/config/branch.rs
index 254f2c7b738..23ce9e23f26 100644
--- a/gix/src/repository/config/branch.rs
+++ b/gix/src/repository/config/branch.rs
@@ -141,7 +141,8 @@ impl crate::Repository {
     /// the side of the remote, also called upstream branch.
     ///
     /// Return `Ok(None)` if there is no remote with fetch-refspecs that would match `tracking_branch` on the right-hand side,
-    /// or `Err` if the matches were ambiguous.
+    /// or `Err` if the matches were ambiguous. If the tracking branch starts with a configured remote name, the longest
+    /// such prefix wins before its fetch refspecs are reverse-mapped. Otherwise all remotes are searched as a fallback.
     ///
     /// ### Limitations
     ///
@@ -158,14 +159,17 @@ impl crate::Repository {
         }
 
         let null = self.object_hash().null();
-        let item_to_search = gix_refspec::match_group::Item {
-            full_ref_name: tracking_branch.as_bstr(),
-            target: &null,
-            object: None,
-        };
+        let remote_names = self.remote_names();
+        let preferred =
+            crate::reference::remote::remote_name_from_tracking_branch(tracking_branch.shorten(), &remote_names)
+                .filter(|name| remote_names.contains(*name))
+                .map(ToOwned::to_owned);
         let mut candidates = Vec::new();
         let mut ambiguous_remotes = Vec::new();
-        for remote_name in self.remote_names() {
+        for remote_name in preferred
+            .iter()
+            .chain(remote_names.iter().filter(|name| Some(*name) != preferred.as_ref()))
+        {
             let remote = self.find_remote(remote_name)?;
             let match_group = gix_refspec::MatchGroup::from_fetch_specs(
                 remote
@@ -173,7 +177,23 @@ impl crate::Repository {
                     .iter()
                     .map(|spec| spec.to_ref()),
             );
-            let out = match_group.match_rhs(Some(item_to_search).into_iter());
+            let out = match_group.match_rhs(
+                Some(gix_refspec::match_group::Item {
+                    full_ref_name: tracking_branch.as_bstr(),
+                    target: &null,
+                    object: None,
+                })
+                .into_iter(),
+            );
+            if preferred.as_ref() == Some(remote_name) {
+                return match &out.mappings[..] {
+                    [] => Ok(None),
+                    [one] => Ok(Some((source_ref_to_full_name(one.lhs.clone())?, remote))),
+                    [..] => Err(Error::AmbiguousRemotes {
+                        remotes: remote.name.into_iter().collect(),
+                    }),
+                };
+            }
             match &out.mappings[..] {
                 [] => {}
                 [one] => candidates.push((remote.clone(), one.lhs.clone().into_owned())),
@@ -183,12 +203,7 @@ impl crate::Repository {
 
         if candidates.len() == 1 {
             let (remote, candidate) = candidates.pop().expect("just checked for one entry");
-            let upstream_branch = match candidate {
-                gix_refspec::match_group::SourceRef::FullName(name) => gix_ref::FullName::try_from(name.into_owned())?,
-                gix_refspec::match_group::SourceRef::ObjectId(_) => {
-                    unreachable!("Such a reverse mapping isn't ever produced")
-                }
-            };
+            let upstream_branch = source_ref_to_full_name(candidate)?;
             return Ok(Some((upstream_branch, remote)));
         }
         if ambiguous_remotes.len() + candidates.len() > 1 {
@@ -262,6 +277,15 @@ impl crate::Repository {
     }
 }
 
+fn source_ref_to_full_name(source: gix_refspec::match_group::SourceRef<'_>) -> Result<FullName, gix_ref::name::Error> {
+    match source {
+        gix_refspec::match_group::SourceRef::FullName(name) => gix_ref::FullName::try_from(name.into_owned()),
+        gix_refspec::match_group::SourceRef::ObjectId(_) => {
+            unreachable!("Such a reverse mapping isn't ever produced")
+        }
+    }
+}
+
 fn matching_remote<'a>(
     lhs: &FullNameRef,
     specs: impl IntoIterator<Item = &'a gix_refspec::RefSpec>,
diff --git a/gix/tests/gix/repository/config/remote.rs b/gix/tests/gix/repository/config/remote.rs
index f4e73859896..efca211a5ab 100644
--- a/gix/tests/gix/repository/config/remote.rs
+++ b/gix/tests/gix/repository/config/remote.rs
@@ -181,13 +181,15 @@ mod branch_remote {
             assert_eq!(remote.name().expect("named remote").as_bstr(), expected_remote_name);
             assert_eq!(upstream.as_bstr(), "refs/heads/main");
         }
-        let err = repo
+        let (upstream, remote) = repo
             .upstream_branch_and_remote_for_tracking_branch("refs/remotes/with/two/slashes/main".try_into()?)
-            .unwrap_err();
+            .expect("mapping succeeds")
+            .expect("the longest remote prefix maps uniquely");
+        assert_eq!(upstream.as_bstr(), "refs/heads/main");
         assert_eq!(
-            err.to_string(),
-            "Found ambiguous remotes without 1:1 mapping or more than one match: with/two, with/two/slashes",
-            "we aren't very specific report an error just like Git does in case of multi-remote ambiguity"
+            remote.name().expect("named remote").as_bstr(),
+            "with/two/slashes",
+            "the longest configured remote prefix wins"
         );
 
         let (upstream, remote) = repo

From d07ed80f94261753791f0d819f85ae4b4d5b4670 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 14:10:41 +0200
Subject: [PATCH 005/282] feat: verify visible commit signatures in tix

Consolidates:
- feat: verify visible commit signatures in tix
- fix: color commit selections by signature status

Keep test repositories isolated from user, system, and environment configuration through a shared test-only opening helper.
---
 gix-tix/Cargo.toml     |   2 +-
 gix-tix/src/app.rs     | 107 ++++++++++++++++++++++++++++++++-
 gix-tix/src/history.rs |  16 +++--
 gix-tix/src/lib.rs     |  68 ++++++++++++++++++++-
 gix-tix/src/ui.rs      | 130 +++++++++++++++++++++++++++++++++++++----
 5 files changed, 303 insertions(+), 20 deletions(-)

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index a83a5c1e8ff..7386d02f175 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -25,7 +25,7 @@ sha256 = ["gix/sha256"]
 [dependencies]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
-gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["mailmap", "parallel", "revision"] }
+gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["mailmap", "parallel", "revision", "command"] }
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 
 [dev-dependencies]
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 4e3ba4f1051..6d5f466ad82 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -19,6 +19,7 @@ pub(crate) struct Commit<T> {
     pub attributions: Range<usize>,
     pub title: T,
     pub metadata_loaded: bool,
+    pub signature: SignatureState,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -27,6 +28,17 @@ pub(crate) struct Metadata<T> {
     pub author: &'static Author,
     pub attributions: Range<usize>,
     pub title: T,
+    pub signature: SignatureState,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum SignatureState {
+    #[default]
+    Unsigned,
+    Unverified,
+    Verifying,
+    Verified,
+    Failed,
 }
 
 #[derive(Debug, Eq, Hash, PartialEq)]
@@ -141,6 +153,7 @@ pub(crate) enum Action {
     ToggleHidden,
     ToggleAlign,
     ToggleCommit,
+    VerifySignatures,
     Cancel,
     Copy,
     CopyAuthor,
@@ -148,12 +161,13 @@ pub(crate) enum Action {
     Quit,
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum Effect {
     Cancel,
     CopyId(ObjectId),
     CopyAuthor(&'static Author),
     Reload(bool),
+    VerifySignatures(Vec<ObjectId>),
     Quit,
 }
 
@@ -188,6 +202,8 @@ pub(crate) struct App {
     horizontal_page: usize,
     horizontal_max: usize,
     follow_tail: bool,
+    pub(crate) signature_failures: usize,
+    signature_verification_running: bool,
 }
 
 impl App {
@@ -222,6 +238,8 @@ impl App {
             horizontal_page: 1,
             horizontal_max: 0,
             follow_tail: false,
+            signature_failures: 0,
+            signature_verification_running: false,
         }
     }
 
@@ -246,6 +264,7 @@ impl App {
                 attributions: attribution_base + row.attributions.start..attribution_base + row.attributions.end,
                 title: start..self.titles.len(),
                 metadata_loaded: row.metadata_loaded,
+                signature: row.signature,
             });
         }
         if was_empty {
@@ -273,6 +292,7 @@ impl App {
             author,
             attributions,
             title,
+            signature,
         } = metadata;
         let title_start = self.titles.len();
         self.titles.extend_from_slice(&title);
@@ -283,6 +303,7 @@ impl App {
         row.attributions = attribution_start + attributions.start..attribution_start + attributions.end;
         row.title = title_start..self.titles.len();
         row.metadata_loaded = true;
+        row.signature = signature;
     }
 
     pub(crate) fn title(&self, row: &CommitRow) -> &BStr {
@@ -328,7 +349,11 @@ impl App {
             Action::PageDown => self.move_selection(self.viewport_rows.max(1), true),
             Action::First => self.select(0),
             Action::Last if !self.rows.is_empty() => {
+                let previous = self.selected;
                 self.selected = Some(self.rows.len() - 1);
+                if self.selected != previous {
+                    self.retry_failed_signatures();
+                }
                 self.follow_tail = self.state == State::Loading;
                 self.ensure_visible();
             }
@@ -362,6 +387,22 @@ impl App {
             }
             Action::ToggleAlign => self.align_metadata = !self.align_metadata,
             Action::ToggleCommit => self.show_commit = !self.show_commit,
+            Action::VerifySignatures if !self.signature_verification_running => {
+                let start = self.offset.min(self.rows.len());
+                let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
+                let ids: Vec<_> = self.rows[start..end]
+                    .iter_mut()
+                    .filter(|row| row.signature == SignatureState::Unverified)
+                    .map(|row| {
+                        row.signature = SignatureState::Verifying;
+                        row.id
+                    })
+                    .collect();
+                if !ids.is_empty() {
+                    self.signature_verification_running = true;
+                    return vec![Effect::VerifySignatures(ids)];
+                }
+            }
             Action::PreviewAuthorCopy(value) => self.preview_author_copy = value,
             Action::Cancel if self.state == State::Loading => {
                 self.state = State::Cancelling;
@@ -429,6 +470,7 @@ impl App {
                             author: row.author,
                             attributions: row.attributions.clone(),
                             title: row.title.clone(),
+                            signature: row.signature,
                         },
                     )
                 })
@@ -444,6 +486,7 @@ impl App {
                 row.attributions = metadata.attributions.clone();
                 row.title = metadata.title.clone();
                 row.metadata_loaded = true;
+                row.signature = metadata.signature;
             }
         }
         self.graph = Some(graph);
@@ -468,6 +511,25 @@ impl App {
         self.show_hidden = show_hidden;
         self.horizontal_offset = 0;
         self.follow_tail = false;
+        self.signature_failures = 0;
+        self.signature_verification_running = false;
+    }
+
+    pub(crate) fn finish_signature_verification(&mut self, results: Vec<(ObjectId, bool)>) {
+        let mut failed = 0;
+        for (id, valid) in results {
+            let Some(row) = self.rows.iter_mut().find(|row| row.id == id) else {
+                continue;
+            };
+            row.signature = if valid {
+                SignatureState::Verified
+            } else {
+                failed += 1;
+                SignatureState::Failed
+            };
+        }
+        self.signature_verification_running = false;
+        self.signature_failures = failed;
     }
 
     fn move_selection(&mut self, distance: usize, down: bool) {
@@ -477,18 +539,34 @@ impl App {
         } else {
             selected.saturating_sub(distance)
         });
+        if self.selected != Some(selected) {
+            self.retry_failed_signatures();
+        }
         self.follow_tail = false;
         self.ensure_visible();
     }
 
     fn select(&mut self, selected: usize) {
         if !self.rows.is_empty() {
+            let previous = self.selected;
             self.selected = Some(selected.min(self.rows.len() - 1));
+            if self.selected != previous {
+                self.retry_failed_signatures();
+            }
             self.follow_tail = false;
             self.ensure_visible();
         }
     }
 
+    fn retry_failed_signatures(&mut self) {
+        for row in &mut self.rows {
+            if row.signature == SignatureState::Failed {
+                row.signature = SignatureState::Unverified;
+            }
+        }
+        self.signature_failures = 0;
+    }
+
     pub(crate) fn ensure_visible(&mut self) {
         let Some(selected) = self.selected else { return };
         let height = self.viewport_rows.max(1);
@@ -831,6 +909,7 @@ mod tests {
             attributions: 0..0,
             title: format!("commit {n}").into(),
             metadata_loaded: true,
+            signature: SignatureState::Unsigned,
         }
     }
 
@@ -958,6 +1037,7 @@ mod tests {
                 author: row(1).author,
                 attributions: 0..0,
                 title: "loaded".into(),
+                signature: SignatureState::Unsigned,
             },
             Vec::new(),
         );
@@ -968,6 +1048,31 @@ mod tests {
         assert_eq!(app.title(&app.rows[0]), "loaded");
     }
 
+    #[test]
+    fn verifies_only_visible_unchecked_signatures() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![row(1), row(2), row(3)]);
+        for row in &mut app.rows {
+            row.signature = SignatureState::Unverified;
+        }
+        app.offset = 1;
+
+        assert_eq!(
+            app.update(Action::VerifySignatures),
+            vec![Effect::VerifySignatures(vec![id(2), id(3)])]
+        );
+        assert_eq!(app.rows[0].signature, SignatureState::Unverified);
+        assert_eq!(app.rows[1].signature, SignatureState::Verifying);
+        app.finish_signature_verification(vec![(id(2), true), (id(3), false)]);
+        assert_eq!(app.rows[1].signature, SignatureState::Verified);
+        assert_eq!(app.rows[2].signature, SignatureState::Failed);
+        assert_eq!(app.signature_failures, 1);
+
+        app.update(Action::MoveDown);
+        assert_eq!(app.rows[2].signature, SignatureState::Unverified);
+        assert_eq!(app.signature_failures, 0);
+    }
+
     #[test]
     fn lane_reuses_a_parent_that_is_already_to_the_right() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 0b3d099dc9f..f683729aaa4 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -11,7 +11,7 @@ use gix::{
     objs::commit::ref_iter::Token,
 };
 
-use crate::app::{Attribution, AttributionKind, Author, Commit, LoadedCommits, Metadata};
+use crate::app::{Attribution, AttributionKind, Author, Commit, LoadedCommits, Metadata, SignatureState};
 
 pub(crate) type SharedAuthors = gix::features::threading::OwnShared<gix::features::threading::Mutable<Authors>>;
 static EMPTY_AUTHOR: std::sync::LazyLock<Author> = std::sync::LazyLock::new(|| Author {
@@ -96,11 +96,13 @@ pub(crate) fn load(
             author,
             attributions: row_attributions,
             title,
+            signature,
         } = metadata.unwrap_or_else(|| Metadata {
             committer_time: Default::default(),
             author: &EMPTY_AUTHOR,
             attributions: 0..0,
             title: BString::default(),
+            signature: SignatureState::Unsigned,
         });
         rows.push(Commit {
             id: info.id,
@@ -110,6 +112,7 @@ pub(crate) fn load(
             attributions: row_attributions,
             title,
             metadata_loaded,
+            signature,
         });
         if rows.len() == COMMIT_BATCH_SIZE
             && !emit(Event::Commits(LoadedCommits {
@@ -148,6 +151,7 @@ fn decode_metadata<'a>(
     let mut author = None;
     let attribution_start = attributions.len();
     let mut title = None;
+    let mut signature = SignatureState::Unsigned;
     for token in tokens {
         match token.context("could not decode commit")? {
             Token::Author { signature } => {
@@ -183,6 +187,9 @@ fn decode_metadata<'a>(
                     }
                 }
             }
+            Token::ExtraHeader((name, _)) if name == "gpgsig" || name == "gpgsig-sha256" => {
+                signature = SignatureState::Unverified;
+            }
             _ => {}
         }
     }
@@ -191,6 +198,7 @@ fn decode_metadata<'a>(
         author: author.context("commit has no author")?,
         attributions: attribution_start..attributions.len(),
         title: title.context("commit has no message")?,
+        signature,
     })
 }
 
@@ -357,7 +365,7 @@ mod tests {
         let mut events = Vec::new();
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let repo = gix::open(path)?;
+        let repo = crate::open_test_repository(path)?;
         load(
             &repo,
             &revisions.iter().map(OsString::from).collect::<Vec<_>>(),
@@ -460,7 +468,7 @@ mod tests {
             .current_dir(fixture_path)
             .env("GIT_AUTHOR_DATE", "2000-01-05T00:00:00 +0000")
             .env("GIT_COMMITTER_DATE", "2000-01-05T00:00:00 +0000")
-            .args(["commit", "-q", "-m", "new"])
+            .args(["-c", "commit.gpgSign=false", "commit", "-q", "-m", "new"])
             .status()?;
         assert!(commit.success(), "a commit newer than the graph is created");
 
@@ -481,7 +489,7 @@ mod tests {
             .find(|row| !row.metadata_loaded)
             .expect("older graph commits defer metadata");
 
-        let repo = gix::open(fixture_path)?;
+        let repo = crate::open_test_repository(fixture_path)?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
         let (metadata, _) = load_metadata(&repo, deferred.id, &authors)?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 61454821e58..939a2b684eb 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -8,7 +8,7 @@ mod ui;
 
 use std::{
     ffi::OsString,
-    path::Path,
+    path::{Path, PathBuf},
     sync::{
         Arc,
         atomic::{AtomicBool, Ordering},
@@ -258,6 +258,7 @@ fn event_loop(
 
     let mut app = App::new(1);
     let mut lane_receiver = None;
+    let mut verification_receiver = None;
     let mut commit_message = None;
     let mut fill_repository = FillRepository {
         path: &repository_path,
@@ -282,6 +283,19 @@ fn event_loop(
     let mut inline_terminal = None;
     let mut history_requires_alternate_screen = false;
     let result: Result<Option<Duration>> = (|| loop {
+        if let Some(result) = verification_receiver.as_ref().map(mpsc::Receiver::try_recv) {
+            match result {
+                Ok(results) => {
+                    app.finish_signature_verification(results);
+                    verification_receiver = None;
+                    dirty = true;
+                }
+                Err(mpsc::TryRecvError::Empty) => {}
+                Err(mpsc::TryRecvError::Disconnected) => {
+                    anyhow::bail!("signature verification worker stopped unexpectedly")
+                }
+            }
+        }
         if let Some(result) = lane_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
                 Ok((rows, graph, lane_time)) => {
@@ -358,7 +372,8 @@ fn event_loop(
             resize_inline,
             &mut inline_terminal,
         )?;
-        let streaming = matches!(app.state, State::Loading | State::Cancelling | State::Computing);
+        let streaming = matches!(app.state, State::Loading | State::Cancelling | State::Computing)
+            || verification_receiver.is_some();
         if should_draw(dirty, streaming, last_draw.elapsed()) {
             draw(
                 terminal,
@@ -424,6 +439,9 @@ fn event_loop(
                         gix::features::threading::OwnShared::clone(&authors),
                     );
                 }
+                Effect::VerifySignatures(ids) => {
+                    verification_receiver = Some(start_signature_verification(repository_path.clone(), ids));
+                }
                 Effect::Quit => {
                     if app.inline {
                         app.show_selection_tail = false;
@@ -467,6 +485,42 @@ fn start_lane_worker(rows: Vec<CommitRow>) -> mpsc::Receiver<(Vec<CommitRow>, ap
     receiver
 }
 
+type SignatureVerification = (gix::ObjectId, bool);
+
+fn start_signature_verification(
+    repository_path: PathBuf,
+    ids: Vec<gix::ObjectId>,
+) -> mpsc::Receiver<Vec<SignatureVerification>> {
+    let (sender, receiver) = mpsc::channel();
+    std::thread::spawn(move || {
+        let results = match gix::open(repository_path) {
+            Ok(mut repository) => {
+                repository.object_cache_size(None);
+                ids.into_iter()
+                    .map(|id| {
+                        let result = repository
+                            .find_commit(id)
+                            .context("could not read signed commit")
+                            .and_then(|commit| {
+                                commit
+                                    .verify_signature()
+                                    .context("could not verify commit signature")
+                                    .and_then(|outcome| outcome.context("commit no longer has a signature"))
+                            });
+                        match result {
+                            Ok(outcome) if outcome.is_valid() => (id, true),
+                            Ok(_) | Err(_) => (id, false),
+                        }
+                    })
+                    .collect()
+            }
+            Err(_) => ids.into_iter().map(|id| (id, false)).collect(),
+        };
+        let _ = sender.send(results);
+    });
+    receiver
+}
+
 fn start_history(
     repository: gix::ThreadSafeRepository,
     revisions: &[OsString],
@@ -618,6 +672,7 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Char('t') => Some(Action::ToggleTrailers),
         KeyCode::Char('m') => Some(Action::ToggleMailmap),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
+        KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHidden),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']' | 'o') => Some(Action::ToggleCommit),
@@ -646,6 +701,11 @@ fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>) -> bool
     kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
 }
 
+#[cfg(test)]
+fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::open::Error> {
+    gix::open_opts(path.as_ref(), gix::open::Options::isolated())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -788,6 +848,10 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE)),
             Some(Action::ToggleHidden)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)),
+            Some(Action::VerifySignatures)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('['), KeyModifiers::NONE)),
             Some(Action::ToggleAlign)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index cc182e9d504..f0ad7c736a7 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -8,7 +8,7 @@ use ratatui::{
 };
 
 use crate::{
-    app::{App, AttributionKind, CommitRow, CopyKind, NameMode, RefMode, State},
+    app::{App, AttributionKind, CommitRow, CopyKind, NameMode, RefMode, SignatureState, State},
     history::{DecorationKind, Decorations},
 };
 
@@ -42,6 +42,9 @@ pub(crate) fn draw(
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
     let visible_rows = &app.rows[start..end];
+    let has_verifiable_signatures = visible_rows
+        .iter()
+        .any(|row| matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying));
     let lanes = app.render_lanes(start..end);
     let content = Rect::new(
         body.x.saturating_add(2),
@@ -134,8 +137,9 @@ pub(crate) fn draw(
         let y = body.y.saturating_add(index as u16);
         let selected = app.selected == Some(start + index);
         let metadata_width = metadata.width();
+        let signature_color = signature_color(visible_rows[index].signature);
         let style = if selected {
-            Style::default().add_modifier(Modifier::REVERSED)
+            color(signature_color).add_modifier(Modifier::REVERSED)
         } else {
             Style::default()
         };
@@ -150,7 +154,14 @@ pub(crate) fn draw(
                 Paragraph::new(lane).style(style).scroll((0, graph_offset as u16)),
                 row_area,
             );
-            color_graph(frame, row_area, lane, graph_offset, selected);
+            color_graph(
+                frame,
+                row_area,
+                lane,
+                graph_offset,
+                selected,
+                visible_rows[index].signature,
+            );
             let aligned = Rect::new(
                 content.x.saturating_add(align_width as u16),
                 y,
@@ -167,7 +178,14 @@ pub(crate) fn draw(
                 Paragraph::new(Line::from(spans)).scroll((0, horizontal_offset as u16)),
                 row_area,
             );
-            color_graph(frame, row_area, lane, horizontal_offset, selected);
+            color_graph(
+                frame,
+                row_area,
+                lane,
+                horizontal_offset,
+                selected,
+                visible_rows[index].signature,
+            );
         }
         if selected && app.show_selection_tail && body.width > 0 {
             let line_width = if align_metadata {
@@ -238,6 +256,19 @@ pub(crate) fn draw(
     } else {
         " · y copy"
     }));
+    if app.signature_failures > 0 {
+        footer_spans.extend([
+            Span::raw(format!(" · s {} ", app.signature_failures)),
+            Span::styled("●", color(Color::Red)),
+        ]);
+    } else if has_verifiable_signatures {
+        footer_spans.extend([
+            Span::raw(" · s "),
+            Span::styled("●", color(Color::Rgb(255, 165, 0))),
+            Span::raw(" -> "),
+            Span::styled("●", color(Color::Green)),
+        ]);
+    }
     if app.state == State::Loading {
         footer_spans.push(Span::raw(" · Esc cancel"));
     }
@@ -496,23 +527,38 @@ fn color(color: Color) -> Style {
     Style::default().fg(color)
 }
 
-fn color_graph(frame: &mut Frame<'_>, area: Rect, graph: &str, offset: usize, selected: bool) {
+fn color_graph(
+    frame: &mut Frame<'_>,
+    area: Rect,
+    graph: &str,
+    offset: usize,
+    selected: bool,
+    signature: SignatureState,
+) {
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
             continue;
         }
-        let mut style = if symbol == '●' {
-            Style::default().fg(Color::Blue)
+        let style = if selected {
+            color(signature_color(signature)).add_modifier(Modifier::REVERSED)
+        } else if symbol == '●' {
+            color(signature_color(signature))
         } else {
             graph_style(offset.saturating_add(x) / 2)
         };
-        if selected {
-            style = style.add_modifier(Modifier::REVERSED);
-        }
         frame.buffer_mut()[(area.x + x as u16, area.y)].set_style(style);
     }
 }
 
+fn signature_color(signature: SignatureState) -> Color {
+    match signature {
+        SignatureState::Unsigned => Color::Blue,
+        SignatureState::Unverified | SignatureState::Verifying => Color::Rgb(255, 165, 0),
+        SignatureState::Verified => Color::Green,
+        SignatureState::Failed => Color::Red,
+    }
+}
+
 fn graph_style(column: usize) -> Style {
     const COLORS: [Color; 7] = [
         Color::Magenta,
@@ -573,6 +619,7 @@ mod tests {
                 attributions: 0..7,
                 title: "subject".into(),
                 metadata_loaded: true,
+                signature: SignatureState::Unsigned,
             }],
             attributions: vec![
                 Attribution {
@@ -678,6 +725,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
         let decorations = Decorations::from([(
@@ -705,7 +753,9 @@ mod tests {
         for x in 0..11 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
         }
-        expected[(2, 0)].set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
+        for x in 0..4 {
+            expected[(x, 0)].set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
+        }
         for x in 4..11 {
             expected[(x, 0)].set_style(
                 Style::default()
@@ -723,7 +773,7 @@ mod tests {
             expected[(x, 0)].set_style(Style::default().fg(Color::Green));
         }
         expected[(selected_line.chars().count() as u16 + 1, 0)]
-            .set_style(Style::default().add_modifier(Modifier::REVERSED));
+            .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         let commit = footer_text[..footer_text.find("o commit").expect("the commit toggle is present")]
             .chars()
             .count();
@@ -872,6 +922,7 @@ mod tests {
                     attributions: 0..0,
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
+                    signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
         );
@@ -932,6 +983,57 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn colors_commit_disks_by_signature_state() -> Result<(), Box<dyn std::error::Error>> {
+        let states = [
+            (SignatureState::Unsigned, Color::Blue),
+            (SignatureState::Unverified, Color::Rgb(255, 165, 0)),
+            (SignatureState::Verified, Color::Green),
+            (SignatureState::Failed, Color::Red),
+        ];
+        let mut terminal = Terminal::new(TestBackend::new(2, states.len() as u16))?;
+        terminal.draw(|frame| {
+            for (y, (state, _)) in states.iter().enumerate() {
+                color_graph(frame, Rect::new(0, y as u16, 2, 1), "●─", 0, true, *state);
+            }
+        })?;
+
+        for (y, (_, expected)) in states.iter().enumerate() {
+            for x in 0..2 {
+                let cell = &terminal.backend().buffer()[(x, y as u16)];
+                assert_eq!(cell.fg, *expected);
+                assert!(cell.modifier.contains(Modifier::REVERSED));
+            }
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn shows_signature_action_only_while_actionable() -> Result<(), Box<dyn std::error::Error>> {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            signature: SignatureState::Unverified,
+        }]);
+        complete(&mut app);
+        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_line(&terminal, 1).contains("s ● -> ●"));
+
+        app.finish_signature_verification(vec![(id, false)]);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_line(&terminal, 1).contains("s 1 ●"));
+        Ok(())
+    }
+
     #[test]
     fn advertises_cancel_only_while_loading() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
@@ -961,6 +1063,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            signature: SignatureState::Unsigned,
         }]);
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
 
@@ -1118,6 +1221,7 @@ mod tests {
                     attributions: 0..0,
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
+                    signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
         );
@@ -1166,6 +1270,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            signature: SignatureState::Unsigned,
         };
         let decorations = Decorations::from([(
             id,
@@ -1268,6 +1373,7 @@ mod tests {
             attributions: 0..0,
             title: format!("{} subject-tail", "a".repeat(50)).into(),
             metadata_loaded: true,
+            signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
         app.set_lane(0, &format!("{}{}", "A".repeat(40), "B".repeat(40)));

From 2109507ed318413371d6d8bffa9022ddb5fa24e7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 26 Jul 2026 11:11:43 +0200
Subject: [PATCH 006/282] feat: present commit authorship in tix

Improve attribution display while retaining access to complete actor identities.
Treat every Assisted-by trailer value as an agent, toggle full actors and
emails while hiding attribution comments, omit classified agent emails,
italicize GitHub noreply actors, and group attribution keys whose displayed
values are identical.

Detect agent markers in commit messages and prefix generated commit titles
with a bright-purple [A] marker shared with the Git notes marker.
---
 gix-tix/src/app.rs                |  53 ++++---
 gix-tix/src/history.rs            |  20 +++
 gix-tix/src/lib.rs                |   7 +-
 gix-tix/src/ui.rs                 | 242 ++++++++++++++++++++++++------
 gix-tix/tests/fixtures/history.sh |   4 +-
 5 files changed, 252 insertions(+), 74 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 6d5f466ad82..f8145801cb5 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -19,6 +19,7 @@ pub(crate) struct Commit<T> {
     pub attributions: Range<usize>,
     pub title: T,
     pub metadata_loaded: bool,
+    pub has_agent_marker: bool,
     pub signature: SignatureState,
 }
 
@@ -28,6 +29,7 @@ pub(crate) struct Metadata<T> {
     pub author: &'static Author,
     pub attributions: Range<usize>,
     pub title: T,
+    pub has_agent_marker: bool,
     pub signature: SignatureState,
 }
 
@@ -53,6 +55,13 @@ impl Author {
             .iter()
             .any(|candidate| self.email.eq_ignore_ascii_case(candidate))
     }
+
+    pub fn is_github_noreply(&self) -> bool {
+        let suffix = b"@users.noreply.github.com";
+        self.email
+            .get(self.email.len().saturating_sub(suffix.len())..)
+            .is_some_and(|email| email.eq_ignore_ascii_case(suffix))
+    }
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -63,15 +72,7 @@ pub(crate) struct Attribution {
 
 impl Attribution {
     pub fn is_agent(&self) -> bool {
-        self.author.is_bot()
-            || self.kind == AttributionKind::Assisted
-                && [b"opus".as_slice(), b"gpt".as_slice()].iter().any(|name| {
-                    self.author
-                        .name
-                        .get(..name.len())
-                        .is_some_and(|prefix| prefix.eq_ignore_ascii_case(name))
-                        && self.author.name.get(name.len()).is_none_or(u8::is_ascii_whitespace)
-                })
+        self.author.is_bot() || self.kind == AttributionKind::Assisted
     }
 }
 
@@ -147,6 +148,7 @@ pub(crate) enum Action {
     Last,
     ToggleDate,
     ToggleName,
+    ToggleEmail,
     ToggleTrailers,
     ToggleMailmap,
     ToggleRefs,
@@ -186,6 +188,7 @@ pub(crate) struct App {
     pub lane_time: Option<Duration>,
     pub show_committer_date: bool,
     pub name_mode: NameMode,
+    pub show_emails: bool,
     pub show_trailers: bool,
     pub use_mailmap: bool,
     pub ref_mode: RefMode,
@@ -222,6 +225,7 @@ impl App {
             lane_time: None,
             show_committer_date: true,
             name_mode: NameMode::All,
+            show_emails: false,
             show_trailers: true,
             use_mailmap: true,
             ref_mode: RefMode::Default,
@@ -264,6 +268,7 @@ impl App {
                 attributions: attribution_base + row.attributions.start..attribution_base + row.attributions.end,
                 title: start..self.titles.len(),
                 metadata_loaded: row.metadata_loaded,
+                has_agent_marker: row.has_agent_marker,
                 signature: row.signature,
             });
         }
@@ -292,6 +297,7 @@ impl App {
             author,
             attributions,
             title,
+            has_agent_marker,
             signature,
         } = metadata;
         let title_start = self.titles.len();
@@ -303,6 +309,7 @@ impl App {
         row.attributions = attribution_start + attributions.start..attribution_start + attributions.end;
         row.title = title_start..self.titles.len();
         row.metadata_loaded = true;
+        row.has_agent_marker = has_agent_marker;
         row.signature = signature;
     }
 
@@ -358,6 +365,7 @@ impl App {
                 self.ensure_visible();
             }
             Action::ToggleDate => self.show_committer_date = !self.show_committer_date,
+            Action::ToggleEmail => self.show_emails = !self.show_emails,
             Action::ToggleName => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -470,6 +478,7 @@ impl App {
                             author: row.author,
                             attributions: row.attributions.clone(),
                             title: row.title.clone(),
+                            has_agent_marker: row.has_agent_marker,
                             signature: row.signature,
                         },
                     )
@@ -486,6 +495,7 @@ impl App {
                 row.attributions = metadata.attributions.clone();
                 row.title = metadata.title.clone();
                 row.metadata_loaded = true;
+                row.has_agent_marker = metadata.has_agent_marker;
                 row.signature = metadata.signature;
             }
         }
@@ -909,6 +919,7 @@ mod tests {
             attributions: 0..0,
             title: format!("commit {n}").into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         }
     }
@@ -920,34 +931,23 @@ mod tests {
     }
 
     #[test]
-    fn recognizes_named_agents_only_when_assisting() {
-        let opus = Box::leak(Box::new(Author {
-            name: b"Opus 4.7".as_bstr(),
-            email: b"".as_bstr(),
-        }));
-        let gpt = Box::leak(Box::new(Author {
-            name: b"GPT 5.6".as_bstr(),
+    fn recognizes_all_assistants_as_agents() {
+        let assistant = Box::leak(Box::new(Author {
+            name: b"Anything".as_bstr(),
             email: b"".as_bstr(),
         }));
 
         assert!(
             Attribution {
                 kind: AttributionKind::Assisted,
-                author: opus,
-            }
-            .is_agent()
-        );
-        assert!(
-            Attribution {
-                kind: AttributionKind::Assisted,
-                author: gpt,
+                author: assistant,
             }
             .is_agent()
         );
         assert!(
             !Attribution {
                 kind: AttributionKind::Reviewed,
-                author: opus,
+                author: assistant,
             }
             .is_agent()
         );
@@ -1037,6 +1037,7 @@ mod tests {
                 author: row(1).author,
                 attributions: 0..0,
                 title: "loaded".into(),
+                has_agent_marker: false,
                 signature: SignatureState::Unsigned,
             },
             Vec::new(),
@@ -1196,6 +1197,7 @@ mod tests {
         assert!(app.show_trailers, "trailer attribution is visible by default");
 
         app.update(Action::ToggleDate);
+        app.update(Action::ToggleEmail);
         app.update(Action::ToggleName);
         app.update(Action::ToggleTrailers);
         app.update(Action::ToggleMailmap);
@@ -1204,6 +1206,7 @@ mod tests {
         app.update(Action::ToggleCommit);
 
         assert!(!app.show_committer_date);
+        assert!(app.show_emails);
         assert_eq!(app.name_mode, NameMode::None);
         assert!(!app.show_trailers);
         assert!(!app.use_mailmap);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index f683729aaa4..0e16dda33f2 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -96,12 +96,14 @@ pub(crate) fn load(
             author,
             attributions: row_attributions,
             title,
+            has_agent_marker,
             signature,
         } = metadata.unwrap_or_else(|| Metadata {
             committer_time: Default::default(),
             author: &EMPTY_AUTHOR,
             attributions: 0..0,
             title: BString::default(),
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         });
         rows.push(Commit {
@@ -112,6 +114,7 @@ pub(crate) fn load(
             attributions: row_attributions,
             title,
             metadata_loaded,
+            has_agent_marker,
             signature,
         });
         if rows.len() == COMMIT_BATCH_SIZE
@@ -151,6 +154,7 @@ fn decode_metadata<'a>(
     let mut author = None;
     let attribution_start = attributions.len();
     let mut title = None;
+    let mut has_agent_marker = false;
     let mut signature = SignatureState::Unsigned;
     for token in tokens {
         match token.context("could not decode commit")? {
@@ -162,6 +166,7 @@ fn decode_metadata<'a>(
                 committer_time = Some(signature.time().context("could not decode committer time")?);
             }
             Token::Message(message) => {
+                has_agent_marker = contains_agent_marker(message);
                 let message = gix::objs::commit::MessageRef::from_bytes(message);
                 title = Some(message.summary().into_owned());
                 if let Some(body) = message.body() {
@@ -198,10 +203,17 @@ fn decode_metadata<'a>(
         author: author.context("commit has no author")?,
         attributions: attribution_start..attributions.len(),
         title: title.context("commit has no message")?,
+        has_agent_marker,
         signature,
     })
 }
 
+fn contains_agent_marker(message: &[u8]) -> bool {
+    [b"--- agent".as_slice(), b"<!-- agent -->".as_slice()]
+        .iter()
+        .any(|marker| message.windows(marker.len()).any(|window| window == *marker))
+}
+
 pub(crate) fn count_up_to(
     repo: &gix::Repository,
     revisions: &[OsString],
@@ -424,6 +436,7 @@ mod tests {
             topic.author.is_bot(),
             "well-known bot email addresses identify bot authors"
         );
+        assert!(topic.has_agent_marker, "history loading recognizes the agent marker");
         assert_eq!(
             attributions[topic.attributions.clone()]
                 .iter()
@@ -448,6 +461,13 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn recognizes_supported_agent_markers() {
+        assert!(contains_agent_marker(b"subject\n\n--- agent\n"));
+        assert!(contains_agent_marker(b"subject\n\n<!-- agent -->\n"));
+        assert!(!contains_agent_marker(b"subject\n\nagent"));
+    }
+
     #[test]
     fn decodes_commits_missing_from_a_stale_graph_and_defers_graph_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 939a2b684eb..7d68316906b 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -668,6 +668,7 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Home | KeyCode::Char('g') => Some(Action::First),
         KeyCode::End | KeyCode::Char('G') => Some(Action::Last),
         KeyCode::Char('d') => Some(Action::ToggleDate),
+        KeyCode::Char('e') => Some(Action::ToggleEmail),
         KeyCode::Char('n') => Some(Action::ToggleName),
         KeyCode::Char('t') => Some(Action::ToggleTrailers),
         KeyCode::Char('m') => Some(Action::ToggleMailmap),
@@ -717,7 +718,7 @@ mod tests {
         let id = repository.rev_parse_single("topic")?.detach();
 
         assert!(
-            load_commit_message(&repository, id)?.starts_with(b"topic\n\nCo-authored-by:"),
+            load_commit_message(&repository, id)?.starts_with(b"topic\n\n--- agent\n\nCo-authored-by:"),
             "on-demand loading retains the full commit message"
         );
         Ok(())
@@ -828,6 +829,10 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)),
             Some(Action::ToggleDate)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
+            Some(Action::ToggleEmail)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
             Some(Action::ToggleName)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index f0ad7c736a7..2c16d4d40d5 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -12,6 +12,8 @@ use crate::{
     history::{DecorationKind, Decorations},
 };
 
+const NOTE_COLOR: Color = Color::LightMagenta;
+
 pub(crate) fn draw(
     frame: &mut Frame<'_>,
     app: &mut App,
@@ -91,6 +93,7 @@ pub(crate) fn draw(
                 MetadataOptions {
                     show_committer_date,
                     show_author_name,
+                    show_emails: app.show_emails,
                     show_trailers,
                     use_mailmap: app.use_mailmap && !preview_author_copy && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
@@ -236,6 +239,7 @@ pub(crate) fn draw(
         ]);
     }
     footer_spans.extend([Span::raw(" · "), toggle("d date", app.show_committer_date)]);
+    footer_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
     let (name_label, names_visible) = match app.name_mode {
         NameMode::All => ("n names", true),
         NameMode::Author => ("n name", true),
@@ -370,6 +374,7 @@ fn toggle(label: &'static str, enabled: bool) -> Span<'static> {
 struct MetadataOptions {
     show_committer_date: bool,
     show_author_name: bool,
+    show_emails: bool,
     show_trailers: bool,
     use_mailmap: bool,
     ref_mode: RefMode,
@@ -390,6 +395,7 @@ fn metadata_line<'a>(
     let MetadataOptions {
         show_committer_date,
         show_author_name,
+        show_emails,
         show_trailers,
         use_mailmap,
         ref_mode,
@@ -443,14 +449,17 @@ fn metadata_line<'a>(
         ));
     }
     if show_author_name {
-        let author = author_name(row.author, mailmap, use_mailmap).to_str_lossy();
-        let author_style = if copy_feedback == Some(CopyKind::Author) {
+        let author = author_label(row.author, mailmap, use_mailmap, show_emails && !row.author.is_bot());
+        let mut author_style = if copy_feedback == Some(CopyKind::Author) {
             Style::default()
         } else if preview_author_copy {
             color(Color::Magenta).add_modifier(Modifier::BOLD)
         } else {
             color(Color::Green)
         };
+        if row.author.is_github_noreply() {
+            author_style = author_style.add_modifier(Modifier::ITALIC);
+        }
         spans.push(Span::styled(
             if row.author.is_bot() {
                 format!("[{author}] ")
@@ -460,55 +469,96 @@ fn metadata_line<'a>(
             author_style,
         ));
         if show_trailers {
-            for (kind, marker) in [
-                (AttributionKind::CoAuthor, "Co: "),
-                (AttributionKind::Assisted, "As: "),
-                (AttributionKind::Reviewed, "Re: "),
-                (AttributionKind::Acked, "Ack: "),
-                (AttributionKind::Tested, "Te: "),
-                (AttributionKind::SignedOff, "So: "),
+            type Group = (&'static str, Vec<&'static str>, Vec<(String, Style)>);
+            let mut groups: Vec<Group> = Vec::new();
+            for (kind, marker, grouped_marker) in [
+                (AttributionKind::CoAuthor, "Co: ", "Co"),
+                (AttributionKind::Assisted, "As: ", "A"),
+                (AttributionKind::Reviewed, "Re: ", "Re"),
+                (AttributionKind::Acked, "Ack: ", "Ack"),
+                (AttributionKind::Tested, "Te: ", "Te"),
+                (AttributionKind::SignedOff, "So: ", "So"),
             ] {
-                let mut actors = attributions.iter().filter(|actor| actor.kind == kind).peekable();
-                if actors.peek().is_none() {
+                let actors: Vec<_> = attributions
+                    .iter()
+                    .filter(|actor| actor.kind == kind)
+                    .map(|actor| {
+                        let name = if actor.author == row.author {
+                            "*".to_owned()
+                        } else {
+                            let name =
+                                author_label(actor.author, mailmap, use_mailmap, show_emails && !actor.is_agent());
+                            if actor.is_agent() { format!("[{name}]") } else { name }
+                        };
+                        let style = if actor.author.is_github_noreply() {
+                            color(Color::Green).add_modifier(Modifier::ITALIC)
+                        } else {
+                            color(Color::Green)
+                        };
+                        (name, style)
+                    })
+                    .collect();
+                if actors.is_empty() {
                     continue;
                 }
-                spans.push(Span::styled(marker, color(Color::Green).add_modifier(Modifier::DIM)));
-                for (index, actor) in actors.enumerate() {
+                if let Some((_, markers, _)) = groups
+                    .iter_mut()
+                    .find(|(_, _, displayed_actors)| *displayed_actors == actors)
+                {
+                    markers.push(grouped_marker);
+                } else {
+                    groups.push((marker, vec![grouped_marker], actors));
+                }
+            }
+            for (marker, markers, actors) in groups {
+                spans.push(Span::styled(
+                    if markers.len() == 1 {
+                        marker.to_owned()
+                    } else {
+                        format!("{}: ", markers.join(", "))
+                    },
+                    color(Color::Green).add_modifier(Modifier::DIM),
+                ));
+                for (index, (name, style)) in actors.into_iter().enumerate() {
                     if index != 0 {
                         spans.push(Span::raw(", "));
                     }
-                    let name = if actor.author == row.author {
-                        "*".to_owned()
-                    } else {
-                        let name = author_name(actor.author, mailmap, use_mailmap).to_str_lossy();
-                        if actor.is_agent() {
-                            format!("[{name}]")
-                        } else {
-                            name.into_owned()
-                        }
-                    };
-                    spans.push(Span::styled(name, color(Color::Green)));
+                    spans.push(Span::styled(name, style));
                 }
                 spans.push(Span::raw(" "));
             }
         }
     }
-    spans.push(Span::raw(title.to_str_lossy()));
+    if row.has_agent_marker {
+        spans.push(Span::styled("[A] ", color(NOTE_COLOR)));
+    }
+    if !show_emails {
+        spans.push(Span::raw(title.to_str_lossy()));
+    }
     Line::from(spans)
 }
 
-fn author_name<'a>(author: &'a crate::app::Author, mailmap: &'a gix::mailmap::Snapshot, use_mailmap: bool) -> &'a BStr {
-    if use_mailmap {
-        mailmap
-            .try_resolve_ref(gix::actor::SignatureRef {
+fn author_label(
+    author: &crate::app::Author,
+    mailmap: &gix::mailmap::Snapshot,
+    use_mailmap: bool,
+    show_email: bool,
+) -> String {
+    let resolved = use_mailmap
+        .then(|| {
+            mailmap.try_resolve_ref(gix::actor::SignatureRef {
                 name: author.name,
                 email: author.email,
                 time: "",
             })
-            .and_then(|resolved| resolved.name)
-            .unwrap_or(author.name)
+        })
+        .flatten();
+    let name = resolved.as_ref().and_then(|actor| actor.name).unwrap_or(author.name);
+    if show_email {
+        let email = resolved.as_ref().and_then(|actor| actor.email).unwrap_or(author.email);
+        format!("{} <{}>", name.to_str_lossy(), email.to_str_lossy())
     } else {
-        author.name
+        name.to_str_lossy().into_owned()
     }
 }
 
@@ -616,18 +666,23 @@ mod tests {
                 parent_ids: Default::default(),
                 committer_time: gix::date::Time::default(),
                 author: author(b"Codex", b"codex@openai.com"),
-                attributions: 0..7,
+                attributions: 0..8,
                 title: "subject".into(),
                 metadata_loaded: true,
+                has_agent_marker: false,
                 signature: SignatureState::Unsigned,
             }],
             attributions: vec![
                 Attribution {
                     kind: AttributionKind::CoAuthor,
-                    author: author(b"Human", b"human@example.com"),
+                    author: author(b"Claude", b"noreply@anthropic.com"),
                 },
                 Attribution {
                     kind: AttributionKind::CoAuthor,
+                    author: author(b"Codex", b"codex@openai.com"),
+                },
+                Attribution {
+                    kind: AttributionKind::Assisted,
                     author: author(b"Claude", b"noreply@anthropic.com"),
                 },
                 Attribution {
@@ -636,7 +691,7 @@ mod tests {
                 },
                 Attribution {
                     kind: AttributionKind::Reviewed,
-                    author: author(b"Reviewer", b"reviewer@example.com"),
+                    author: author(b"Human", b"human@example.com"),
                 },
                 Attribution {
                     kind: AttributionKind::Acked,
@@ -661,10 +716,8 @@ mod tests {
 
         let row = rendered_row(&terminal);
         assert!(
-            row.contains(
-                "[Codex] Co: Mapped Human, [Claude] As: * Re: Reviewer Ack: Acknowledger Te: Tester So: Signer subject"
-            ),
-            "same-kind trailers share one marker, use mailmap, and collapse the primary author to an asterisk"
+            row.contains("[Codex] Co, A: [Claude], * Re: Mapped Human Ack: Acknowledger Te: Tester So: Signer subject"),
+            "attributions with identical displayed actors share their markers"
         );
         let buffer = terminal.backend().buffer();
         let style_at = |needle: &str| {
@@ -672,8 +725,12 @@ mod tests {
             buffer[(x, 0)].fg
         };
         assert_eq!(style_at("[Codex]"), Color::Green, "bot authors use the agent color");
-        assert_eq!(style_at("Co:"), Color::Green, "attribution markers use the agent color");
-        let marker_x = row.find("Co:").expect("rendered metadata contains a trailer marker") as u16;
+        assert_eq!(
+            style_at("Co, A:"),
+            Color::Green,
+            "grouped attribution markers use the agent color"
+        );
+        let marker_x = row.find("Co, A:").expect("rendered metadata contains a trailer marker") as u16;
         assert!(
             buffer[(marker_x, 0)].modifier.contains(Modifier::DIM),
             "attribution markers are dimmed"
@@ -695,21 +752,98 @@ mod tests {
         let row = rendered_row(&terminal);
         assert!(row.contains("Codex"), "the first n keeps the primary actor");
         assert!(
-            !row.contains("Reviewer"),
+            !row.contains("Mapped Human"),
             "the first n hides trailer actors while trailers are enabled"
         );
         app.update(Action::ToggleName);
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
         let row = rendered_row(&terminal);
         assert!(!row.contains("Codex"), "the second n hides the primary actor");
-        assert!(!row.contains("Reviewer"), "the second n keeps trailer actors hidden");
+        assert!(
+            !row.contains("Mapped Human"),
+            "the second n keeps trailer actors hidden"
+        );
         app.update(Action::ToggleName);
         app.update(Action::ToggleMailmap);
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
         assert!(
-            rendered_row(&terminal).contains("Co: Human, [Claude]"),
+            rendered_row(&terminal).contains("Re: Human"),
             "m restores original trailer actor names"
         );
+
+        app.update(Action::ToggleEmail);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let row = rendered_row(&terminal);
+        assert!(row.contains("Human <human@example.com>"));
+        assert!(!row.contains("codex@openai.com"));
+        assert!(!row.contains("noreply@anthropic.com"));
+        Ok(())
+    }
+
+    #[test]
+    fn toggles_full_actor_and_comment() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id: gix::ObjectId::Sha1([1; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "unique comment".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        app.selected = None;
+        let mut terminal = Terminal::new(TestBackend::new(100, 2))?;
+
+        app.update(Action::ToggleEmail);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_row(&terminal).contains("author <author@example.com>"));
+        assert!(!rendered_row(&terminal).contains("unique comment"));
+
+        app.update(Action::ToggleEmail);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(!rendered_row(&terminal).contains("<author@example.com>"));
+        assert!(rendered_row(&terminal).contains("unique comment"));
+        Ok(())
+    }
+
+    #[test]
+    fn italicizes_github_noreply_actors() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.extend_commits(LoadedCommits {
+            rows: vec![Commit {
+                id: gix::ObjectId::Sha1([1; 20]),
+                parent_ids: Default::default(),
+                committer_time: gix::date::Time::default(),
+                author: author(b"Author", b"1+author@users.noreply.github.com"),
+                attributions: 0..1,
+                title: "subject".into(),
+                metadata_loaded: true,
+                has_agent_marker: false,
+                signature: SignatureState::Unsigned,
+            }],
+            attributions: vec![Attribution {
+                kind: AttributionKind::Reviewed,
+                author: author(b"Reviewer", b"reviewer@USERS.NOREPLY.GITHUB.COM"),
+            }],
+        });
+        app.selected = None;
+        app.update(Action::ToggleEmail);
+        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let row = rendered_row(&terminal);
+        for actor in [
+            "Author <1+author@users.noreply.github.com>",
+            "Reviewer <reviewer@USERS.NOREPLY.GITHUB.COM>",
+        ] {
+            let start = row.find(actor).expect("the full actor is rendered") as u16;
+            for x in start..start + actor.len() as u16 {
+                assert!(terminal.backend().buffer()[(x, 0)].modifier.contains(Modifier::ITALIC));
+            }
+        }
         Ok(())
     }
 
@@ -725,6 +859,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
@@ -743,13 +878,13 @@ mod tests {
         )]);
         let mailmap =
             gix::mailmap::Snapshot::from_bytes(b"mapped author <mapped@example.com> author <author@example.com>\n");
-        let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(150, 2))?;
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
 
-        let footer_text = "1 commits · ↑↓/jk move · h/l pan · [ align · o commit · d date · n names · m mailmap · t trailers · r refs · y copy · q quit";
+        let footer_text = "1 commits · ↑↓/jk move · h/l pan · [ align · o commit · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
-        let mut expected = Buffer::with_lines([format!("{selected_line:<140}"), format!("{footer_text:<140}")]);
+        let mut expected = Buffer::with_lines([format!("{selected_line:<150}"), format!("{footer_text:<150}")]);
         for x in 0..11 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
         }
@@ -780,6 +915,12 @@ mod tests {
         for x in commit..commit + "o commit".len() {
             expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
         }
+        let email = footer_text[..footer_text.find("e emails").expect("the email toggle is present")]
+            .chars()
+            .count();
+        for x in email..email + "e emails".len() {
+            expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
+        }
         terminal.backend().assert_buffer(&expected);
 
         app.inline = true;
@@ -922,6 +1063,7 @@ mod tests {
                     attributions: 0..0,
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
+                    has_agent_marker: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -1020,6 +1162,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unverified,
         }]);
         complete(&mut app);
@@ -1063,6 +1206,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         }]);
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
@@ -1221,6 +1365,7 @@ mod tests {
                     attributions: 0..0,
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
+                    has_agent_marker: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -1270,6 +1415,7 @@ mod tests {
             attributions: 0..0,
             title: "subject".into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         };
         let decorations = Decorations::from([(
@@ -1311,6 +1457,7 @@ mod tests {
             MetadataOptions {
                 show_committer_date: true,
                 show_author_name: true,
+                show_emails: false,
                 show_trailers: true,
                 use_mailmap: false,
                 ref_mode: RefMode::All,
@@ -1373,6 +1520,7 @@ mod tests {
             attributions: 0..0,
             title: format!("{} subject-tail", "a".repeat(50)).into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
diff --git a/gix-tix/tests/fixtures/history.sh b/gix-tix/tests/fixtures/history.sh
index e4122e01aaf..b053f6040c4 100755
--- a/gix-tix/tests/fixtures/history.sh
+++ b/gix-tix/tests/fixtures/history.sh
@@ -25,7 +25,9 @@ echo topic >topic
 git add topic
 GIT_AUTHOR_DATE="2000-01-04T00:00:00 +0000" GIT_COMMITTER_DATE="2000-01-04T00:00:00 +0000" \
   git commit -q --author="Codex <Codex@OpenAI.com>" -m topic \
-    -m "Co-authored-by: Human Coauthor <human@example.com>
+    -m "--- agent
+
+Co-authored-by: Human Coauthor <human@example.com>
 Co-authored-by: Claude <noreply@anthropic.com>
 Assisted-by: Opus 4.7
 rEvIeWeD-bY: Reviewer <reviewer@example.com>

From 9d29d59903a93423cd3a2e0e2658a5f9a7ab29a7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 26 Jul 2026 15:40:36 +0200
Subject: [PATCH 007/282] feat: navigate merge ancestry with Shift in tix

Consolidates:
- fix: scope Shift handling to the active tix screen
- feat: focus tix navigation on reachable commits
- feat: isolate merged history in Shift navigation
- feat: include merge fork points in Shift navigation
- fix: defer Shift reachability until graph completion
- feat: cycle junction parents during Shift navigation
---
 gix-tix/src/app.rs | 285 +++++++++++++++++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs |  98 ++++++++++++----
 gix-tix/src/ui.rs  | 111 ++++++++++++++++++
 3 files changed, 462 insertions(+), 32 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index f8145801cb5..8f0f02cac18 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1,5 +1,5 @@
 use std::{
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     ops::Range,
     time::{Duration, Instant},
 };
@@ -199,6 +199,9 @@ pub(crate) struct App {
     pub(crate) show_selection_tail: bool,
     pub inline: bool,
     pub preview_author_copy: bool,
+    reachability_anchor: Option<ObjectId>,
+    junction_parent: Option<usize>,
+    reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
@@ -236,6 +239,9 @@ impl App {
             show_selection_tail: true,
             inline: false,
             preview_author_copy: false,
+            reachability_anchor: None,
+            junction_parent: None,
+            reachable_rows: None,
             copy_feedback: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
@@ -280,6 +286,9 @@ impl App {
             self.selected = Some(self.rows.len() - 1);
             self.ensure_visible();
         }
+        if self.reachability_anchor.is_some() {
+            self.compute_reachable_rows();
+        }
     }
 
     pub(crate) fn set_metadata(
@@ -339,16 +348,20 @@ impl App {
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
-            Action::MoveUp => self.move_selection(1, false),
-            Action::MoveDown => self.move_selection(1, true),
+            Action::MoveUp => self.move_reachable(false),
+            Action::MoveDown => self.move_reachable(true),
             Action::ScrollLeft => {
-                self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
+                if !self.cycle_junction_parent(false) {
+                    self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
+                }
             }
             Action::ScrollRight => {
-                self.horizontal_offset = self
-                    .horizontal_offset
-                    .saturating_add(self.horizontal_page)
-                    .min(self.horizontal_max);
+                if !self.cycle_junction_parent(true) {
+                    self.horizontal_offset = self
+                        .horizontal_offset
+                        .saturating_add(self.horizontal_page)
+                        .min(self.horizontal_max);
+                }
             }
             Action::HalfPageUp => self.move_selection((self.viewport_rows / 2).max(1), false),
             Action::HalfPageDown => self.move_selection((self.viewport_rows / 2).max(1), true),
@@ -411,7 +424,17 @@ impl App {
                     return vec![Effect::VerifySignatures(ids)];
                 }
             }
-            Action::PreviewAuthorCopy(value) => self.preview_author_copy = value,
+            Action::PreviewAuthorCopy(value) => {
+                if value && !self.preview_author_copy {
+                    self.reachability_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+                    self.compute_reachable_rows();
+                } else if !value {
+                    self.reachability_anchor = None;
+                    self.junction_parent = None;
+                    self.reachable_rows = None;
+                }
+                self.preview_author_copy = value;
+            }
             Action::Cancel if self.state == State::Loading => {
                 self.state = State::Cancelling;
                 return vec![Effect::Cancel];
@@ -503,6 +526,9 @@ impl App {
         self.lane_time = Some(lane_time);
         self.selected = selected.and_then(|id| self.rows.iter().position(|row| row.id == id));
         self.state = State::Complete;
+        if self.reachability_anchor.is_some() {
+            self.compute_reachable_rows();
+        }
         self.ensure_visible();
     }
 
@@ -521,6 +547,10 @@ impl App {
         self.show_hidden = show_hidden;
         self.horizontal_offset = 0;
         self.follow_tail = false;
+        self.preview_author_copy = false;
+        self.reachability_anchor = None;
+        self.junction_parent = None;
+        self.reachable_rows = None;
         self.signature_failures = 0;
         self.signature_verification_running = false;
     }
@@ -556,6 +586,104 @@ impl App {
         self.ensure_visible();
     }
 
+    fn move_reachable(&mut self, down: bool) {
+        let (Some(selected), Some(reachable)) = (self.selected, self.reachable_rows.as_ref()) else {
+            self.move_selection(1, down);
+            return;
+        };
+        let next = if down {
+            (selected + 1..self.rows.len()).find(|index| reachable.get(*index) == Some(&true))
+        } else {
+            (0..selected).rev().find(|index| reachable.get(*index) == Some(&true))
+        };
+        if let Some(next) = next {
+            self.select(next);
+        }
+    }
+
+    fn cycle_junction_parent(&mut self, forward: bool) -> bool {
+        if self.state != State::Complete {
+            return false;
+        }
+        let Some(parent_count) = self
+            .reachability_anchor
+            .and_then(|anchor| self.rows.iter().find(|row| row.id == anchor))
+            .map(|row| row.parent_ids.len())
+            .filter(|count| *count > 1)
+        else {
+            return false;
+        };
+        let current = self.junction_parent.unwrap_or(1);
+        self.junction_parent = Some(if forward {
+            (current + 1) % parent_count
+        } else {
+            (current + parent_count - 1) % parent_count
+        });
+        self.compute_reachable_rows();
+        true
+    }
+
+    fn compute_reachable_rows(&mut self) {
+        if self.state != State::Complete {
+            self.reachable_rows = None;
+            return;
+        }
+        let Some(anchor) = self.reachability_anchor else {
+            self.reachable_rows = None;
+            return;
+        };
+        let Some(anchor_index) = self.rows.iter().position(|row| row.id == anchor) else {
+            self.reachable_rows = Some(vec![false; self.rows.len()]);
+            return;
+        };
+        let parent_count = self.rows[anchor_index].parent_ids.len();
+        let start = if parent_count > 1 {
+            let parent = self.junction_parent.get_or_insert(1);
+            if *parent >= parent_count {
+                *parent = 1;
+            }
+            self.rows[anchor_index]
+                .parent_ids
+                .get(*parent)
+                .copied()
+                .expect("the selected junction parent exists")
+        } else {
+            self.junction_parent = None;
+            anchor
+        };
+        let mut pending = HashSet::from([start]);
+        let mut reachable: Vec<_> = self
+            .rows
+            .iter()
+            .map(|row| {
+                let reachable = pending.remove(&row.id);
+                if reachable {
+                    pending.extend(row.parent_ids.iter().copied());
+                }
+                reachable
+            })
+            .collect();
+        if start != anchor {
+            reachable[anchor_index] = true;
+        }
+        self.reachable_rows = Some(reachable);
+    }
+
+    pub(crate) fn junction_parent(&self, index: usize) -> Option<usize> {
+        let row = self.rows.get(index)?;
+        if self.reachability_anchor == Some(row.id) {
+            self.junction_parent.map(|parent| parent + 1)
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn is_row_reachable(&self, index: usize) -> bool {
+        self.reachable_rows
+            .as_ref()
+            .is_none_or(|reachable| reachable.get(index).copied().unwrap_or(false))
+    }
+
     fn select(&mut self, selected: usize) {
         if !self.rows.is_empty() {
             let previous = self.selected;
@@ -1129,6 +1257,63 @@ mod tests {
         );
     }
 
+    #[test]
+    fn shift_limits_jk_to_the_selected_commits_ancestors() {
+        let mut app = App::new(5);
+        app.extend_commits(vec![
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(5));
+
+        app.update(Action::PreviewAuthorCopy(true));
+        let reachable: Vec<_> = app
+            .rows
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| app.is_row_reachable(*index))
+            .map(|(_, row)| row.id)
+            .collect();
+        assert_eq!(reachable, [id(5), id(3), id(1)]);
+
+        app.update(Action::MoveDown);
+        assert_eq!(app.rows[app.selected.expect("an ancestor is selected")].id, id(3));
+        app.update(Action::MoveDown);
+        assert_eq!(app.rows[app.selected.expect("an ancestor is selected")].id, id(1));
+
+        app.update(Action::PreviewAuthorCopy(false));
+        app.update(Action::MoveUp);
+        assert_eq!(app.rows[app.selected.expect("normal navigation is restored")].id, id(2));
+    }
+
+    #[test]
+    fn shift_defers_reachability_until_the_graph_is_complete() {
+        let mut app = App::new(4);
+        app.extend_commits(vec![row_with_parents(4, &[3, 2]), row_with_parents(3, &[1])]);
+
+        app.update(Action::PreviewAuthorCopy(true));
+        assert!(
+            app.reachable_rows.is_none(),
+            "pressing Shift while traversing does not compute reachability"
+        );
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        assert!(
+            app.reachable_rows.is_none(),
+            "later traversal batches do not recompute reachability"
+        );
+
+        complete(&mut app);
+        assert!(
+            app.reachable_rows.is_some(),
+            "graph completion computes reachability once"
+        );
+        assert_eq!(app.junction_parent(0), Some(2));
+    }
+
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);
@@ -1267,9 +1452,11 @@ mod tests {
         );
         complete(&mut app);
         assert_eq!(app.update(Action::ToggleHidden), vec![Effect::Reload(true)]);
+        drop(app.update(Action::PreviewAuthorCopy(true)));
         app.reload(true);
         assert!(app.rows.is_empty(), "reloading drops rows from the previous view");
         assert!(app.show_hidden);
+        assert!(!app.preview_author_copy, "reloading clears transient Shift state");
         assert_eq!(app.state, State::Loading);
         assert!(
             app.update(Action::ToggleHidden).is_empty(),
@@ -1298,6 +1485,86 @@ mod tests {
         );
     }
 
+    #[test]
+    fn shift_starts_with_a_merges_second_parent_rail() {
+        let mut app = App::new(7);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5, 4]),
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(6));
+
+        app.update(Action::PreviewAuthorCopy(true));
+        let reachable: Vec<_> = app
+            .rows
+            .iter()
+            .enumerate()
+            .filter(|(index, _)| app.is_row_reachable(*index))
+            .map(|(_, row)| row.id)
+            .collect();
+        assert_eq!(
+            reachable,
+            [id(6), id(4), id(2), id(1)],
+            "the second parent and its complete ancestry are reachable"
+        );
+    }
+
+    #[test]
+    fn shift_cycles_junction_parents_without_panning() {
+        let mut app = App::new(8);
+        app.extend_commits(vec![
+            row_with_parents(10, &[8, 9, 11]),
+            row_with_parents(8, &[6]),
+            row_with_parents(9, &[7, 6]),
+            row_with_parents(11, &[5]),
+            row_with_parents(7, &[1]),
+            row_with_parents(6, &[1]),
+            row_with_parents(5, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(10));
+        app.set_horizontal_bounds(10, 25);
+
+        app.update(Action::PreviewAuthorCopy(true));
+        let reachable = |app: &App| {
+            app.rows
+                .iter()
+                .enumerate()
+                .filter(|(index, _)| app.is_row_reachable(*index))
+                .map(|(_, row)| row.id)
+                .collect::<HashSet<_>>()
+        };
+        assert_eq!(app.junction_parent(0), Some(2));
+        assert_eq!(
+            reachable(&app),
+            HashSet::from([id(10), id(9), id(7), id(6), id(1)]),
+            "the selected rail traverses every parent of its next junction"
+        );
+
+        app.update(Action::ScrollRight);
+        assert_eq!(app.junction_parent(0), Some(3));
+        assert_eq!(reachable(&app), HashSet::from([id(10), id(11), id(5), id(1)]));
+        app.update(Action::ScrollRight);
+        assert_eq!(app.junction_parent(0), Some(1));
+        assert_eq!(reachable(&app), HashSet::from([id(10), id(8), id(6), id(1)]));
+        app.update(Action::ScrollLeft);
+        assert_eq!(app.junction_parent(0), Some(3));
+        assert_eq!(
+            app.horizontal_offset, 0,
+            "junction selection suppresses horizontal panning"
+        );
+
+        app.update(Action::PreviewAuthorCopy(false));
+        app.update(Action::ScrollRight);
+        assert_eq!(app.horizontal_offset, 10, "releasing Shift restores horizontal panning");
+    }
+
     #[test]
     fn completion_and_copy_effects_use_the_current_selection() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 7d68316906b..41d70494175 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -23,8 +23,9 @@ use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
     event::{
-        self, Event as TerminalEvent, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags,
-        ModifierKeyCode, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+        self, DisableFocusChange, EnableFocusChange, Event as TerminalEvent, KeyCode, KeyEvent, KeyEventKind,
+        KeyModifiers, KeyboardEnhancementFlags, ModifierKeyCode, PopKeyboardEnhancementFlags,
+        PushKeyboardEnhancementFlags,
     },
     execute,
     style::Print,
@@ -91,24 +92,20 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
     }
     .context("could not initialize terminal")?;
     let enhanced_keyboard = terminal::supports_keyboard_enhancement().unwrap_or(false);
-    let keyboard_setup = if enhanced_keyboard {
-        execute!(
-            terminal.backend_mut(),
-            PushKeyboardEnhancementFlags(
-                KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
-                    | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
-                    | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
-            )
-        )
-    } else {
-        Ok(())
-    };
+    let keyboard_setup = enable_input(terminal.backend_mut(), enhanced_keyboard);
     let result = keyboard_setup
         .context("could not enable enhanced keyboard events")
-        .and_then(|()| event_loop(&mut terminal, repository, revisions, options, inline_height.is_some()));
-    let keyboard_restore = enhanced_keyboard
-        .then(|| execute!(terminal.backend_mut(), PopKeyboardEnhancementFlags))
-        .transpose();
+        .and_then(|()| {
+            event_loop(
+                &mut terminal,
+                repository,
+                revisions,
+                options,
+                inline_height.is_some(),
+                enhanced_keyboard,
+            )
+        });
+    let keyboard_restore = disable_input(terminal.backend_mut(), enhanced_keyboard);
     let restore = restore_terminal(&mut terminal, inline_height.is_some());
     let lane_time = result?;
     keyboard_restore.context("could not restore keyboard events")?;
@@ -119,6 +116,28 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
     Ok(())
 }
 
+fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
+    execute!(backend, EnableFocusChange)?;
+    if enhanced_keyboard {
+        execute!(
+            backend,
+            PushKeyboardEnhancementFlags(
+                KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+                    | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
+                    | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
+            )
+        )?;
+    }
+    Ok(())
+}
+
+fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
+    if enhanced_keyboard {
+        execute!(backend, PopKeyboardEnhancementFlags)?;
+    }
+    execute!(backend, DisableFocusChange)
+}
+
 fn half_height(terminal_height: u16) -> u16 {
     (terminal_height / 2).max(1)
 }
@@ -164,18 +183,27 @@ fn restore_terminal(terminal: &mut ratatui::DefaultTerminal, inline: bool) -> Re
     Ok(())
 }
 
-fn enter_alternate_screen(terminal: &mut ratatui::DefaultTerminal) -> std::io::Result<ratatui::DefaultTerminal> {
+fn enter_alternate_screen(
+    terminal: &mut ratatui::DefaultTerminal,
+    enhanced_keyboard: bool,
+) -> std::io::Result<ratatui::DefaultTerminal> {
+    disable_input(terminal.backend_mut(), enhanced_keyboard)?;
     let alternate = ratatui::Terminal::new(CrosstermBackend::new(std::io::stdout()))?;
     execute!(terminal.backend_mut(), EnterAlternateScreen)?;
-    Ok(std::mem::replace(terminal, alternate))
+    let inline = std::mem::replace(terminal, alternate);
+    enable_input(terminal.backend_mut(), enhanced_keyboard)?;
+    Ok(inline)
 }
 
 fn leave_alternate_screen(
     terminal: &mut ratatui::DefaultTerminal,
     inline: ratatui::DefaultTerminal,
+    enhanced_keyboard: bool,
 ) -> std::io::Result<()> {
+    disable_input(terminal.backend_mut(), enhanced_keyboard)?;
     drop(std::mem::replace(terminal, inline));
     execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
+    enable_input(terminal.backend_mut(), enhanced_keyboard)?;
     terminal.hide_cursor()
 }
 
@@ -201,6 +229,10 @@ fn resize_inline_screen(terminal: &mut ratatui::DefaultTerminal, height: u16) ->
     terminal.hide_cursor()
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "screen transitions need the complete terminal state"
+)]
 fn sync_screen(
     terminal: &mut ratatui::DefaultTerminal,
     app: &mut App,
@@ -209,6 +241,7 @@ fn sync_screen(
     history_requires_alternate_screen: bool,
     resize_inline: bool,
     inline_terminal: &mut Option<ratatui::DefaultTerminal>,
+    enhanced_keyboard: bool,
 ) -> Result<()> {
     let needs_alternate_screen = app.show_commit || history_requires_alternate_screen;
     if !should_switch_screen(started_inline, needs_alternate_screen, inline_terminal.is_some()) {
@@ -220,10 +253,11 @@ fn sync_screen(
         return Ok(());
     }
     if needs_alternate_screen {
-        *inline_terminal = Some(enter_alternate_screen(terminal).context("could not enter the alternate screen")?);
+        *inline_terminal =
+            Some(enter_alternate_screen(terminal, enhanced_keyboard).context("could not enter the alternate screen")?);
         app.inline = false;
     } else if let Some(inline) = inline_terminal.take() {
-        leave_alternate_screen(terminal, inline).context("could not leave the alternate screen")?;
+        leave_alternate_screen(terminal, inline, enhanced_keyboard).context("could not leave the alternate screen")?;
         app.inline = true;
         let height = inline_height(screen, terminal::size()?.1, app.rows.len())
             .expect("an inline history always has an inline height");
@@ -238,6 +272,7 @@ fn event_loop(
     revisions: Vec<OsString>,
     options: Options,
     started_inline: bool,
+    enhanced_keyboard: bool,
 ) -> Result<Option<Duration>> {
     let Options {
         quit_on_finish,
@@ -282,6 +317,7 @@ fn event_loop(
     let mut urgent = false;
     let mut inline_terminal = None;
     let mut history_requires_alternate_screen = false;
+    let mut focused = true;
     let result: Result<Option<Duration>> = (|| loop {
         if let Some(result) = verification_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
@@ -371,6 +407,7 @@ fn event_loop(
             history_requires_alternate_screen,
             resize_inline,
             &mut inline_terminal,
+            enhanced_keyboard,
         )?;
         let streaming = matches!(app.state, State::Loading | State::Cancelling | State::Computing)
             || verification_receiver.is_some();
@@ -397,6 +434,17 @@ fn event_loop(
         };
         let key = match terminal_event {
             TerminalEvent::Key(key) => key,
+            TerminalEvent::FocusLost => {
+                focused = false;
+                drop(app.update(Action::PreviewAuthorCopy(false)));
+                dirty = true;
+                urgent = true;
+                continue;
+            }
+            TerminalEvent::FocusGained => {
+                focused = true;
+                continue;
+            }
             TerminalEvent::Resize(_, _) => {
                 dirty = true;
                 urgent = true;
@@ -404,6 +452,9 @@ fn event_loop(
             }
             _ => continue,
         };
+        if !focused {
+            continue;
+        }
         let action = action(key);
         fill_repository.retain = retains_fill_repository(key.kind, action.as_ref());
         if !fill_repository.retain {
@@ -467,10 +518,11 @@ fn event_loop(
             history_requires_alternate_screen,
             false,
             &mut inline_terminal,
+            enhanced_keyboard,
         )?;
     })();
     let restore = inline_terminal
-        .map(|inline| leave_alternate_screen(terminal, inline))
+        .map(|inline| leave_alternate_screen(terminal, inline, enhanced_keyboard))
         .transpose();
     let outcome = result?;
     restore.context("could not restore the inline terminal")?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 2c16d4d40d5..4cced3a465d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -190,6 +190,32 @@ pub(crate) fn draw(
                 visible_rows[index].signature,
             );
         }
+        let lane_offset = if align_metadata {
+            graph_offset
+        } else {
+            horizontal_offset
+        };
+        if let (Some(parent), Some(disk)) = (
+            app.junction_parent(start + index),
+            lane.chars().position(|symbol| symbol == '●'),
+        ) && disk >= lane_offset
+        {
+            let number = parent.to_string();
+            let x = disk + 1 - lane_offset;
+            if x < row_area.width as usize {
+                let width = number
+                    .chars()
+                    .count()
+                    .min(lane.chars().count().saturating_sub(disk + 1))
+                    .min(row_area.width as usize - x);
+                if width > 0 {
+                    frame.render_widget(
+                        Paragraph::new(number).style(style),
+                        Rect::new(row_area.x + x as u16, y, width as u16, 1),
+                    );
+                }
+            }
+        }
         if selected && app.show_selection_tail && body.width > 0 {
             let line_width = if align_metadata {
                 align_width.saturating_add(metadata_width.saturating_sub(metadata_offset))
@@ -206,6 +232,11 @@ pub(crate) fn draw(
                 .min(body.right().saturating_sub(1));
             frame.buffer_mut()[(marker_x, y)].set_style(style);
         }
+        if !app.is_row_reachable(start + index) {
+            for x in body.x..body.right() {
+                frame.buffer_mut()[(x, y)].set_style(Style::default().add_modifier(Modifier::DIM));
+            }
+        }
     }
     app.set_horizontal_bounds(content.width as usize, max_offset);
     if let (Some(area), Some(message)) = (commit_pane, commit_message) {
@@ -1404,6 +1435,86 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn dims_rows_outside_the_shift_reachability_set() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(2);
+        app.extend_commits(
+            (1..=2)
+                .map(|n| Commit {
+                    id: gix::ObjectId::Sha1([n; 20]),
+                    parent_ids: Default::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: format!("subject {n}").into(),
+                    metadata_loaded: true,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.update(Action::PreviewAuthorCopy(true));
+        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        assert!(
+            !terminal.backend().buffer()[(10, 0)].modifier.contains(Modifier::DIM),
+            "the anchor row remains bright"
+        );
+        assert!(
+            terminal.backend().buffer()[(10, 1)].modifier.contains(Modifier::DIM),
+            "an unreachable row is dimmed"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn shows_the_selected_parent_beside_the_junction_disk() -> Result<(), Box<dyn std::error::Error>> {
+        let commit = |n: u8, parents: &[u8]| Commit {
+            id: gix::ObjectId::Sha1([n; 20]),
+            parent_ids: parents
+                .iter()
+                .map(|parent| gix::ObjectId::Sha1([*parent; 20]))
+                .collect(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: format!("subject {n}").into(),
+            metadata_loaded: true,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(4);
+        app.extend_commits(vec![
+            commit(4, &[3, 2]),
+            commit(3, &[1]),
+            commit(2, &[1]),
+            commit(1, &[]),
+        ]);
+        complete(&mut app);
+        app.update(Action::PreviewAuthorCopy(true));
+        let mut terminal = Terminal::new(TestBackend::new(80, 5))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let metadata_x = rendered_row(&terminal)
+            .find("0404040")
+            .expect("the junction metadata is visible");
+        assert_eq!(
+            terminal.backend().buffer()[(3, 0)].symbol(),
+            "2",
+            "the initial parent number replaces the connector beside the disk"
+        );
+
+        app.update(Action::ScrollRight);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(terminal.backend().buffer()[(3, 0)].symbol(), "1");
+        assert_eq!(
+            rendered_row(&terminal).find("0404040"),
+            Some(metadata_x),
+            "cycling parents does not shift metadata"
+        );
+        Ok(())
+    }
+
     #[test]
     fn uses_the_tig_palette_without_coloring_the_selection() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);

From 4219b1eefc2aaae0bba9994afacac1b37f6e4b58 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 26 Jul 2026 18:51:49 +0200
Subject: [PATCH 008/282] feat: clarify filtered history in tix

Retain the selected commit when toggling hidden history, falling back to the
top only when the commit is no longer present. Hide references together with
ancestry so filtered rows remain visually aligned.

Retain excluded parents directly connected to visible commits as dimmed,
terminal-colored boundary rows that show where graph lanes terminate without
restoring full hidden ancestry. Keep these rows outside selection, paging,
Shift navigation, signature verification, and selection restoration.
---
 gix-tix/src/app.rs     | 145 +++++++++++++++++++++++++++++++++++++----
 gix-tix/src/history.rs |  61 ++++++++++++++++-
 gix-tix/src/lib.rs     |   8 ++-
 gix-tix/src/ui.rs      |  62 +++++++++++++++++-
 4 files changed, 259 insertions(+), 17 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 8f0f02cac18..5878930df15 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -176,6 +176,7 @@ pub(crate) enum Effect {
 #[derive(Debug)]
 pub(crate) struct App {
     pub rows: Vec<CommitRow>,
+    hidden_rows: HashSet<ObjectId>,
     titles: Vec<u8>,
     graph: Option<Graph>,
     attributions: Vec<Attribution>,
@@ -208,6 +209,7 @@ pub(crate) struct App {
     horizontal_page: usize,
     horizontal_max: usize,
     follow_tail: bool,
+    reload_selection: Option<ObjectId>,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
 }
@@ -216,6 +218,7 @@ impl App {
     pub fn new(viewport_rows: usize) -> Self {
         App {
             rows: Vec::new(),
+            hidden_rows: HashSet::new(),
             titles: Vec::new(),
             graph: None,
             attributions: Vec::new(),
@@ -248,11 +251,19 @@ impl App {
             horizontal_page: 1,
             horizontal_max: 0,
             follow_tail: false,
+            reload_selection: None,
             signature_failures: 0,
             signature_verification_running: false,
         }
     }
 
+    pub(crate) fn configure_hidden_filter(&mut self, present: bool) {
+        self.has_hidden_filter = present;
+        if present {
+            self.ref_mode = RefMode::None;
+        }
+    }
+
     pub(crate) fn extend_commits(&mut self, commits: impl Into<LoadedCommits>) {
         let LoadedCommits { rows, attributions } = commits.into();
         if self.state != State::Loading || rows.is_empty() {
@@ -280,10 +291,20 @@ impl App {
         }
         if was_empty {
             self.estimated_lane_width = estimate_lane_width(&self.rows[..self.viewport_rows.min(self.rows.len())]);
-            self.selected = Some(0);
+            self.selected = self.first_selectable();
             self.ensure_visible();
         } else if self.follow_tail {
-            self.selected = Some(self.rows.len() - 1);
+            self.selected = self.last_selectable();
+            self.ensure_visible();
+        }
+        if let Some(index) = self
+            .reload_selection
+            .and_then(|id| self.rows.iter().position(|row| row.id == id))
+        {
+            if !self.is_row_hidden(index) {
+                self.selected = Some(index);
+            }
+            self.reload_selection = None;
             self.ensure_visible();
         }
         if self.reachability_anchor.is_some() {
@@ -291,6 +312,18 @@ impl App {
         }
     }
 
+    pub(crate) fn extend_hidden_commits(&mut self, commits: impl Into<LoadedCommits>) {
+        let commits = commits.into();
+        self.hidden_rows.extend(commits.rows.iter().map(|row| row.id));
+        self.extend_commits(commits);
+    }
+
+    pub(crate) fn is_row_hidden(&self, index: usize) -> bool {
+        self.rows
+            .get(index)
+            .is_some_and(|row| self.hidden_rows.contains(&row.id))
+    }
+
     pub(crate) fn set_metadata(
         &mut self,
         index: usize,
@@ -367,10 +400,14 @@ impl App {
             Action::HalfPageDown => self.move_selection((self.viewport_rows / 2).max(1), true),
             Action::PageUp => self.move_selection(self.viewport_rows.max(1), false),
             Action::PageDown => self.move_selection(self.viewport_rows.max(1), true),
-            Action::First => self.select(0),
-            Action::Last if !self.rows.is_empty() => {
+            Action::First => {
+                if let Some(index) = self.first_selectable() {
+                    self.select(index);
+                }
+            }
+            Action::Last if self.last_selectable().is_some() => {
                 let previous = self.selected;
-                self.selected = Some(self.rows.len() - 1);
+                self.selected = self.last_selectable();
                 if self.selected != previous {
                     self.retry_failed_signatures();
                 }
@@ -413,7 +450,7 @@ impl App {
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
                 let ids: Vec<_> = self.rows[start..end]
                     .iter_mut()
-                    .filter(|row| row.signature == SignatureState::Unverified)
+                    .filter(|row| !self.hidden_rows.contains(&row.id) && row.signature == SignatureState::Unverified)
                     .map(|row| {
                         row.signature = SignatureState::Verifying;
                         row.id
@@ -473,6 +510,7 @@ impl App {
             State::Loading => {
                 self.state = State::Computing;
                 self.follow_tail = false;
+                self.reload_selection = None;
                 Some(self.rows.clone())
             }
             State::Cancelling => {
@@ -533,7 +571,9 @@ impl App {
     }
 
     pub(crate) fn reload(&mut self, show_hidden: bool) {
+        self.reload_selection = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
         self.rows = Vec::new();
+        self.hidden_rows.clear();
         self.titles = Vec::new();
         self.graph = None;
         self.attributions = Vec::new();
@@ -574,11 +614,12 @@ impl App {
 
     fn move_selection(&mut self, distance: usize, down: bool) {
         let Some(selected) = self.selected else { return };
-        self.selected = Some(if down {
+        let target = if down {
             selected.saturating_add(distance).min(self.rows.len() - 1)
         } else {
             selected.saturating_sub(distance)
-        });
+        };
+        self.selected = self.nearest_selectable(target, down);
         if self.selected != Some(selected) {
             self.retry_failed_signatures();
         }
@@ -592,9 +633,12 @@ impl App {
             return;
         };
         let next = if down {
-            (selected + 1..self.rows.len()).find(|index| reachable.get(*index) == Some(&true))
+            (selected + 1..self.rows.len())
+                .find(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
         } else {
-            (0..selected).rev().find(|index| reachable.get(*index) == Some(&true))
+            (0..selected)
+                .rev()
+                .find(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
         };
         if let Some(next) = next {
             self.select(next);
@@ -685,7 +729,7 @@ impl App {
     }
 
     fn select(&mut self, selected: usize) {
-        if !self.rows.is_empty() {
+        if !self.rows.is_empty() && !self.is_row_hidden(selected) {
             let previous = self.selected;
             self.selected = Some(selected.min(self.rows.len() - 1));
             if self.selected != previous {
@@ -696,6 +740,27 @@ impl App {
         }
     }
 
+    fn first_selectable(&self) -> Option<usize> {
+        (0..self.rows.len()).find(|index| !self.is_row_hidden(*index))
+    }
+
+    fn last_selectable(&self) -> Option<usize> {
+        (0..self.rows.len()).rev().find(|index| !self.is_row_hidden(*index))
+    }
+
+    fn nearest_selectable(&self, target: usize, down: bool) -> Option<usize> {
+        if down {
+            (target..self.rows.len())
+                .find(|index| !self.is_row_hidden(*index))
+                .or_else(|| (0..target).rev().find(|index| !self.is_row_hidden(*index)))
+        } else {
+            (0..=target)
+                .rev()
+                .find(|index| !self.is_row_hidden(*index))
+                .or_else(|| (target + 1..self.rows.len()).find(|index| !self.is_row_hidden(*index)))
+        }
+    }
+
     fn retry_failed_signatures(&mut self) {
         for row in &mut self.rows {
             if row.signature == SignatureState::Failed {
@@ -1348,6 +1413,30 @@ mod tests {
         assert_eq!(app.offset, 0, "the newest commit is visible");
     }
 
+    #[test]
+    fn hidden_boundary_rows_are_not_selectable_or_verifiable() {
+        let mut app = App::new(4);
+        app.extend_commits(vec![row(1), row(2), row(3)]);
+        app.update(Action::Last);
+        app.extend_hidden_commits(vec![row(4)]);
+        app.rows[3].signature = SignatureState::Unverified;
+
+        assert_eq!(
+            app.selected,
+            Some(2),
+            "following the tail stops at the oldest visible commit"
+        );
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected, Some(2), "j cannot enter the hidden boundary");
+        app.update(Action::First);
+        app.update(Action::PageDown);
+        assert_eq!(app.selected, Some(2), "paging skips the hidden boundary");
+        assert!(
+            app.update(Action::VerifySignatures).is_empty(),
+            "hidden signatures are not actionable"
+        );
+    }
+
     #[test]
     fn half_pages_use_half_the_viewport() {
         let mut app = App::new(4);
@@ -1444,7 +1533,12 @@ mod tests {
             "the key is inert without hidden revisions"
         );
 
-        app.has_hidden_filter = true;
+        app.configure_hidden_filter(true);
+        assert_eq!(
+            app.ref_mode,
+            RefMode::None,
+            "hidden ancestry hides references by default"
+        );
         app.extend_commits(vec![row(1)]);
         assert!(
             app.update(Action::ToggleHidden).is_empty(),
@@ -1466,6 +1560,33 @@ mod tests {
         assert_eq!(app.update(Action::ToggleHidden), vec![Effect::Reload(false)]);
     }
 
+    #[test]
+    fn reload_retains_selection_or_falls_back_to_the_top() {
+        let mut app = App::new(3);
+        app.extend_commits(vec![row(1), row(2), row(3)]);
+        complete(&mut app);
+        app.update(Action::MoveDown);
+        let selected = app.rows[app.selected.expect("a row is selected")].id;
+
+        app.reload(true);
+        app.extend_commits(vec![row(1), row(2), row(3)]);
+        complete(&mut app);
+        assert_eq!(
+            app.rows[app.selected.expect("the old row remains selected")].id,
+            selected
+        );
+
+        app.reload(false);
+        app.extend_commits(vec![row(3)]);
+        app.extend_hidden_commits(vec![row(2)]);
+        complete(&mut app);
+        assert_eq!(
+            app.selected,
+            Some(0),
+            "a selection which becomes a hidden boundary falls back to the top row"
+        );
+    }
+
     #[test]
     fn cancellation_preserves_rows_and_ignores_late_worker_events() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 0e16dda33f2..b052d6c0546 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -47,6 +47,7 @@ const COMMIT_BATCH_SIZE: usize = 1024;
 pub(crate) enum Event {
     Decorations(Decorations),
     Commits(LoadedCommits),
+    HiddenCommits(LoadedCommits),
     Complete,
     Cancelled,
 }
@@ -77,6 +78,9 @@ pub(crate) fn load(
         .context("could not start revision walk")?;
     let mut rows = Vec::with_capacity(COMMIT_BATCH_SIZE);
     let mut attributions = Vec::with_capacity(COMMIT_BATCH_SIZE);
+    let mut visible = HashSet::new();
+    let mut connected = Vec::new();
+    let mut seen_parents = HashSet::new();
     for info in walk {
         if cancelled.load(Ordering::Relaxed) {
             emit(Event::Cancelled);
@@ -106,6 +110,13 @@ pub(crate) fn load(
             has_agent_marker: false,
             signature: SignatureState::Unsigned,
         });
+        visible.insert(info.id);
+        connected.extend(
+            info.parent_ids
+                .iter()
+                .copied()
+                .filter(|parent| seen_parents.insert(*parent)),
+        );
         rows.push(Commit {
             id: info.id,
             parent_ids: info.parent_ids,
@@ -129,6 +140,42 @@ pub(crate) fn load(
     if !rows.is_empty() && !emit(Event::Commits(LoadedCommits { rows, attributions })) {
         return Ok(());
     }
+    if !hidden_revisions.is_empty() {
+        connected.retain(|id| !visible.contains(id));
+        let mut rows = Vec::with_capacity(connected.len());
+        let mut attributions = Vec::new();
+        let mut authors = gix::features::threading::lock(authors);
+        for id in connected {
+            if cancelled.load(Ordering::Relaxed) {
+                emit(Event::Cancelled);
+                return Ok(());
+            }
+            let object = repo.find_commit(id).context("could not read connected hidden commit")?;
+            let parent_ids = object.parent_ids().map(gix::Id::detach).collect();
+            let Metadata {
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                has_agent_marker,
+                signature,
+            } = decode_metadata(object.iter(), &mut authors, &mut attributions)?;
+            rows.push(Commit {
+                id,
+                parent_ids,
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                metadata_loaded: true,
+                has_agent_marker,
+                signature,
+            });
+        }
+        if !rows.is_empty() && !emit(Event::HiddenCommits(LoadedCommits { rows, attributions })) {
+            return Ok(());
+        }
+    }
     emit(Event::Complete);
     Ok(())
 }
@@ -542,7 +589,19 @@ mod tests {
         );
         let expected = String::from_utf8(output.stdout)?.lines().map(str::to_owned).collect();
         assert_eq!(actual, expected, "hidden tips use Git's exclusion semantics");
-        let repo = gix::open(&fixture)?;
+        let repo = crate::open_test_repository(&fixture)?;
+        let connected: Vec<_> = events
+            .iter()
+            .flat_map(|event| match event {
+                Event::HiddenCommits(batch) => batch.rows.iter().map(|row| row.id).collect(),
+                _ => Vec::new(),
+            })
+            .collect();
+        assert_eq!(
+            connected,
+            [repo.rev_parse_single("topic^")?.detach()],
+            "only the excluded parent directly connected to visible history is retained"
+        );
         let revisions = [OsString::from("topic")];
         let hidden = [OsString::from("main")];
         assert_eq!(
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 41d70494175..ee6f0a8951a 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -301,7 +301,7 @@ fn event_loop(
         retain: false,
     };
     app.inline = started_inline;
-    app.has_hidden_filter = !hide.is_empty();
+    app.configure_hidden_filter(!hide.is_empty());
     let mut decorations = Decorations::new();
     draw(
         terminal,
@@ -388,6 +388,12 @@ fn event_loop(
                         history_requires_alternate_screen = true;
                     }
                 }
+                Event::HiddenCommits(rows) => {
+                    app.extend_hidden_commits(rows);
+                    if history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len()) {
+                        history_requires_alternate_screen = true;
+                    }
+                }
                 Event::Complete => {
                     resize_inline = true;
                     history_requires_alternate_screen =
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4cced3a465d..be73243c8b6 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -44,9 +44,10 @@ pub(crate) fn draw(
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
     let visible_rows = &app.rows[start..end];
-    let has_verifiable_signatures = visible_rows
-        .iter()
-        .any(|row| matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying));
+    let has_verifiable_signatures = visible_rows.iter().enumerate().any(|(index, row)| {
+        !app.is_row_hidden(start + index)
+            && matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying)
+    });
     let lanes = app.render_lanes(start..end);
     let content = Rect::new(
         body.x.saturating_add(2),
@@ -237,6 +238,14 @@ pub(crate) fn draw(
                 frame.buffer_mut()[(x, y)].set_style(Style::default().add_modifier(Modifier::DIM));
             }
         }
+        if app.is_row_hidden(start + index) {
+            for x in body.x..body.right() {
+                frame.buffer_mut()[(x, y)]
+                    .set_fg(Color::Reset)
+                    .set_bg(Color::Reset)
+                    .set_style(Style::default().add_modifier(Modifier::DIM));
+            }
+        }
     }
     app.set_horizontal_bounds(content.width as usize, max_offset);
     if let (Some(area), Some(message)) = (commit_pane, commit_message) {
@@ -1468,6 +1477,53 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renders_hidden_boundary_rows_without_colors() -> Result<(), Box<dyn std::error::Error>> {
+        let commit = |n: u8| Commit {
+            id: gix::ObjectId::Sha1([n; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: format!("subject {n}").into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unverified,
+        };
+        let mut app = App::new(2);
+        app.extend_commits(vec![commit(1)]);
+        app.extend_hidden_commits(vec![commit(2)]);
+        complete(&mut app);
+        app.set_lane(0, "● ");
+        app.set_lane(1, "● ");
+        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let line = rendered_line(&terminal, 1);
+        assert!(line.contains("subject 2"), "the hidden commit keeps its normal content");
+        let visible = rendered_line(&terminal, 0);
+        let visible_hash = visible.find("0101010").expect("the visible hash is present") as u16;
+        assert_ne!(terminal.backend().buffer()[(visible_hash, 0)].fg, Color::Reset);
+        let hash = line.find("0202020").expect("the hidden hash is visible") as u16;
+        assert!(
+            terminal.backend().buffer()[(hash, 1)].modifier.contains(Modifier::BOLD),
+            "non-color styling is retained"
+        );
+        for x in 0..terminal.backend().buffer().area.width {
+            let cell = &terminal.backend().buffer()[(x, 1)];
+            assert_eq!(cell.fg, Color::Reset, "the hidden row has no foreground colors");
+            assert_eq!(cell.bg, Color::Reset, "the hidden row has no background colors");
+            assert!(cell.modifier.contains(Modifier::DIM), "the hidden row is dimmed");
+        }
+        assert_ne!(
+            terminal.backend().buffer()[(0, 1)].symbol(),
+            ">",
+            "the hidden row is not selected"
+        );
+        Ok(())
+    }
+
     #[test]
     fn shows_the_selected_parent_beside_the_junction_disk() -> Result<(), Box<dyn std::error::Error>> {
         let commit = |n: u8, parents: &[u8]| Commit {

From 3e82fba25854ba6bc0ce0fd1de125ae52aef212f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 28 Jul 2026 15:19:04 +0200
Subject: [PATCH 009/282] feat: inspect tree changes in tix

Add a default-open, focusable bottom panel for changed paths in the selected
commit. Preserve diff order, summarize color-coded change kinds and line
counts, support merge-parent cycling and path navigation, cap the panel at
half the screen, and hide it during repeated history navigation. Distinguish
inactive panels and history, expose focus feedback, and return with q/Escape.

Compute line statistics in a temporary available-parallelism worker pool and
use a short-lived cached repository for tree changes. Highlight compared
parents, reuse computed line counts, and open selected file diffs through the
built-in viewer or Git-compatible external diff and core.pager pipeline,
preserving output from immediately closing pagers.

Keep aligned metadata stable while panning and resizing panels. Avoid letting
the default changes view force inline startup into the alternate screen, and
delay empty loading frames to prevent scrollback residue and startup flashes.
On exit, retain only the left selection marker in static frames, including
when leaving an alternate screen, and let Ctrl-C terminate from any focus.
---
 gix-tix/Cargo.toml                |    2 +-
 gix-tix/src/app.rs                |  331 +++++++-
 gix-tix/src/lib.rs                | 1172 +++++++++++++++++++++++++++--
 gix-tix/src/ui.rs                 |  856 +++++++++++++++++++--
 gix-tix/tests/fixtures/history.sh |    4 +-
 5 files changed, 2241 insertions(+), 124 deletions(-)

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 7386d02f175..595ca6c70d3 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -25,7 +25,7 @@ sha256 = ["gix/sha256"]
 [dependencies]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
-gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["mailmap", "parallel", "revision", "command"] }
+gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "parallel", "revision", "command"] }
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 
 [dev-dependencies]
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 5878930df15..d5f6bfebbbd 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -43,6 +43,59 @@ pub(crate) enum SignatureState {
     Failed,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ChangeKind {
+    Added,
+    Modified,
+    Deleted,
+    Renamed,
+    Copied,
+    TypeChanged,
+}
+
+impl ChangeKind {
+    pub(crate) fn letter(self) -> char {
+        match self {
+            ChangeKind::Added => 'A',
+            ChangeKind::Modified => 'M',
+            ChangeKind::Deleted => 'D',
+            ChangeKind::Renamed => 'R',
+            ChangeKind::Copied => 'C',
+            ChangeKind::TypeChanged => 'T',
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct PathChange {
+    pub kind: ChangeKind,
+    pub source: Option<BString>,
+    pub path: BString,
+    pub lines: Option<(u32, u32)>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq)]
+pub(crate) struct Changes {
+    pub parent: Option<ComparedParent>,
+    pub paths: Vec<PathChange>,
+    pub diffs: Vec<gix::object::tree::diff::ChangeDetached>,
+    pub lines_added: u64,
+    pub lines_removed: u64,
+}
+
+impl Changes {
+    pub(crate) fn is_visible(&self) -> bool {
+        self.parent.is_some() || !self.paths.is_empty()
+    }
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct ComparedParent {
+    pub index: usize,
+    pub total: usize,
+    pub id: ObjectId,
+}
+
 #[derive(Debug, Eq, Hash, PartialEq)]
 pub(crate) struct Author {
     pub name: &'static BStr,
@@ -155,11 +208,16 @@ pub(crate) enum Action {
     ToggleHidden,
     ToggleAlign,
     ToggleCommit,
+    ToggleChanges,
+    ToggleChangesFocus,
+    CycleChangesParent,
+    OpenDiff,
     VerifySignatures,
     Cancel,
     Copy,
     CopyAuthor,
     PreviewAuthorCopy(bool),
+    ForceQuit,
     Quit,
 }
 
@@ -169,6 +227,7 @@ pub(crate) enum Effect {
     CopyId(ObjectId),
     CopyAuthor(&'static Author),
     Reload(bool),
+    OpenDiff(usize),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -197,6 +256,18 @@ pub(crate) struct App {
     pub show_hidden: bool,
     pub align_metadata: bool,
     pub show_commit: bool,
+    pub show_changes: bool,
+    pub(crate) changes_suppressed: bool,
+    pub(crate) changes_focused: bool,
+    pub(crate) changes_selected: usize,
+    pub(crate) changes_offset: usize,
+    pub(crate) changes_horizontal_offset: usize,
+    pub(crate) changes_parent: usize,
+    pub(crate) diff_error: Option<String>,
+    changes_page: usize,
+    changes_max: usize,
+    changes_horizontal_page: usize,
+    changes_horizontal_max: usize,
     pub(crate) show_selection_tail: bool,
     pub inline: bool,
     pub preview_author_copy: bool,
@@ -204,6 +275,7 @@ pub(crate) struct App {
     junction_parent: Option<usize>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
+    pub(crate) focus_feedback: Option<&'static str>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
     horizontal_page: usize,
@@ -239,6 +311,18 @@ impl App {
             show_hidden: false,
             align_metadata: true,
             show_commit: false,
+            show_changes: true,
+            changes_suppressed: false,
+            changes_focused: false,
+            changes_selected: 0,
+            changes_offset: 0,
+            changes_horizontal_offset: 0,
+            changes_parent: 0,
+            diff_error: None,
+            changes_page: 1,
+            changes_max: 0,
+            changes_horizontal_page: 1,
+            changes_horizontal_max: 0,
             show_selection_tail: true,
             inline: false,
             preview_author_copy: false,
@@ -246,6 +330,7 @@ impl App {
             junction_parent: None,
             reachable_rows: None,
             copy_feedback: None,
+            focus_feedback: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
             horizontal_page: 1,
@@ -381,30 +466,50 @@ impl App {
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
+            Action::MoveUp if self.changes_focused => self.move_changes(1, false),
+            Action::MoveDown if self.changes_focused => self.move_changes(1, true),
             Action::MoveUp => self.move_reachable(false),
             Action::MoveDown => self.move_reachable(true),
             Action::ScrollLeft => {
-                if !self.cycle_junction_parent(false) {
+                if self.changes_focused {
+                    self.pan_changes(false);
+                } else if !self.cycle_junction_parent(false) {
                     self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
                 }
             }
             Action::ScrollRight => {
-                if !self.cycle_junction_parent(true) {
+                if self.changes_focused {
+                    self.pan_changes(true);
+                } else if !self.cycle_junction_parent(true) {
                     self.horizontal_offset = self
                         .horizontal_offset
                         .saturating_add(self.horizontal_page)
                         .min(self.horizontal_max);
                 }
             }
+            Action::HalfPageUp if self.changes_focused => self.move_changes((self.changes_page / 2).max(1), false),
+            Action::HalfPageDown if self.changes_focused => self.move_changes((self.changes_page / 2).max(1), true),
+            Action::PageUp if self.changes_focused => self.move_changes(self.changes_page, false),
+            Action::PageDown if self.changes_focused => self.move_changes(self.changes_page, true),
             Action::HalfPageUp => self.move_selection((self.viewport_rows / 2).max(1), false),
             Action::HalfPageDown => self.move_selection((self.viewport_rows / 2).max(1), true),
             Action::PageUp => self.move_selection(self.viewport_rows.max(1), false),
             Action::PageDown => self.move_selection(self.viewport_rows.max(1), true),
+            Action::First if self.changes_focused => {
+                self.changes_selected = 0;
+                self.diff_error = None;
+                self.ensure_changes_visible();
+            }
             Action::First => {
                 if let Some(index) = self.first_selectable() {
                     self.select(index);
                 }
             }
+            Action::Last if self.changes_focused => {
+                self.changes_selected = self.changes_max;
+                self.diff_error = None;
+                self.ensure_changes_visible();
+            }
             Action::Last if self.last_selectable().is_some() => {
                 let previous = self.selected;
                 self.selected = self.last_selectable();
@@ -445,6 +550,32 @@ impl App {
             }
             Action::ToggleAlign => self.align_metadata = !self.align_metadata,
             Action::ToggleCommit => self.show_commit = !self.show_commit,
+            Action::ToggleChanges => {
+                self.focus_feedback = None;
+                self.show_changes = !self.show_changes;
+                if !self.show_changes {
+                    self.changes_suppressed = false;
+                    self.changes_focused = false;
+                    self.reset_changes_view();
+                }
+            }
+            Action::ToggleChangesFocus if self.show_changes => {
+                self.changes_focused = !self.changes_focused;
+                if self.changes_focused {
+                    self.clear_preview_author_copy();
+                }
+                self.focus_feedback = Some(if self.changes_focused { "changes" } else { "history" });
+            }
+            Action::CycleChangesParent => {
+                if self.show_changes {
+                    self.changes_parent = self.changes_parent.saturating_add(1);
+                    self.diff_error = None;
+                }
+            }
+            Action::OpenDiff if self.changes_focused => {
+                self.diff_error = None;
+                return vec![Effect::OpenDiff(self.changes_selected)];
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -461,14 +592,15 @@ impl App {
                     return vec![Effect::VerifySignatures(ids)];
                 }
             }
+            Action::ForceQuit => return vec![Effect::Quit],
+            Action::Cancel | Action::Quit if self.changes_focused => self.focus_history(),
+            Action::PreviewAuthorCopy(_) if self.changes_focused => {}
             Action::PreviewAuthorCopy(value) => {
                 if value && !self.preview_author_copy {
                     self.reachability_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
                     self.compute_reachable_rows();
                 } else if !value {
-                    self.reachability_anchor = None;
-                    self.junction_parent = None;
-                    self.reachable_rows = None;
+                    self.clear_preview_author_copy();
                 }
                 self.preview_author_copy = value;
             }
@@ -585,12 +717,12 @@ impl App {
         self.lane_time = None;
         self.estimated_lane_width = 0;
         self.show_hidden = show_hidden;
+        self.changes_suppressed = false;
         self.horizontal_offset = 0;
+        self.focus_history();
+        self.reset_changes_view();
         self.follow_tail = false;
-        self.preview_author_copy = false;
-        self.reachability_anchor = None;
-        self.junction_parent = None;
-        self.reachable_rows = None;
+        self.clear_preview_author_copy();
         self.signature_failures = 0;
         self.signature_verification_running = false;
     }
@@ -612,6 +744,54 @@ impl App {
         self.signature_failures = failed;
     }
 
+    fn move_changes(&mut self, distance: usize, down: bool) {
+        self.diff_error = None;
+        self.changes_selected = if down {
+            self.changes_selected.saturating_add(distance).min(self.changes_max)
+        } else {
+            self.changes_selected.saturating_sub(distance)
+        };
+        self.ensure_changes_visible();
+    }
+
+    fn clear_preview_author_copy(&mut self) {
+        self.preview_author_copy = false;
+        self.reachability_anchor = None;
+        self.junction_parent = None;
+        self.reachable_rows = None;
+    }
+
+    pub(crate) fn focus_history(&mut self) {
+        self.changes_focused = false;
+        self.focus_feedback = None;
+    }
+
+    pub(crate) fn changes_visible(&self) -> bool {
+        self.show_changes && !self.changes_suppressed
+    }
+
+    fn ensure_changes_visible(&mut self) {
+        if self.changes_selected < self.changes_offset {
+            self.changes_offset = self.changes_selected;
+        } else if self.changes_selected >= self.changes_offset.saturating_add(self.changes_page) {
+            self.changes_offset = self.changes_selected + 1 - self.changes_page;
+        }
+        self.changes_offset = self
+            .changes_offset
+            .min(self.changes_max.saturating_add(1).saturating_sub(self.changes_page));
+    }
+
+    fn pan_changes(&mut self, right: bool) {
+        self.changes_horizontal_offset = if right {
+            self.changes_horizontal_offset
+                .saturating_add(self.changes_horizontal_page)
+                .min(self.changes_horizontal_max)
+        } else {
+            self.changes_horizontal_offset
+                .saturating_sub(self.changes_horizontal_page)
+        };
+    }
+
     fn move_selection(&mut self, distance: usize, down: bool) {
         let Some(selected) = self.selected else { return };
         let target = if down {
@@ -786,6 +966,34 @@ impl App {
         self.horizontal_offset = self.horizontal_offset.min(max);
     }
 
+    pub(crate) fn set_changes_bounds(
+        &mut self,
+        page: usize,
+        len: usize,
+        horizontal_page: usize,
+        horizontal_max: usize,
+    ) {
+        self.changes_page = page.max(1);
+        self.changes_max = len.saturating_sub(1);
+        if len == 0 {
+            self.changes_selected = 0;
+            self.changes_offset = 0;
+        } else {
+            self.changes_selected = self.changes_selected.min(self.changes_max);
+            self.ensure_changes_visible();
+        }
+        self.changes_horizontal_page = horizontal_page.max(1);
+        self.changes_horizontal_max = horizontal_max;
+        self.changes_horizontal_offset = self.changes_horizontal_offset.min(horizontal_max);
+    }
+
+    pub(crate) fn reset_changes_view(&mut self) {
+        self.diff_error = None;
+        self.changes_selected = 0;
+        self.changes_offset = 0;
+        self.changes_horizontal_offset = 0;
+    }
+
     #[cfg(test)]
     pub(crate) fn set_lane(&mut self, index: usize, lane: &str) {
         self.test_lanes.resize(self.rows.len(), String::new());
@@ -1355,6 +1563,28 @@ mod tests {
         assert_eq!(app.rows[app.selected.expect("normal navigation is restored")].id, id(2));
     }
 
+    #[test]
+    fn changes_focus_clears_and_ignores_shift() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+
+        app.update(Action::PreviewAuthorCopy(true));
+        assert!(app.preview_author_copy && app.reachable_rows.is_some());
+
+        app.update(Action::ToggleChangesFocus);
+        assert!(
+            app.changes_focused && !app.preview_author_copy && app.reachable_rows.is_none(),
+            "entering the changes pane clears transient history navigation"
+        );
+
+        app.update(Action::PreviewAuthorCopy(true));
+        assert!(
+            !app.preview_author_copy && app.reachable_rows.is_none(),
+            "the inactive history pane ignores Shift"
+        );
+    }
+
     #[test]
     fn shift_defers_reachability_until_the_graph_is_complete() {
         let mut app = App::new(4);
@@ -1465,10 +1695,57 @@ mod tests {
         assert_eq!(app.horizontal_offset, 0, "scrolling is disabled when content fits");
     }
 
+    #[test]
+    fn focused_changes_redirect_navigation_to_the_path_viewport() {
+        let mut app = App::new(2);
+        app.extend_commits((1..=3).map(row).collect::<Vec<_>>());
+        app.set_changes_bounds(4, 10, 20, 45);
+        app.update(Action::ToggleChangesFocus);
+        assert!(app.changes_focused);
+        assert_eq!(app.focus_feedback.take(), Some("changes"));
+        app.update(Action::ToggleChangesFocus);
+        assert!(!app.changes_focused);
+        assert_eq!(app.focus_feedback.take(), Some("history"));
+        app.update(Action::ToggleChangesFocus);
+
+        app.update(Action::MoveDown);
+        assert_eq!((app.changes_selected, app.changes_offset), (1, 0));
+        assert_eq!(app.update(Action::OpenDiff), vec![Effect::OpenDiff(1)]);
+        assert_eq!(
+            app.selected,
+            Some(0),
+            "path selection leaves commit selection untouched"
+        );
+        app.update(Action::PageDown);
+        assert_eq!((app.changes_selected, app.changes_offset), (5, 2));
+        app.update(Action::HalfPageDown);
+        assert_eq!((app.changes_selected, app.changes_offset), (7, 4));
+        app.update(Action::Last);
+        assert_eq!((app.changes_selected, app.changes_offset), (9, 6));
+        app.update(Action::First);
+        assert_eq!((app.changes_selected, app.changes_offset), (0, 0));
+
+        app.update(Action::ScrollRight);
+        app.update(Action::ScrollRight);
+        app.update(Action::ScrollRight);
+        assert_eq!(app.changes_horizontal_offset, 45);
+        assert_eq!(app.horizontal_offset, 0, "path panning leaves the graph untouched");
+        app.update(Action::ScrollLeft);
+        assert_eq!(app.changes_horizontal_offset, 25);
+
+        app.update(Action::ToggleChanges);
+        assert!(!app.changes_focused, "closing the panel returns focus to history");
+        assert!(app.update(Action::OpenDiff).is_empty());
+        assert_eq!(app.changes_selected, 0);
+        assert_eq!(app.changes_offset, 0);
+        assert_eq!(app.changes_horizontal_offset, 0);
+    }
+
     #[test]
     fn toggles_metadata_columns() {
         let mut app = App::new(1);
         assert!(app.show_trailers, "trailer attribution is visible by default");
+        assert!(app.show_changes, "changed paths are visible by default");
 
         app.update(Action::ToggleDate);
         app.update(Action::ToggleEmail);
@@ -1478,6 +1755,8 @@ mod tests {
         app.update(Action::ToggleRefs);
         app.update(Action::ToggleAlign);
         app.update(Action::ToggleCommit);
+        app.update(Action::CycleChangesParent);
+        app.update(Action::ToggleChanges);
 
         assert!(!app.show_committer_date);
         assert!(app.show_emails);
@@ -1491,6 +1770,8 @@ mod tests {
         assert_eq!(app.ref_mode, RefMode::Default);
         assert!(!app.align_metadata);
         assert!(app.show_commit);
+        assert!(!app.show_changes);
+        assert_eq!(app.changes_parent, 1);
         app.update(Action::ToggleAlign);
         assert!(app.align_metadata);
     }
@@ -1567,8 +1848,15 @@ mod tests {
         complete(&mut app);
         app.update(Action::MoveDown);
         let selected = app.rows[app.selected.expect("a row is selected")].id;
+        app.set_changes_bounds(1, 3, 1, 2);
+        app.update(Action::ToggleChangesFocus);
+        app.update(Action::MoveDown);
+        app.update(Action::ScrollRight);
 
         app.reload(true);
+        assert!(!app.changes_focused, "reload returns focus to history");
+        assert_eq!(app.changes_selected, 0);
+        assert_eq!((app.changes_offset, app.changes_horizontal_offset), (0, 0));
         app.extend_commits(vec![row(1), row(2), row(3)]);
         complete(&mut app);
         assert_eq!(
@@ -1606,6 +1894,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pane_exit_keys_return_to_history_but_control_c_quits() {
+        let mut app = App::new(1);
+        app.update(Action::ToggleChangesFocus);
+
+        assert!(app.update(Action::Quit).is_empty());
+        assert!(!app.changes_focused, "q returns focus to history");
+
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(
+            app.update(Action::ForceQuit),
+            vec![Effect::Quit],
+            "Ctrl-C quits even while changes have focus"
+        );
+        assert!(app.update(Action::Cancel).is_empty());
+        assert!(!app.changes_focused, "Escape returns focus to history");
+        assert_eq!(
+            app.state,
+            State::Loading,
+            "Escape does not cancel while changes had focus"
+        );
+
+        assert_eq!(app.update(Action::Cancel), vec![Effect::Cancel]);
+    }
+
     #[test]
     fn shift_starts_with_a_merges_second_parent_rail() {
         let mut app = App::new(7);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index ee6f0a8951a..74ce7a073d1 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -8,7 +8,9 @@ mod ui;
 
 use std::{
     ffi::OsString,
+    io::{self, Write},
     path::{Path, PathBuf},
+    process::{Command, ExitStatus, Stdio},
     sync::{
         Arc,
         atomic::{AtomicBool, Ordering},
@@ -18,7 +20,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
-use app::{Action, App, CommitRow, Effect, State};
+use app::{Action, App, ChangeKind, Changes, CommitRow, ComparedParent, Effect, PathChange, State};
 use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
@@ -28,16 +30,21 @@ use crossterm::{
         PushKeyboardEnhancementFlags,
     },
     execute,
-    style::Print,
+    style::{Print, ResetColor},
     terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
 };
-use gix::bstr::{BString, ByteSlice};
+use gix::{
+    bstr::{BString, ByteSlice},
+    prelude::TreeDiffChangeExt,
+};
 use history::{Authors, Decorations, Event, SharedAuthors};
-use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend};
+use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
 
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
+const REPEAT_IDLE: Duration = Duration::from_millis(75);
+const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 
 struct FillRepository<'a> {
     path: &'a Path,
@@ -45,6 +52,165 @@ struct FillRepository<'a> {
     retain: bool,
 }
 
+type LineCounts = Option<(u32, u32)>;
+type LineDiffResult = (usize, gix::object::tree::diff::ChangeDetached, Result<LineCounts>);
+
+struct LineDiffJob {
+    index: usize,
+    change: gix::object::tree::diff::ChangeDetached,
+}
+
+struct LineDiffPool {
+    jobs: Option<mpsc::Sender<LineDiffJob>>,
+    results: mpsc::Receiver<LineDiffResult>,
+    workers: Vec<std::thread::JoinHandle<()>>,
+}
+
+impl LineDiffPool {
+    fn new(repository_path: &Path, parallelism: usize) -> Result<Self> {
+        let repository = gix::open(repository_path)
+            .context("could not open repository for parallel line diffs")?
+            .into_sync();
+        let mut worker_state = Vec::with_capacity(parallelism);
+        for _ in 0..parallelism {
+            let mut repository = repository.to_thread_local();
+            repository.object_cache_size(OBJECT_CACHE_SIZE);
+            let resource_cache = repository
+                .diff_resource_cache_for_tree_diff()
+                .context("could not initialize parallel line diffs")?;
+            worker_state.push((repository, resource_cache));
+        }
+
+        let (jobs, job_receiver) = mpsc::channel::<LineDiffJob>();
+        let job_receiver =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(job_receiver));
+        let (result_sender, results) = mpsc::channel();
+        let workers = worker_state
+            .into_iter()
+            .map(|(repository, mut resource_cache)| {
+                let job_receiver = gix::features::threading::OwnShared::clone(&job_receiver);
+                let result_sender = result_sender.clone();
+                std::thread::spawn(move || {
+                    loop {
+                        let Ok(job) = gix::features::threading::lock(&job_receiver).recv() else {
+                            break;
+                        };
+                        let result = job
+                            .change
+                            .attach(&repository, &repository)
+                            .diff(&mut resource_cache)
+                            .context("could not prepare line diff")
+                            .and_then(|mut diff| {
+                                diff.line_counts()
+                                    .context("could not count changed lines")
+                                    .map(|counts| counts.map(|counts| (counts.insertions, counts.removals)))
+                            });
+                        resource_cache.clear_resource_cache_keep_allocation();
+                        if result_sender.send((job.index, job.change, result)).is_err() {
+                            break;
+                        }
+                    }
+                })
+            })
+            .collect();
+        Ok(LineDiffPool {
+            jobs: Some(jobs),
+            results,
+            workers,
+        })
+    }
+
+    fn line_counts(
+        &mut self,
+        changes: Vec<gix::object::tree::diff::ChangeDetached>,
+    ) -> Result<Vec<(gix::object::tree::diff::ChangeDetached, LineCounts)>> {
+        let len = changes.len();
+        let jobs = self.jobs.as_ref().context("line diff pool is shutting down")?;
+        for (index, change) in changes.into_iter().enumerate() {
+            jobs.send(LineDiffJob { index, change })
+                .context("line diff workers stopped unexpectedly")?;
+        }
+
+        let mut out: Vec<_> = std::iter::repeat_with(|| None).take(len).collect();
+        let mut first_error = None;
+        for _ in 0..len {
+            let (index, change, result) = self.results.recv().context("line diff workers stopped unexpectedly")?;
+            match result {
+                Ok(lines) => {
+                    *out.get_mut(index)
+                        .context("line diff worker returned an invalid result index")? = Some((change, lines));
+                }
+                Err(err) if first_error.is_none() => first_error = Some(err),
+                Err(_) => {}
+            }
+        }
+        if let Some(err) = first_error {
+            return Err(err);
+        }
+        out.into_iter()
+            .map(|entry| entry.context("line diff worker omitted a result"))
+            .collect()
+    }
+}
+
+impl Drop for LineDiffPool {
+    fn drop(&mut self) {
+        drop(self.jobs.take());
+        for worker in self.workers.drain(..) {
+            drop(worker.join());
+        }
+    }
+}
+
+fn sync_line_diff_pool(
+    pool: &mut Option<LineDiffPool>,
+    visible: bool,
+    repository_path: &Path,
+    parallelism: usize,
+) -> Result<()> {
+    if visible && pool.is_none() {
+        *pool = Some(LineDiffPool::new(repository_path, parallelism.max(1))?);
+    } else if !visible {
+        *pool = None;
+    }
+    Ok(())
+}
+
+enum FileDiff {
+    External(gix::diff::blob::platform::prepare_diff_command::Command),
+    Pager { command: Command, diff: BuiltInDiff },
+    BuiltIn(BuiltInDiff),
+}
+
+pub(crate) struct BuiltInDiff {
+    title: BString,
+    lines: Vec<BString>,
+    max_width: usize,
+}
+
+impl BuiltInDiff {
+    fn new(title: BString, lines: Vec<BString>) -> Self {
+        let max_width = lines
+            .iter()
+            .map(|line| Line::from(line.to_str_lossy()).width())
+            .max()
+            .unwrap_or_default();
+        BuiltInDiff {
+            title,
+            lines,
+            max_width,
+        }
+    }
+
+    fn write_to(&self, mut out: impl Write) -> io::Result<()> {
+        for line in &self.lines {
+            out.write_all(line)?;
+            out.write_all(b"\n")?;
+        }
+        Ok(())
+    }
+}
+
 /// Options for [`run()`].
 #[derive(Clone, Debug, Default)]
 pub struct Options {
@@ -211,10 +377,25 @@ fn should_switch_screen(started_inline: bool, needs_alternate_screen: bool, in_a
     started_inline && needs_alternate_screen != in_alternate_screen
 }
 
+fn configure_initial_screen(app: &mut App, inline: bool) {
+    app.inline = inline;
+    if inline {
+        app.show_changes = false;
+    }
+}
+
 fn history_needs_alternate_screen(screen: Screen, terminal_height: u16, commits: usize) -> bool {
     screen == Screen::Auto && inline_height(screen, terminal_height, commits).is_none()
 }
 
+fn needs_alternate_screen(
+    show_panel: bool,
+    history_requires_alternate_screen: bool,
+    current_inline_height: Option<u16>,
+) -> bool {
+    show_panel || history_requires_alternate_screen || current_inline_height.is_none()
+}
+
 fn resize_inline_screen(terminal: &mut ratatui::DefaultTerminal, height: u16) -> std::io::Result<()> {
     if terminal.get_frame().area().height == height {
         return Ok(());
@@ -243,11 +424,14 @@ fn sync_screen(
     inline_terminal: &mut Option<ratatui::DefaultTerminal>,
     enhanced_keyboard: bool,
 ) -> Result<()> {
-    let needs_alternate_screen = app.show_commit || history_requires_alternate_screen;
+    let inline_height = inline_height(screen, terminal::size()?.1, app.rows.len());
+    let needs_alternate_screen = needs_alternate_screen(
+        app.show_commit || app.show_changes,
+        history_requires_alternate_screen,
+        inline_height,
+    );
     if !should_switch_screen(started_inline, needs_alternate_screen, inline_terminal.is_some()) {
-        if started_inline && app.inline && resize_inline {
-            let height = inline_height(screen, terminal::size()?.1, app.rows.len())
-                .expect("an inline history always has an inline height");
+        if let (true, Some(height)) = (started_inline && app.inline && resize_inline, inline_height) {
             resize_inline_screen(terminal, height).context("could not resize the inline history")?;
         }
         return Ok(());
@@ -259,9 +443,9 @@ fn sync_screen(
     } else if let Some(inline) = inline_terminal.take() {
         leave_alternate_screen(terminal, inline, enhanced_keyboard).context("could not leave the alternate screen")?;
         app.inline = true;
-        let height = inline_height(screen, terminal::size()?.1, app.rows.len())
-            .expect("an inline history always has an inline height");
-        resize_inline_screen(terminal, height).context("could not resize the inline history")?;
+        if let Some(height) = inline_height {
+            resize_inline_screen(terminal, height).context("could not resize the inline history")?;
+        }
     }
     Ok(())
 }
@@ -295,13 +479,22 @@ fn event_loop(
     let mut lane_receiver = None;
     let mut verification_receiver = None;
     let mut commit_message = None;
+    let mut changes = None;
+    let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
+    let mut line_diff_pool = None;
     let mut fill_repository = FillRepository {
         path: &repository_path,
         retained: None,
         retain: false,
     };
-    app.inline = started_inline;
+    configure_initial_screen(&mut app, started_inline);
     app.configure_hidden_filter(!hide.is_empty());
+    sync_line_diff_pool(
+        &mut line_diff_pool,
+        app.show_changes,
+        &repository_path,
+        line_diff_parallelism,
+    )?;
     let mut decorations = Decorations::new();
     draw(
         terminal,
@@ -311,6 +504,8 @@ fn event_loop(
         &authors,
         &mut fill_repository,
         &mut commit_message,
+        &mut changes,
+        &mut line_diff_pool,
     )?;
     let mut last_draw = Instant::now();
     let mut dirty = false;
@@ -318,7 +513,19 @@ fn event_loop(
     let mut inline_terminal = None;
     let mut history_requires_alternate_screen = false;
     let mut focused = true;
+    let mut repeat_deadline: Option<Instant> = None;
     let result: Result<Option<Duration>> = (|| loop {
+        if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
+            repeat_deadline = None;
+            if app.changes_suppressed {
+                app.changes_suppressed = false;
+                dirty = true;
+                urgent = true;
+            } else {
+                fill_repository.retain = false;
+                fill_repository.retained = None;
+            }
+        }
         if let Some(result) = verification_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
                 Ok(results) => {
@@ -357,10 +564,16 @@ fn event_loop(
                 &authors,
                 &mut fill_repository,
                 &mut commit_message,
+                &mut changes,
+                &mut line_diff_pool,
             )?;
             last_draw = Instant::now();
             dirty = false;
             urgent = false;
+            if repeat_deadline.is_none() {
+                fill_repository.retain = false;
+                fill_repository.retained = None;
+            }
             continue;
         }
         let mut events = 0;
@@ -426,11 +639,14 @@ fn event_loop(
                 &authors,
                 &mut fill_repository,
                 &mut commit_message,
+                &mut changes,
+                &mut line_diff_pool,
             )?;
             last_draw = Instant::now();
             dirty = false;
         }
-        let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed()) {
+        let repeat_timeout = repeat_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
+        let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed(), repeat_timeout) {
             Some(timeout) if event::poll(timeout)? => Some(event::read()?),
             Some(_) => None,
             None => Some(event::read()?),
@@ -442,6 +658,8 @@ fn event_loop(
             TerminalEvent::Key(key) => key,
             TerminalEvent::FocusLost => {
                 focused = false;
+                app.changes_suppressed = false;
+                repeat_deadline = None;
                 drop(app.update(Action::PreviewAuthorCopy(false)));
                 dirty = true;
                 urgent = true;
@@ -462,16 +680,40 @@ fn event_loop(
             continue;
         }
         let action = action(key);
-        fill_repository.retain = retains_fill_repository(key.kind, action.as_ref());
-        if !fill_repository.retain {
+        let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focused);
+        if repeats_history {
+            fill_repository.retain = true;
+            repeat_deadline = Some(Instant::now() + REPEAT_IDLE);
+        } else if key.kind != KeyEventKind::Repeat {
+            fill_repository.retain = false;
             fill_repository.retained = None;
         }
+        if repeats_history && app.show_changes {
+            app.changes_suppressed = true;
+        } else if key.kind != KeyEventKind::Repeat && app.changes_suppressed {
+            app.changes_suppressed = false;
+            repeat_deadline = None;
+            dirty = true;
+            urgent = true;
+        }
         let Some(action) = action else {
             continue;
         };
+        if action == Action::ToggleChangesFocus && !changes_focusable(changes.as_ref().map(|(_, _, changes)| changes)) {
+            continue;
+        }
         dirty = true;
         urgent = true;
+        let toggles_changes = action == Action::ToggleChanges;
         let effects = app.update(action);
+        if toggles_changes {
+            sync_line_diff_pool(
+                &mut line_diff_pool,
+                app.show_changes,
+                &repository_path,
+                line_diff_parallelism,
+            )?;
+        }
         for effect in effects {
             match effect {
                 Effect::Cancel => cancelled.store(true, Ordering::Relaxed),
@@ -496,24 +738,31 @@ fn event_loop(
                         gix::features::threading::OwnShared::clone(&authors),
                     );
                 }
+                Effect::OpenDiff(index) => {
+                    let result = changes
+                        .as_ref()
+                        .and_then(|(_, _, changes)| changes.diffs.get(index).zip(changes.paths.get(index)))
+                        .context("selected path no longer has diff resources")
+                        .and_then(|(change, path)| prepare_file_diff(&repository_path, change, path))
+                        .and_then(|diff| match diff {
+                            FileDiff::External(command) => {
+                                run_external_diff(terminal, command, enhanced_keyboard).map(|()| false)
+                            }
+                            FileDiff::Pager { command, diff } => {
+                                run_pager(terminal, command, &diff, enhanced_keyboard).map(|()| false)
+                            }
+                            FileDiff::BuiltIn(diff) => show_builtin_diff(terminal, &diff),
+                        });
+                    match result {
+                        Ok(true) => app.focus_history(),
+                        Err(err) => app.diff_error = Some(format!("{err:#}")),
+                        Ok(false) => {}
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(repository_path.clone(), ids));
                 }
-                Effect::Quit => {
-                    if app.inline {
-                        app.show_selection_tail = false;
-                        draw(
-                            terminal,
-                            &mut app,
-                            &decorations,
-                            &mailmap,
-                            &authors,
-                            &mut fill_repository,
-                            &mut commit_message,
-                        )?;
-                    }
-                    return Ok(None);
-                }
+                Effect::Quit => return Ok(None),
             }
         }
         sync_screen(
@@ -532,9 +781,34 @@ fn event_loop(
         .transpose();
     let outcome = result?;
     restore.context("could not restore the inline terminal")?;
+    if outcome.is_none() && started_inline {
+        prepare_inline_exit(&mut app);
+        sync_line_diff_pool(&mut line_diff_pool, false, &repository_path, line_diff_parallelism)?;
+        draw(
+            terminal,
+            &mut app,
+            &decorations,
+            &mailmap,
+            &authors,
+            &mut fill_repository,
+            &mut commit_message,
+            &mut changes,
+            &mut line_diff_pool,
+        )?;
+    }
     Ok(outcome)
 }
 
+fn prepare_inline_exit(app: &mut App) {
+    app.inline = true;
+    app.show_commit = false;
+    app.show_changes = false;
+    app.changes_suppressed = false;
+    app.changes_focused = false;
+    app.reset_changes_view();
+    app.show_selection_tail = false;
+}
+
 fn start_lane_worker(rows: Vec<CommitRow>) -> mpsc::Receiver<(Vec<CommitRow>, app::Graph, Duration)> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
@@ -608,6 +882,7 @@ fn start_history(
     (cancelled, receiver)
 }
 
+#[expect(clippy::too_many_arguments, reason = "drawing needs the complete view state")]
 fn draw(
     terminal: &mut ratatui::DefaultTerminal,
     app: &mut App,
@@ -616,24 +891,50 @@ fn draw(
     authors: &SharedAuthors,
     fill_repository: &mut FillRepository<'_>,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
+    changes: &mut Option<(gix::ObjectId, usize, Changes)>,
+    line_diff_pool: &mut Option<LineDiffPool>,
 ) -> Result<()> {
     app.viewport_rows = terminal
         .get_frame()
         .area()
         .height
         .saturating_sub(1 + 2 * u16::from(app.inline)) as usize;
+    if !history_is_ready_to_draw(app.state, app.rows.len()) {
+        return Ok(());
+    }
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
-    let selected = app
-        .show_commit
+    let changes_visible = app.changes_visible();
+    let selected = (app.show_commit || changes_visible)
         .then(|| app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id))
         .flatten();
-    let message_to_load = selected.filter(|id| commit_message.as_ref().map(|(cached, _)| cached) != Some(id));
-    if selected.is_none() {
+    let message_to_load = app
+        .show_commit
+        .then_some(selected)
+        .flatten()
+        .filter(|id| commit_message.as_ref().map(|(cached, _)| cached) != Some(id));
+    if changes_visible && selected.is_some() && changes.as_ref().map(|(cached, _, _)| *cached) != selected {
+        app.changes_parent = 0;
+    }
+    let changes_to_load = changes_visible.then_some(selected).flatten().filter(|id| {
+        changes
+            .as_ref()
+            .is_none_or(|(cached, parent, _)| cached != id || *parent != app.changes_parent)
+    });
+    if changes_to_load.is_some() {
+        app.reset_changes_view();
+    }
+    if !app.show_commit || selected.is_none() {
         *commit_message = None;
     }
-    if app.rows[start..end].iter().any(|row| !row.metadata_loaded) || message_to_load.is_some() {
+    if !app.show_changes || app.selected.is_none() {
+        *changes = None;
+    }
+    if app.rows[start..end].iter().any(|row| !row.metadata_loaded)
+        || message_to_load.is_some()
+        || changes_to_load.is_some()
+    {
         let mut one_shot_repository = None;
         let repository = if fill_repository.retain {
             match &mut fill_repository.retained {
@@ -654,9 +955,25 @@ fn draw(
         if let Some(id) = message_to_load {
             *commit_message = Some((id, load_commit_message(repository, id)?));
         }
+        if let Some(id) = changes_to_load {
+            repository.object_cache_size(OBJECT_CACHE_SIZE);
+            let loaded = load_changes(
+                repository,
+                id,
+                app.changes_parent,
+                line_diff_pool
+                    .as_mut()
+                    .context("line diff pool is missing while the changes pane is visible")?,
+            );
+            repository.object_cache_size(None);
+            let loaded = loaded?;
+            app.changes_parent = loaded.parent.map_or(0, |parent| parent.index);
+            *changes = Some((id, app.changes_parent, loaded));
+        }
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
-    terminal.draw(|frame| ui::draw(frame, app, decorations, mailmap, message))?;
+    let changes = changes.as_ref().map(|(_, _, changes)| changes);
+    terminal.draw(|frame| ui::draw(frame, app, decorations, mailmap, message, changes))?;
     Ok(())
 }
 
@@ -666,11 +983,426 @@ fn open_fill_repository(repository_path: &Path) -> Result<gix::Repository> {
     Ok(repository)
 }
 
+fn prepare_file_diff(
+    repository_path: &Path,
+    change: &gix::object::tree::diff::ChangeDetached,
+    path: &PathChange,
+) -> Result<FileDiff> {
+    let mut repository = gix::open(repository_path).context("could not open repository for file diff")?;
+    repository.object_cache_size(OBJECT_CACHE_SIZE);
+    prepare_file_diff_with_repository(&repository, change, path)
+}
+
+fn prepare_file_diff_with_repository(
+    repository: &gix::Repository,
+    change: &gix::object::tree::diff::ChangeDetached,
+    path: &PathChange,
+) -> Result<FileDiff> {
+    let global_command = repository
+        .config_snapshot()
+        .trusted_program(gix::config::tree::Diff::EXTERNAL)
+        .map(gix::path::os_string_into_bstring)
+        .transpose()
+        .context("external diff command is not representable on this platform")?;
+    let mut resources = repository
+        .diff_resource_cache(
+            gix::diff::blob::pipeline::Mode::ToGitUnlessBinaryToTextIsPresent,
+            Default::default(),
+        )
+        .context("could not initialize file diff")?;
+    resources.options.skip_internal_diff_if_external_is_configured = true;
+    change
+        .attach(repository, repository)
+        .diff(&mut resources)
+        .context("could not prepare selected file")?;
+    let prepared = resources.prepare_diff().context("could not prepare selected diff")?;
+    match prepared.operation {
+        gix::diff::blob::platform::prepare_diff::Operation::ExternalCommand { command } => {
+            let command = command.to_owned();
+            prepare_external_diff(repository, &resources, command)
+        }
+        gix::diff::blob::platform::prepare_diff::Operation::InternalDiff { algorithm } => {
+            if let Some(command) = global_command {
+                return prepare_external_diff(repository, &resources, command);
+            }
+            let input = prepared.interned_input();
+            let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &input);
+            let rendered = gix::diff::blob::UnifiedDiff::new(
+                &diff,
+                &input,
+                gix::diff::blob::unified_diff::ConsumeBinaryHunk::new(BString::default(), "\n"),
+                gix::diff::blob::unified_diff::ContextSize::symmetrical(3),
+            )
+            .consume()
+            .context("could not render selected diff")?;
+            prepare_pager(repository, built_in_diff(path, change, Some(rendered), false))
+        }
+        gix::diff::blob::platform::prepare_diff::Operation::SourceOrDestinationIsBinary => {
+            prepare_pager(repository, built_in_diff(path, change, None, true))
+        }
+    }
+}
+
+fn prepare_pager(repository: &gix::Repository, diff: BuiltInDiff) -> Result<FileDiff> {
+    let Some(program) = repository.config_snapshot().trusted_program("core.pager") else {
+        return Ok(FileDiff::BuiltIn(diff));
+    };
+    if program.is_empty() || program == "cat" {
+        return Ok(FileDiff::BuiltIn(diff));
+    }
+    let command = gix::command::prepare(program)
+        .command_may_be_shell_script_disallow_manual_argument_splitting()
+        .with_context(
+            repository
+                .command_context()
+                .context("could not prepare pager environment")?,
+        )
+        .env("GIT_PAGER_IN_USE", "true")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .into();
+    Ok(FileDiff::Pager { command, diff })
+}
+
+fn prepare_external_diff(
+    repository: &gix::Repository,
+    resources: &gix::diff::blob::Platform,
+    command: BString,
+) -> Result<FileDiff> {
+    Ok(FileDiff::External(
+        resources
+            .prepare_diff_command(
+                command,
+                repository
+                    .command_context()
+                    .context("could not prepare external diff environment")?,
+                0,
+                1,
+            )
+            .context("could not prepare external diff command")?,
+    ))
+}
+
+fn built_in_diff(
+    path: &PathChange,
+    change: &gix::object::tree::diff::ChangeDetached,
+    rendered: Option<BString>,
+    binary: bool,
+) -> BuiltInDiff {
+    use gix::object::tree::diff::ChangeDetached;
+
+    let (old_path, new_path, old_mode, new_mode) = match change {
+        ChangeDetached::Addition { entry_mode, .. } => (None, Some(path.path.as_bstr()), None, Some(*entry_mode)),
+        ChangeDetached::Deletion { entry_mode, .. } => (Some(path.path.as_bstr()), None, Some(*entry_mode), None),
+        ChangeDetached::Modification {
+            previous_entry_mode,
+            entry_mode,
+            ..
+        } => (
+            Some(path.path.as_bstr()),
+            Some(path.path.as_bstr()),
+            Some(*previous_entry_mode),
+            Some(*entry_mode),
+        ),
+        ChangeDetached::Rewrite {
+            source_entry_mode,
+            entry_mode,
+            ..
+        } => (
+            path.source.as_ref().map(|path| path.as_bstr()),
+            Some(path.path.as_bstr()),
+            Some(*source_entry_mode),
+            Some(*entry_mode),
+        ),
+    };
+    let display_path = |path: Option<&gix::bstr::BStr>, prefix: &str| -> BString {
+        path.map_or_else(
+            || "/dev/null".into(),
+            |path| format!("{prefix}{}", path.to_str_lossy()).into(),
+        )
+    };
+    let mut lines = vec![
+        format!("--- {}", display_path(old_path, "a/").to_str_lossy()).into(),
+        format!("+++ {}", display_path(new_path, "b/").to_str_lossy()).into(),
+    ];
+    if old_mode != new_mode {
+        if let Some(mode) = old_mode {
+            lines.push(format!("old mode {}", mode.kind().as_octal_str()).into());
+        }
+        if let Some(mode) = new_mode {
+            lines.push(format!("new mode {}", mode.kind().as_octal_str()).into());
+        }
+    }
+    if binary {
+        lines.push("Binary files differ".into());
+    } else if let Some(rendered) = rendered {
+        lines.extend(rendered.lines().map(BString::from));
+    }
+    BuiltInDiff::new(
+        format!("{} {}", path.kind.letter(), path.path.to_str_lossy()).into(),
+        lines,
+    )
+}
+
+fn run_external_diff(
+    terminal: &mut ratatui::DefaultTerminal,
+    mut command: gix::diff::blob::platform::prepare_diff_command::Command,
+    enhanced_keyboard: bool,
+) -> Result<()> {
+    with_suspended_terminal(terminal, enhanced_keyboard, || {
+        let status = command.status().context("could not launch external diff")?;
+        external_diff_status(status)
+    })
+}
+
+fn run_pager(
+    terminal: &mut ratatui::DefaultTerminal,
+    mut command: Command,
+    diff: &BuiltInDiff,
+    enhanced_keyboard: bool,
+) -> Result<()> {
+    with_suspended_terminal(terminal, enhanced_keyboard, || {
+        let start = Instant::now();
+        let mut child = command.spawn().context("could not launch diff pager")?;
+        let write_result = child.stdin.take().map_or_else(
+            || Err(io::Error::other("pager stdin was not piped")),
+            |mut stdin| diff.write_to(&mut stdin),
+        );
+        let status = child.wait().context("could not wait for diff pager");
+        pager_write_result(write_result)?;
+        pager_status(status?)?;
+        if pager_needs_acknowledgement(start.elapsed()) {
+            wait_for_keypress()?;
+        }
+        Ok(())
+    })
+}
+
+fn wait_for_keypress() -> Result<()> {
+    terminal::enable_raw_mode().context("could not read pager acknowledgement")?;
+    loop {
+        if matches!(
+            event::read().context("could not read pager acknowledgement")?,
+            TerminalEvent::Key(KeyEvent {
+                kind: KeyEventKind::Press,
+                ..
+            })
+        ) {
+            return Ok(());
+        }
+    }
+}
+
+fn with_suspended_terminal<T>(
+    terminal: &mut ratatui::DefaultTerminal,
+    enhanced_keyboard: bool,
+    operation: impl FnOnce() -> Result<T>,
+) -> Result<T> {
+    let suspend = disable_input(terminal.backend_mut(), enhanced_keyboard)
+        .and_then(|()| terminal.show_cursor())
+        .and_then(|()| terminal::disable_raw_mode())
+        .and_then(|()| {
+            execute!(
+                terminal.backend_mut(),
+                ResetColor,
+                cursor::MoveTo(0, 0),
+                Clear(ClearType::All)
+            )
+        });
+    if let Err(err) = suspend {
+        let _ = terminal::enable_raw_mode();
+        let _ = enable_input(terminal.backend_mut(), enhanced_keyboard);
+        let _ = terminal.hide_cursor();
+        return Err(err).context("could not suspend terminal for external program");
+    }
+
+    let result = operation();
+    let restore = terminal::enable_raw_mode()
+        .and_then(|()| enable_input(terminal.backend_mut(), enhanced_keyboard))
+        .and_then(|()| terminal.hide_cursor())
+        .and_then(|()| terminal.clear());
+    let value = result?;
+    restore.context("could not restore terminal after external program")?;
+    Ok(value)
+}
+
+fn external_diff_status(status: ExitStatus) -> Result<()> {
+    if status.success() || status.code() == Some(1) {
+        Ok(())
+    } else {
+        anyhow::bail!("external diff exited with {status}")
+    }
+}
+
+fn pager_write_result(result: io::Result<()>) -> Result<()> {
+    match result {
+        Err(err) if err.kind() == io::ErrorKind::BrokenPipe => Ok(()),
+        result => result.context("could not write diff to pager"),
+    }
+}
+
+fn pager_status(status: ExitStatus) -> Result<()> {
+    if status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!("diff pager exited with {status}")
+    }
+}
+
+fn pager_needs_acknowledgement(elapsed: Duration) -> bool {
+    elapsed <= IMMEDIATE_PAGER_EXIT
+}
+
+fn show_builtin_diff(terminal: &mut ratatui::DefaultTerminal, diff: &BuiltInDiff) -> Result<bool> {
+    let mut offset = 0usize;
+    let mut horizontal_offset = 0usize;
+    let mut focused = true;
+    loop {
+        let size = terminal.size().context("could not determine diff viewport")?;
+        let page = usize::from(size.height.saturating_sub(2)).max(1);
+        let max = diff.lines.len().saturating_sub(page);
+        let horizontal_page = usize::from(size.width).max(1);
+        let horizontal_max = diff.max_width.saturating_sub(horizontal_page);
+        offset = offset.min(max);
+        horizontal_offset = horizontal_offset.min(horizontal_max);
+        terminal
+            .draw(|frame| ui::draw_file_diff(frame, diff, offset, horizontal_offset))
+            .context("could not draw file diff")?;
+        let event = event::read().context("could not read file diff input")?;
+        let key = match event {
+            TerminalEvent::FocusLost => {
+                focused = false;
+                continue;
+            }
+            TerminalEvent::FocusGained => {
+                focused = true;
+                continue;
+            }
+            TerminalEvent::Resize(_, _) => continue,
+            TerminalEvent::Key(key) if focused && key.kind != KeyEventKind::Release => key,
+            _ => continue,
+        };
+        match action(key) {
+            Some(Action::OpenDiff) => return Ok(false),
+            Some(Action::ForceQuit | Action::Quit | Action::Cancel) => return Ok(true),
+            Some(Action::MoveUp) => offset = offset.saturating_sub(1),
+            Some(Action::MoveDown) => offset = offset.saturating_add(1).min(max),
+            Some(Action::PageUp) => offset = offset.saturating_sub(page),
+            Some(Action::PageDown) => offset = offset.saturating_add(page).min(max),
+            Some(Action::HalfPageUp) => offset = offset.saturating_sub((page / 2).max(1)),
+            Some(Action::HalfPageDown) => offset = offset.saturating_add((page / 2).max(1)).min(max),
+            Some(Action::First) => offset = 0,
+            Some(Action::Last) => offset = max,
+            Some(Action::ScrollLeft) => horizontal_offset = horizontal_offset.saturating_sub(horizontal_page),
+            Some(Action::ScrollRight) => {
+                horizontal_offset = horizontal_offset.saturating_add(horizontal_page).min(horizontal_max);
+            }
+            _ => {}
+        }
+    }
+}
+
 fn load_commit_message(repository: &gix::Repository, id: gix::ObjectId) -> Result<BString> {
     let commit = repository.find_commit(id).context("could not load commit message")?;
     Ok(commit.message_raw_sloppy().to_owned())
 }
 
+fn load_changes(
+    repository: &gix::Repository,
+    id: gix::ObjectId,
+    requested_parent: usize,
+    line_diff_pool: &mut LineDiffPool,
+) -> Result<Changes> {
+    let commit = repository.find_commit(id).context("could not load changed paths")?;
+    let parents: Vec<_> = commit.parent_ids().collect();
+    let parent_index = requested_parent.checked_rem(parents.len()).unwrap_or_default();
+    let parent = parents.get(parent_index).copied();
+    let new_tree = commit.tree().context("could not load changed commit tree")?;
+    let old_tree = match parent {
+        Some(parent) => Some(
+            parent
+                .object()
+                .context("could not load parent commit")?
+                .try_into_commit()
+                .context("parent is not a commit")?
+                .tree()
+                .context("could not load parent commit tree")?,
+        ),
+        None => None,
+    };
+    let changes = repository
+        .diff_tree_to_tree(old_tree.as_ref(), Some(&new_tree), None)
+        .context("could not diff commit trees")?;
+    let mut out = Changes {
+        parent: (parents.len() > 1).then(|| ComparedParent {
+            index: parent_index,
+            total: parents.len(),
+            id: parent.expect("a merge has parents").detach(),
+        }),
+        ..Changes::default()
+    };
+    let mut diffs = Vec::new();
+    for change in changes {
+        use gix::object::tree::diff::ChangeDetached;
+        let (kind, source, path, is_tree) = match &change {
+            ChangeDetached::Addition {
+                entry_mode, location, ..
+            } => (ChangeKind::Added, None, location.clone(), entry_mode.is_tree()),
+            ChangeDetached::Deletion {
+                entry_mode, location, ..
+            } => (ChangeKind::Deleted, None, location.clone(), entry_mode.is_tree()),
+            ChangeDetached::Modification {
+                previous_entry_mode,
+                entry_mode,
+                location,
+                ..
+            } => (
+                if previous_entry_mode.kind() == entry_mode.kind() {
+                    ChangeKind::Modified
+                } else {
+                    ChangeKind::TypeChanged
+                },
+                None,
+                location.clone(),
+                previous_entry_mode.is_tree() && entry_mode.is_tree(),
+            ),
+            ChangeDetached::Rewrite {
+                source_location,
+                source_entry_mode,
+                entry_mode,
+                location,
+                copy,
+                ..
+            } => (
+                if *copy { ChangeKind::Copied } else { ChangeKind::Renamed },
+                Some(source_location.clone()),
+                location.clone(),
+                source_entry_mode.is_tree() || entry_mode.is_tree(),
+            ),
+        };
+        if is_tree {
+            continue;
+        }
+        out.paths.push(PathChange {
+            kind,
+            source,
+            path,
+            lines: None,
+        });
+        diffs.push(change);
+    }
+    for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
+        path.lines = lines;
+        if let Some((insertions, removals)) = lines {
+            out.lines_added += u64::from(insertions);
+            out.lines_removed += u64::from(removals);
+        }
+        out.diffs.push(change);
+    }
+    Ok(out)
+}
+
 fn actor_bytes(author: &app::Author) -> Vec<u8> {
     let mut out = Vec::with_capacity(author.name.len() + author.email.len() + 3);
     out.extend_from_slice(author.name);
@@ -684,8 +1416,18 @@ fn should_draw(dirty: bool, streaming: bool, since_draw: Duration) -> bool {
     dirty && (!streaming || since_draw >= FRAME_INTERVAL)
 }
 
-fn poll_timeout(streaming: bool, events: usize, dirty: bool, since_draw: Duration) -> Option<Duration> {
-    streaming.then(|| {
+fn history_is_ready_to_draw(state: State, commits: usize) -> bool {
+    commits != 0 || state != State::Loading
+}
+
+fn poll_timeout(
+    streaming: bool,
+    events: usize,
+    dirty: bool,
+    since_draw: Duration,
+    wake_after: Option<Duration>,
+) -> Option<Duration> {
+    let frame_timeout = streaming.then(|| {
         if events == EVENT_BATCH_SIZE {
             Duration::ZERO
         } else if dirty {
@@ -693,7 +1435,12 @@ fn poll_timeout(streaming: bool, events: usize, dirty: bool, since_draw: Duratio
         } else {
             FRAME_INTERVAL
         }
-    })
+    });
+    match (frame_timeout, wake_after) {
+        (Some(frame), Some(wake_after)) => Some(frame.min(wake_after)),
+        (Some(frame), None) => Some(frame),
+        (None, wake_after) => wake_after,
+    }
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
@@ -709,7 +1456,11 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Modifier(ModifierKeyCode::LeftShift | ModifierKeyCode::RightShift) => {
             Some(Action::PreviewAuthorCopy(key.kind != KeyEventKind::Release))
         }
-        KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Quit),
+        KeyCode::Tab => Some(Action::ToggleChangesFocus),
+        KeyCode::Enter => Some(Action::OpenDiff),
+        KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
+        KeyCode::Char('c') => Some(Action::ToggleChanges),
+        KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
@@ -742,6 +1493,10 @@ fn action(key: KeyEvent) -> Option<Action> {
     }
 }
 
+fn changes_focusable(changes: Option<&Changes>) -> bool {
+    changes.is_some_and(Changes::is_visible)
+}
+
 fn repeats_viewport(action: &Action) -> bool {
     matches!(
         action,
@@ -756,8 +1511,8 @@ fn repeats_viewport(action: &Action) -> bool {
     )
 }
 
-fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>) -> bool {
-    kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
+fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>, changes_focused: bool) -> bool {
+    !changes_focused && kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
 }
 
 #[cfg(test)]
@@ -782,6 +1537,210 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn loads_changes_against_each_merge_parent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let repository = gix::open_opts(&fixture, gix::open::Options::isolated())?;
+        let mut line_diff_pool = None;
+        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, 2)?;
+        assert_eq!(
+            line_diff_pool.as_ref().map(|pool| pool.workers.len()),
+            Some(2),
+            "showing changes creates the requested worker pool"
+        );
+        sync_line_diff_pool(&mut line_diff_pool, false, &fixture, 2)?;
+        assert!(line_diff_pool.is_none(), "hiding changes destroys the worker pool");
+        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, 2)?;
+        let line_diff_pool = line_diff_pool
+            .as_mut()
+            .expect("showing changes recreates the worker pool");
+
+        let root = load_changes(
+            &repository,
+            repository.rev_parse_single("v1^{}")?.detach(),
+            0,
+            line_diff_pool,
+        )?;
+        assert_eq!(
+            root.paths,
+            [PathChange {
+                kind: ChangeKind::Added,
+                source: None,
+                path: "root".into(),
+                lines: Some((1, 0)),
+            }],
+            "root commits are compared to the empty tree"
+        );
+        assert_eq!((root.parent, root.lines_added, root.lines_removed), (None, 1, 0));
+        assert_eq!(root.diffs.len(), 1, "the original change is retained for file diffs");
+        match prepare_file_diff_with_repository(&repository, &root.diffs[0], &root.paths[0])? {
+            FileDiff::BuiltIn(diff) => {
+                assert_eq!(diff.title, "A root");
+                assert!(diff.lines.iter().any(|line| line == "+root"));
+            }
+            FileDiff::External(_) => unreachable!("isolated repositories have no external diff"),
+            FileDiff::Pager { .. } => unreachable!("isolated repositories have no pager"),
+        }
+
+        let external_repository = gix::open_opts(
+            &fixture,
+            gix::open::Options::isolated().config_overrides(["diff.external=test --flag"]),
+        )?;
+        match prepare_file_diff_with_repository(&external_repository, &root.diffs[0], &root.paths[0])? {
+            FileDiff::External(command) => assert!(
+                command
+                    .get_args()
+                    .any(|arg| arg.to_string_lossy().contains("test --flag")),
+                "the configured helper is prepared with shell semantics"
+            ),
+            FileDiff::BuiltIn(_) => unreachable!("configured external diffs take precedence"),
+            FileDiff::Pager { .. } => unreachable!("configured external diffs take precedence"),
+        }
+
+        let pager_repository = gix::open_opts(
+            &fixture,
+            gix::open::Options::isolated().config_overrides(["core.pager=delta --dark"]),
+        )?;
+        match prepare_file_diff_with_repository(&pager_repository, &root.diffs[0], &root.paths[0])? {
+            FileDiff::Pager { command, diff } => {
+                assert!(
+                    command
+                        .get_args()
+                        .any(|arg| arg.to_string_lossy().contains("delta --dark")),
+                    "the configured pager is prepared with shell semantics"
+                );
+                let mut patch = Vec::new();
+                diff.write_to(&mut patch)?;
+                assert!(patch.starts_with(b"--- /dev/null\n+++ b/root\n"));
+                assert!(patch.ends_with(b"\n"), "pagers receive a complete final line");
+            }
+            FileDiff::BuiltIn(_) | FileDiff::External(_) => {
+                unreachable!("configured pagers receive built-in diffs")
+            }
+        }
+
+        for setting in ["core.pager=", "core.pager=cat"] {
+            let repository = gix::open_opts(&fixture, gix::open::Options::isolated().config_overrides([setting]))?;
+            assert!(
+                matches!(
+                    prepare_file_diff_with_repository(&repository, &root.diffs[0], &root.paths[0])?,
+                    FileDiff::BuiltIn(_)
+                ),
+                "disabled pagers retain the built-in viewer"
+            );
+        }
+
+        let topic = load_changes(
+            &repository,
+            repository.rev_parse_single("topic")?.detach(),
+            0,
+            line_diff_pool,
+        )?;
+        assert_eq!(
+            topic.paths,
+            [
+                PathChange {
+                    kind: ChangeKind::Added,
+                    source: None,
+                    path: "topic".into(),
+                    lines: Some((1, 0)),
+                },
+                PathChange {
+                    kind: ChangeKind::Added,
+                    source: None,
+                    path: "topic-extra".into(),
+                    lines: Some((1, 0)),
+                }
+            ],
+            "parallel line diffs retain tree-diff order and status"
+        );
+        assert_eq!((topic.lines_added, topic.lines_removed), (2, 0));
+
+        let merge = repository.rev_parse_single("main")?.detach();
+        let first_parent = load_changes(&repository, merge, 0, line_diff_pool)?;
+        assert_eq!(
+            first_parent.parent,
+            Some(ComparedParent {
+                index: 0,
+                total: 2,
+                id: repository.rev_parse_single("main^1")?.detach(),
+            })
+        );
+        assert_eq!(
+            first_parent.paths,
+            [PathChange {
+                kind: ChangeKind::Added,
+                source: None,
+                path: "merged".into(),
+                lines: Some((1, 0)),
+            }],
+            "the default merge diff compares the result to its first parent"
+        );
+
+        let second_parent = load_changes(&repository, merge, 1, line_diff_pool)?;
+        assert_eq!(
+            second_parent.parent,
+            Some(ComparedParent {
+                index: 1,
+                total: 2,
+                id: repository.rev_parse_single("main^2")?.detach(),
+            })
+        );
+        assert_eq!(
+            second_parent.paths,
+            [PathChange {
+                kind: ChangeKind::Added,
+                source: None,
+                path: "main".into(),
+                lines: Some((1, 0)),
+            }],
+            "later parents can be selected independently"
+        );
+        assert_eq!(
+            load_changes(&repository, merge, 2, line_diff_pool)?.parent,
+            first_parent.parent,
+            "parent selection wraps around"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn streams_diff_bytes_and_accepts_early_pager_exit() -> gix_testtools::Result {
+        let diff = BuiltInDiff::new(
+            "M file".into(),
+            vec![BString::from("--- a/file"), BString::from(vec![b'+', 0xff])],
+        );
+        let mut patch = Vec::new();
+
+        diff.write_to(&mut patch)?;
+
+        assert_eq!(patch, b"--- a/file\n+\xff\n", "patch bytes reach the pager unchanged");
+        pager_write_result(Err(io::Error::new(io::ErrorKind::BrokenPipe, "pager quit")))
+            .expect("an early pager exit is normal");
+        assert!(
+            pager_write_result(Err(io::Error::other("write failed"))).is_err(),
+            "other write failures remain visible"
+        );
+        #[cfg(unix)]
+        assert!(
+            pager_status(std::os::unix::process::ExitStatusExt::from_raw(1 << 8)).is_err(),
+            "a failing pager remains visible"
+        );
+        assert!(
+            pager_needs_acknowledgement(Duration::ZERO),
+            "an immediately closing pager leaves its output visible"
+        );
+        assert!(
+            pager_needs_acknowledgement(Duration::from_millis(250)),
+            "the threshold is inclusive"
+        );
+        assert!(
+            !pager_needs_acknowledgement(Duration::from_millis(251)),
+            "longer-running pagers restore tix immediately"
+        );
+        Ok(())
+    }
+
     #[test]
     fn chooses_screen_from_terminal_and_history_height() {
         assert_eq!(
@@ -823,6 +1782,18 @@ mod tests {
 
     #[test]
     fn switches_screens_for_inline_commit_panes_and_large_histories() {
+        let mut inline = App::new(1);
+        configure_initial_screen(&mut inline, true);
+        assert!(inline.inline);
+        assert!(!inline.show_changes, "inline startup hides the default changes view");
+        let mut alternate = App::new(1);
+        configure_initial_screen(&mut alternate, false);
+        assert!(!alternate.inline);
+        assert!(
+            alternate.show_changes,
+            "alternate-screen startup keeps the default changes view"
+        );
+
         assert!(
             should_switch_screen(true, true, false),
             "opening the commit pane from inline mode enters the alternate screen"
@@ -842,6 +1813,14 @@ mod tests {
         assert!(!history_needs_alternate_screen(Screen::Auto, 20, 7));
         assert!(!history_needs_alternate_screen(Screen::Auto, 20, 8));
         assert!(history_needs_alternate_screen(Screen::Auto, 20, 10));
+        assert!(
+            needs_alternate_screen(false, false, None),
+            "current terminal geometry overrides a stale history-fit flag"
+        );
+        assert!(
+            !needs_alternate_screen(false, false, Some(11)),
+            "a fitting current layout may return to inline mode"
+        );
         assert!(
             !history_needs_alternate_screen(Screen::Half, 20, usize::MAX),
             "half-screen mode never switches because history grows"
@@ -850,6 +1829,14 @@ mod tests {
 
     #[test]
     fn maps_navigation_and_control_c() {
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE)),
+            Some(Action::ToggleChangesFocus)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
+            Some(Action::OpenDiff)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::PageUp, KeyModifiers::NONE)),
             Some(Action::PageUp)
@@ -927,6 +1914,14 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)),
             Some(Action::ToggleCommit)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
+            Some(Action::CycleChangesParent)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)),
+            Some(Action::ToggleChanges)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('Y'), KeyModifiers::SHIFT)),
             Some(Action::CopyAuthor)
@@ -949,26 +1944,79 @@ mod tests {
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)),
-            Some(Action::Quit)
+            Some(Action::ForceQuit)
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE)), None);
     }
 
+    #[test]
+    fn only_visible_changes_can_take_focus() {
+        assert!(!changes_focusable(None));
+        assert!(!changes_focusable(Some(&Changes::default())));
+        let changes = Changes {
+            paths: vec![PathChange {
+                kind: ChangeKind::Modified,
+                source: None,
+                path: "file".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        assert!(changes_focusable(Some(&changes)));
+    }
+
     #[test]
     fn retains_the_fill_repository_only_for_repeated_viewport_navigation() {
-        assert!(retains_fill_repository(KeyEventKind::Repeat, Some(&Action::MoveDown)));
-        assert!(!retains_fill_repository(KeyEventKind::Press, Some(&Action::MoveDown)));
-        assert!(!retains_fill_repository(KeyEventKind::Release, Some(&Action::MoveDown)));
+        assert!(retains_fill_repository(
+            KeyEventKind::Repeat,
+            Some(&Action::MoveDown),
+            false
+        ));
+        assert!(!retains_fill_repository(
+            KeyEventKind::Repeat,
+            Some(&Action::MoveDown),
+            true
+        ));
+        assert!(!retains_fill_repository(
+            KeyEventKind::Press,
+            Some(&Action::MoveDown),
+            false
+        ));
+        assert!(!retains_fill_repository(
+            KeyEventKind::Release,
+            Some(&Action::MoveDown),
+            false
+        ));
         assert!(!retains_fill_repository(
             KeyEventKind::Repeat,
-            Some(&Action::ScrollRight)
+            Some(&Action::ScrollRight),
+            false
         ));
         assert!(!retains_fill_repository(
             KeyEventKind::Repeat,
-            Some(&Action::ToggleDate)
+            Some(&Action::ToggleDate),
+            false
         ));
     }
 
+    #[test]
+    fn prepares_a_reduced_selection_after_leaving_the_alternate_screen() {
+        let mut app = App::new(1);
+        app.show_commit = true;
+        app.show_changes = true;
+        app.changes_focused = true;
+
+        prepare_inline_exit(&mut app);
+
+        assert!(app.inline, "the final frame is drawn into the restored inline screen");
+        assert!(
+            !app.show_commit && !app.show_changes,
+            "alternate-screen panels are omitted from the final frame"
+        );
+        assert!(!app.changes_focused, "the hidden panel no longer owns focus");
+        assert!(!app.show_selection_tail, "only the left selection marker remains");
+    }
+
     #[test]
     fn copies_parsed_author_bytes_without_validation() {
         let author = app::Author {
@@ -985,6 +2033,18 @@ mod tests {
 
     #[test]
     fn rendering_is_reactive_and_capped_while_streaming() {
+        assert!(
+            !history_is_ready_to_draw(State::Loading, 0),
+            "the initial empty frame remains outside terminal scrollback"
+        );
+        assert!(
+            history_is_ready_to_draw(State::Loading, 1),
+            "the first commit makes loading history renderable"
+        );
+        assert!(
+            history_is_ready_to_draw(State::Computing, 0),
+            "an empty completed traversal remains renderable"
+        );
         assert!(
             !should_draw(false, false, Duration::MAX),
             "clean frames are never redrawn"
@@ -1002,19 +2062,29 @@ mod tests {
             "streaming frames draw at the deadline"
         );
         assert_eq!(
-            poll_timeout(false, 0, false, Duration::ZERO),
+            poll_timeout(false, 0, false, Duration::ZERO, None),
             None,
             "idle waits reactively for terminal input"
         );
         assert_eq!(
-            poll_timeout(true, EVENT_BATCH_SIZE, true, Duration::ZERO),
+            poll_timeout(true, EVENT_BATCH_SIZE, true, Duration::ZERO, None),
             Some(Duration::ZERO),
             "saturated history batches keep processing"
         );
         assert_eq!(
-            poll_timeout(true, 1, true, Duration::from_millis(10)),
+            poll_timeout(true, 1, true, Duration::from_millis(10), None),
             Some(FRAME_INTERVAL.saturating_sub(Duration::from_millis(10))),
             "dirty streaming frames wait only until their deadline"
         );
+        assert_eq!(
+            poll_timeout(false, 0, false, Duration::ZERO, Some(REPEAT_IDLE)),
+            Some(REPEAT_IDLE),
+            "repeat-idle restoration wakes an otherwise idle event loop"
+        );
+        assert_eq!(
+            poll_timeout(true, 1, true, Duration::from_millis(10), Some(REPEAT_IDLE)),
+            Some(FRAME_INTERVAL.saturating_sub(Duration::from_millis(10))),
+            "the earlier frame deadline takes precedence over repeat-idle restoration"
+        );
     }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index be73243c8b6..803318bf0fe 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -4,22 +4,64 @@ use ratatui::{
     layout::{Constraint, Layout, Margin, Rect},
     style::{Color, Modifier, Style},
     text::{Line, Span, Text},
-    widgets::{Clear, Paragraph, Wrap},
+    widgets::{Block, Borders, Clear, Paragraph, Wrap},
 };
 
 use crate::{
-    app::{App, AttributionKind, CommitRow, CopyKind, NameMode, RefMode, SignatureState, State},
+    BuiltInDiff,
+    app::{App, AttributionKind, ChangeKind, Changes, CommitRow, CopyKind, NameMode, RefMode, SignatureState, State},
     history::{DecorationKind, Decorations},
 };
 
+const COMPARED_PARENT_COLOR: Color = Color::Cyan;
 const NOTE_COLOR: Color = Color::LightMagenta;
 
+pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset: usize, horizontal_offset: usize) {
+    let [header, body, footer] =
+        Layout::vertical([Constraint::Length(1), Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
+    frame.render_widget(Clear, frame.area());
+    frame.render_widget(
+        Paragraph::new(diff.title.to_str_lossy()).style(Style::default().add_modifier(Modifier::BOLD)),
+        header,
+    );
+    let lines = diff
+        .lines
+        .iter()
+        .map(|line| {
+            let style = if line.starts_with(b"@@") {
+                Style::default().fg(Color::Cyan)
+            } else if line.starts_with(b"+") {
+                Style::default().fg(Color::Green)
+            } else if line.starts_with(b"-") {
+                Style::default().fg(Color::Red)
+            } else if line.starts_with(b"Binary ") {
+                Style::default().fg(Color::Yellow)
+            } else {
+                Style::default()
+            };
+            Line::styled(line.to_str_lossy(), style)
+        })
+        .collect::<Vec<_>>();
+    frame.render_widget(
+        Paragraph::new(Text::from(lines)).scroll((
+            u16::try_from(offset).unwrap_or(u16::MAX),
+            u16::try_from(horizontal_offset).unwrap_or(u16::MAX),
+        )),
+        body,
+    );
+    frame.render_widget(
+        Paragraph::new("↑↓/jk move · h/l pan · Enter/q/Esc back").style(Style::default().add_modifier(Modifier::DIM)),
+        footer,
+    );
+}
+
 pub(crate) fn draw(
     frame: &mut Frame<'_>,
     app: &mut App,
     decorations: &Decorations,
     mailmap: &gix::mailmap::Snapshot,
     commit_message: Option<&BStr>,
+    changes: Option<&Changes>,
 ) {
     let [top_spacer, mut body, bottom_spacer, footer] = Layout::vertical([
         Constraint::Length(u16::from(app.inline)),
@@ -30,25 +72,51 @@ pub(crate) fn draw(
     .areas(frame.area());
     frame.render_widget(Clear, top_spacer);
     frame.render_widget(Clear, bottom_spacer);
-    let commit_pane = app.show_commit.then(|| {
-        let width = 80.min(body.width / 2);
-        let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(body);
+    let full_body = body;
+    let compared_parent = if app.changes_visible() {
+        changes.and_then(|changes| changes.parent.map(|parent| parent.id))
+    } else {
+        None
+    };
+    let changes_pane = app.changes_visible().then(|| {
+        let desired_height = changes.filter(|changes| changes.is_visible()).map_or(0, |changes| {
+            u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(3)
+        });
+        let max_height = frame.area().height / 2;
+        let height = desired_height.min(max_height);
+        let [commits, changes] = Layout::vertical([Constraint::Min(0), Constraint::Length(height)]).areas(full_body);
         body = commits;
-        message.inner(Margin {
-            horizontal: 2,
-            vertical: 1,
-        })
+        (
+            changes,
+            changes.inner(Margin {
+                horizontal: 2,
+                vertical: 1,
+            }),
+        )
+    });
+    let commit_pane = app.show_commit.then(|| {
+        let width = 80.min(full_body.width / 2);
+        let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
+        body.width = body.width.min(commits.width);
+        (
+            message,
+            message.inner(Margin {
+                horizontal: 2,
+                vertical: 1,
+            }),
+        )
     });
     app.viewport_rows = body.height as usize;
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
+    let lane_end = start.saturating_add(full_body.height as usize).min(app.rows.len());
     let visible_rows = &app.rows[start..end];
     let has_verifiable_signatures = visible_rows.iter().enumerate().any(|(index, row)| {
         !app.is_row_hidden(start + index)
             && matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying)
     });
-    let lanes = app.render_lanes(start..end);
+    let lanes = app.render_lanes(start..lane_end);
     let content = Rect::new(
         body.x.saturating_add(2),
         body.y,
@@ -98,7 +166,8 @@ pub(crate) fn draw(
                     show_trailers,
                     use_mailmap: app.use_mailmap && !preview_author_copy && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
-                    selected: selected == Some(start + index),
+                    selected: (selected == Some(start + index) && app.show_selection_tail)
+                        || compared_parent == Some(row.id),
                     preview_author_copy,
                     copy_feedback: if selected == Some(start + index) {
                         copy_feedback
@@ -110,18 +179,8 @@ pub(crate) fn draw(
         })
         .collect();
     let graph_max_offset = max_lane_width.saturating_sub(align_width);
-    let metadata_max_offset = if align_metadata {
-        metadata
-            .iter()
-            .map(Line::width)
-            .max()
-            .unwrap_or_default()
-            .saturating_sub((content.width as usize).saturating_sub(align_width))
-    } else {
-        0
-    };
     let max_offset = if align_metadata {
-        graph_max_offset.saturating_add(metadata_max_offset)
+        graph_max_offset
     } else {
         lanes
             .iter()
@@ -134,7 +193,6 @@ pub(crate) fn draw(
     .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
     let graph_offset = horizontal_offset.min(graph_max_offset);
-    let metadata_offset = horizontal_offset.saturating_sub(graph_max_offset);
 
     for (index, metadata) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
@@ -142,11 +200,16 @@ pub(crate) fn draw(
         let selected = app.selected == Some(start + index);
         let metadata_width = metadata.width();
         let signature_color = signature_color(visible_rows[index].signature);
-        let style = if selected {
-            color(signature_color).add_modifier(Modifier::REVERSED)
+        let highlight = if selected && app.show_selection_tail {
+            Some(signature_color)
+        } else if compared_parent == Some(visible_rows[index].id) {
+            Some(COMPARED_PARENT_COLOR)
         } else {
-            Style::default()
+            None
         };
+        let style = highlight.map_or_else(Style::default, |highlight| {
+            color(highlight).add_modifier(Modifier::REVERSED)
+        });
         frame.render_widget(
             Paragraph::new(if selected { "> " } else { "  " }).style(style),
             Rect::new(body.x, y, body.width.min(2), 1),
@@ -163,7 +226,7 @@ pub(crate) fn draw(
                 row_area,
                 lane,
                 graph_offset,
-                selected,
+                highlight,
                 visible_rows[index].signature,
             );
             let aligned = Rect::new(
@@ -173,7 +236,7 @@ pub(crate) fn draw(
                 1,
             );
             frame.render_widget(Clear, aligned);
-            frame.render_widget(Paragraph::new(metadata).scroll((0, metadata_offset as u16)), aligned);
+            frame.render_widget(Paragraph::new(metadata), aligned);
         } else {
             let mut spans = Vec::with_capacity(metadata.spans.len() + 1);
             spans.push(Span::styled(lane, style));
@@ -187,7 +250,7 @@ pub(crate) fn draw(
                 row_area,
                 lane,
                 horizontal_offset,
-                selected,
+                highlight,
                 visible_rows[index].signature,
             );
         }
@@ -219,7 +282,7 @@ pub(crate) fn draw(
         }
         if selected && app.show_selection_tail && body.width > 0 {
             let line_width = if align_metadata {
-                align_width.saturating_add(metadata_width.saturating_sub(metadata_offset))
+                align_width.saturating_add(metadata_width)
             } else {
                 lane.chars()
                     .count()
@@ -248,8 +311,51 @@ pub(crate) fn draw(
         }
     }
     app.set_horizontal_bounds(content.width as usize, max_offset);
-    if let (Some(area), Some(message)) = (commit_pane, commit_message) {
-        render_commit_message(frame, area, message);
+    if let Some((outer, area)) = changes_pane {
+        frame.render_widget(Clear, outer);
+        frame.render_widget(Block::new().borders(Borders::TOP), outer);
+        if let Some(changes) = changes.filter(|changes| changes.is_visible()) {
+            render_changes(frame, area, changes, app);
+            let status = Rect::new(
+                outer.x.saturating_add(2),
+                outer.bottom().saturating_sub(1),
+                outer.width.saturating_sub(4),
+                1,
+            );
+            let mut spans = Vec::new();
+            if let Some(parent) = changes.parent {
+                spans.extend([
+                    Span::styled(
+                        format!(
+                            "vs parent {}/{} {}",
+                            parent.index + 1,
+                            parent.total,
+                            parent.id.to_hex_with_len(7)
+                        ),
+                        color(COMPARED_PARENT_COLOR),
+                    ),
+                    Span::raw(" · p next parent · "),
+                ]);
+            }
+            if let Some(error) = &app.diff_error {
+                spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
+            } else {
+                spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
+            }
+            spans.push(Span::raw(" · c to hide"));
+            frame.render_widget(Paragraph::new(Line::from(spans)), status);
+        }
+        if !app.changes_focused {
+            frame
+                .buffer_mut()
+                .set_style(outer, Style::default().add_modifier(Modifier::DIM));
+        }
+    }
+    if let Some((outer, area)) = commit_pane {
+        frame.render_widget(Clear, outer);
+        if let Some(message) = commit_message {
+            render_commit_message(frame, area, message);
+        }
     }
 
     let status = match app.state {
@@ -263,8 +369,18 @@ pub(crate) fn draw(
         "{} commits{status} · ↑↓/jk move · h/l pan",
         app.rows.len()
     ))];
+    if app.changes_visible() && changes.is_some_and(Changes::is_visible) {
+        footer_spans.push(match app.focus_feedback.take() {
+            Some(destination) => Span::raw(format!(" · Tab → {destination}")),
+            None => Span::raw(" · Tab switch"),
+        });
+    }
+    if app.changes_focused {
+        footer_spans.push(Span::raw(" · q/Esc history"));
+    }
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
     footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
+    footer_spans.extend([Span::raw(" · "), toggle("c changes", app.show_changes)]);
     if app.has_hidden_filter {
         footer_spans.extend([
             Span::raw(" · "),
@@ -313,11 +429,154 @@ pub(crate) fn draw(
             Span::styled("●", color(Color::Green)),
         ]);
     }
-    if app.state == State::Loading {
-        footer_spans.push(Span::raw(" · Esc cancel"));
+    if !app.changes_focused {
+        if app.state == State::Loading {
+            footer_spans.push(Span::raw(" · Esc cancel"));
+        }
+        footer_spans.push(Span::raw(" · q quit"));
     }
-    footer_spans.push(Span::raw(" · q quit"));
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
+    if app.changes_focused {
+        frame
+            .buffer_mut()
+            .set_style(body, Style::default().add_modifier(Modifier::DIM));
+    }
+}
+
+fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, app: &mut App) {
+    if !changes.is_visible() || area.height == 0 {
+        app.set_changes_bounds(0, 0, area.width as usize, 0);
+        return;
+    }
+    let mut summary = Vec::new();
+    for kind in [
+        ChangeKind::Added,
+        ChangeKind::Modified,
+        ChangeKind::Deleted,
+        ChangeKind::Renamed,
+        ChangeKind::Copied,
+        ChangeKind::TypeChanged,
+    ] {
+        let count = changes.paths.iter().filter(|change| change.kind == kind).count();
+        if count == 0 {
+            continue;
+        }
+        if !summary.is_empty() {
+            summary.push(Span::raw("  "));
+        }
+        summary.push(Span::styled(
+            format!("{} = {count}", kind.letter()),
+            color(change_color(kind)),
+        ));
+    }
+    if !summary.is_empty() {
+        summary.push(Span::raw(" · "));
+    }
+    summary.extend([
+        Span::raw(format!("{} files changed · ", changes.paths.len())),
+        Span::styled(format!("+{}", changes.lines_added), color(Color::Green)),
+        Span::raw(" "),
+        Span::styled(format!("-{}", changes.lines_removed), color(Color::Red)),
+    ]);
+    frame.render_widget(
+        Paragraph::new(Line::from(summary)),
+        Rect::new(area.x, area.y, area.width, 1),
+    );
+
+    let path_capacity = usize::from(area.height.saturating_sub(1));
+    let overflow = changes.paths.len() > 1 && changes.paths.len() > path_capacity;
+    let visible_paths = if overflow {
+        path_capacity.saturating_sub(1)
+    } else {
+        path_capacity.min(changes.paths.len())
+    };
+    let lines: Vec<_> = changes
+        .paths
+        .iter()
+        .enumerate()
+        .map(|(index, change)| {
+            let selected = app.changes_focused && index == app.changes_selected;
+            let path_style = if selected {
+                Style::default().add_modifier(Modifier::REVERSED)
+            } else {
+                Style::default()
+            };
+            let mut spans = vec![
+                Span::styled(change.kind.letter().to_string(), color(change_color(change.kind))),
+                Span::raw(" "),
+            ];
+            if let Some(source) = &change.source {
+                spans.extend([
+                    Span::styled(source.to_str_lossy(), path_style),
+                    Span::styled(" -> ", path_style),
+                    Span::styled(change.path.to_str_lossy(), path_style),
+                ]);
+            } else {
+                spans.push(Span::styled(change.path.to_str_lossy(), path_style));
+            }
+            if selected && let Some((insertions, removals)) = change.lines {
+                spans.extend([
+                    Span::raw(" "),
+                    Span::styled(format!("+{insertions}"), color(Color::Green)),
+                    Span::raw(" "),
+                    Span::styled(format!("-{removals}"), color(Color::Red)),
+                ]);
+            }
+            Line::from(spans)
+        })
+        .collect();
+    let horizontal_max = lines
+        .iter()
+        .map(Line::width)
+        .max()
+        .unwrap_or_default()
+        .saturating_sub(area.width as usize);
+    app.set_changes_bounds(visible_paths, changes.paths.len(), area.width as usize, horizontal_max);
+    let path_area = Rect::new(
+        area.x,
+        area.y.saturating_add(1),
+        area.width,
+        u16::try_from(visible_paths).unwrap_or(u16::MAX),
+    );
+    frame.render_widget(
+        Paragraph::new(Text::from(
+            lines
+                .into_iter()
+                .skip(app.changes_offset)
+                .take(visible_paths)
+                .collect::<Vec<_>>(),
+        ))
+        .scroll((0, u16::try_from(app.changes_horizontal_offset).unwrap_or(u16::MAX))),
+        path_area,
+    );
+    let hidden = changes
+        .paths
+        .len()
+        .saturating_sub(app.changes_offset.saturating_add(visible_paths));
+    if overflow && hidden > 0 {
+        frame.render_widget(
+            Paragraph::new(Line::styled(
+                format!("… {hidden} {} not shown", if hidden == 1 { "line" } else { "lines" }),
+                Style::default().add_modifier(Modifier::DIM),
+            )),
+            Rect::new(
+                area.x,
+                area.bottom().saturating_sub(1),
+                area.width,
+                u16::from(area.height > 0),
+            ),
+        );
+    }
+}
+
+fn change_color(kind: ChangeKind) -> Color {
+    match kind {
+        ChangeKind::Added => Color::Green,
+        ChangeKind::Modified => Color::Yellow,
+        ChangeKind::Deleted => Color::Red,
+        ChangeKind::Renamed | ChangeKind::Copied => Color::Cyan,
+        ChangeKind::TypeChanged => Color::Magenta,
+    }
 }
 
 fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr) {
@@ -622,15 +881,15 @@ fn color_graph(
     area: Rect,
     graph: &str,
     offset: usize,
-    selected: bool,
+    highlight: Option<Color>,
     signature: SignatureState,
 ) {
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
             continue;
         }
-        let style = if selected {
-            color(signature_color(signature)).add_modifier(Modifier::REVERSED)
+        let style = if let Some(highlight) = highlight {
+            color(highlight).add_modifier(Modifier::REVERSED)
         } else if symbol == '●' {
             color(signature_color(signature))
         } else {
@@ -686,7 +945,7 @@ mod tests {
     }
 
     fn draw(frame: &mut Frame<'_>, app: &mut App, decorations: &Decorations) {
-        super::draw(frame, app, decorations, &gix::mailmap::Snapshot::default(), None);
+        super::draw(frame, app, decorations, &gix::mailmap::Snapshot::default(), None, None);
     }
 
     fn complete(app: &mut App) {
@@ -697,6 +956,33 @@ mod tests {
         app.finish_lane_computation(rows, lanes, lane_time);
     }
 
+    #[test]
+    fn renders_a_colored_file_diff_pager() -> Result<(), Box<dyn std::error::Error>> {
+        let diff = BuiltInDiff::new(
+            "M file".into(),
+            ["--- a/file", "+++ b/file", "@@ -1 +1 @@", "-old", "+new"]
+                .into_iter()
+                .map(Into::into)
+                .collect(),
+        );
+        let mut terminal = Terminal::new(TestBackend::new(40, 7))?;
+
+        terminal.draw(|frame| draw_file_diff(frame, &diff, 0, 0))?;
+
+        assert_eq!(rendered_line(&terminal, 0).trim(), "M file");
+        for (y, color) in [
+            (1, Color::Red),
+            (2, Color::Green),
+            (3, Color::Cyan),
+            (4, Color::Red),
+            (5, Color::Green),
+        ] {
+            assert_eq!(terminal.backend().buffer()[(0, y)].fg, color);
+        }
+        assert!(rendered_line(&terminal, 6).contains("Enter/q/Esc back"));
+        Ok(())
+    }
+
     #[test]
     fn renders_grouped_attributions_and_bot_names() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
@@ -752,7 +1038,7 @@ mod tests {
 
         let mailmap =
             gix::mailmap::Snapshot::from_bytes(b"Mapped Human <mapped@example.com> Human <human@example.com>\n");
-        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
         let row = rendered_row(&terminal);
         assert!(
@@ -788,7 +1074,7 @@ mod tests {
 
         app.update(Action::ToggleTrailers);
         app.update(Action::ToggleName);
-        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
         let row = rendered_row(&terminal);
         assert!(row.contains("Codex"), "the first n keeps the primary actor");
         assert!(
@@ -796,7 +1082,7 @@ mod tests {
             "the first n hides trailer actors while trailers are enabled"
         );
         app.update(Action::ToggleName);
-        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
         let row = rendered_row(&terminal);
         assert!(!row.contains("Codex"), "the second n hides the primary actor");
         assert!(
@@ -805,7 +1091,7 @@ mod tests {
         );
         app.update(Action::ToggleName);
         app.update(Action::ToggleMailmap);
-        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains("Re: Human"),
             "m restores original trailer actor names"
@@ -918,13 +1204,13 @@ mod tests {
         )]);
         let mailmap =
             gix::mailmap::Snapshot::from_bytes(b"mapped author <mapped@example.com> author <author@example.com>\n");
-        let mut terminal = Terminal::new(TestBackend::new(150, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(180, 2))?;
 
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "1 commits · ↑↓/jk move · h/l pan · [ align · o commit · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
+        let footer_text = "1 commits · ↑↓/jk move · h/l pan · [ align · o commit · c changes · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
-        let mut expected = Buffer::with_lines([format!("{selected_line:<150}"), format!("{footer_text:<150}")]);
+        let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
         }
@@ -965,7 +1251,7 @@ mod tests {
 
         app.inline = true;
         let mut inline_terminal = Terminal::new(TestBackend::new(140, 4))?;
-        inline_terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        inline_terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_line(&inline_terminal, 0).trim().is_empty(),
             "inline mode separates the commits from preceding content"
@@ -993,7 +1279,7 @@ mod tests {
         );
 
         app.update(Action::ToggleMailmap);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains(" author subject"),
             "m restores the original author name"
@@ -1003,7 +1289,7 @@ mod tests {
 
         app.update(Action::ToggleDate);
         app.update(Action::ToggleName);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         let row = rendered_row(&terminal);
         assert!(!row.contains("1970-01-01"), "d hides the committer date");
         assert!(
@@ -1016,7 +1302,7 @@ mod tests {
         assert!(footer_is_dim(&terminal, "n name"), "disabled name is dimmed");
 
         app.update(Action::ToggleName);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains("author"),
             "the second n restores the author name"
@@ -1027,7 +1313,7 @@ mod tests {
         );
 
         app.update(Action::ToggleRefs);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(!rendered_row(&terminal).contains("HEAD"), "no refs hides regular refs");
         assert!(
             !rendered_row(&terminal).contains("refs/patches"),
@@ -1036,7 +1322,7 @@ mod tests {
         assert!(footer_is_dim(&terminal, "r no refs"), "no refs is dimmed");
 
         app.update(Action::ToggleRefs);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(rendered_row(&terminal).contains("HEAD"), "all refs shows regular refs");
         assert!(
             rendered_row(&terminal).contains("refs/patches"),
@@ -1045,7 +1331,7 @@ mod tests {
         assert!(!footer_is_dim(&terminal, "r all refs"), "all refs is not dimmed");
 
         app.update(Action::ToggleRefs);
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(rendered_row(&terminal).contains("HEAD"), "refs shows regular refs");
         assert!(
             !rendered_row(&terminal).contains("refs/patches"),
@@ -1054,20 +1340,20 @@ mod tests {
         assert!(!footer_is_dim(&terminal, "r refs"), "refs is not dimmed");
 
         app.has_hidden_filter = true;
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_line(&terminal, 1).contains("v show hidden"),
             "the footer advertises the configured hidden-history toggle"
         );
         app.show_hidden = true;
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_line(&terminal, 1).contains("v hide hidden"),
             "the footer reflects the unfiltered view"
         );
 
         app.update(Action::PreviewAuthorCopy(true));
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None))?;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         let row = rendered_row(&terminal);
         assert!(
             row.contains("author subject"),
@@ -1176,7 +1462,14 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(2, states.len() as u16))?;
         terminal.draw(|frame| {
             for (y, (state, _)) in states.iter().enumerate() {
-                color_graph(frame, Rect::new(0, y as u16, 2, 1), "●─", 0, true, *state);
+                color_graph(
+                    frame,
+                    Rect::new(0, y as u16, 2, 1),
+                    "●─",
+                    0,
+                    Some(signature_color(*state)),
+                    *state,
+                );
             }
         })?;
 
@@ -1262,6 +1555,7 @@ mod tests {
                 &Decorations::new(),
                 &gix::mailmap::Snapshot::default(),
                 Some(b"subject\n\nbody".as_bstr()),
+                None,
             );
         })?;
         assert_eq!(
@@ -1296,6 +1590,7 @@ mod tests {
                 &Decorations::new(),
                 &gix::mailmap::Snapshot::default(),
                 Some(b"subject".as_bstr()),
+                None,
             );
         })?;
         assert_eq!(
@@ -1306,6 +1601,422 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn changing_the_changes_height_keeps_history_alignment_stable() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(11);
+        app.extend_commits(
+            (1..=8)
+                .map(|n| Commit {
+                    id: gix::ObjectId::Sha1([n; 20]),
+                    parent_ids: Default::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: format!("subject {n}").into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.set_lane(6, "●──────── ");
+        let path = crate::app::PathChange {
+            kind: ChangeKind::Modified,
+            source: None,
+            path: "path".into(),
+            lines: None,
+        };
+        let changes = |len| Changes {
+            paths: vec![path.clone(); len],
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(80, 12))?;
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes(1)),
+            );
+        })?;
+        let short = rendered_line(&terminal, 0)
+            .find("0101010")
+            .expect("metadata is visible with a short changes pane");
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes(8)),
+            );
+        })?;
+        assert_eq!(
+            rendered_line(&terminal, 0).find("0101010"),
+            Some(short),
+            "changes pane height does not move aligned history metadata"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn shows_changed_paths_in_a_bottom_pane_below_the_summary() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(6);
+        app.extend_commits(vec![
+            Commit {
+                id: gix::ObjectId::Sha1([1; 20]),
+                parent_ids: [gix::ObjectId::Sha1([2; 20]), gix::ObjectId::Sha1([3; 20])]
+                    .into_iter()
+                    .collect(),
+                committer_time: gix::date::Time::default(),
+                author: author(b"author", b"author@example.com"),
+                attributions: 0..0,
+                title: "merge".into(),
+                metadata_loaded: true,
+                has_agent_marker: false,
+                signature: SignatureState::Unsigned,
+            },
+            Commit {
+                id: gix::ObjectId::Sha1([2; 20]),
+                parent_ids: Default::default(),
+                committer_time: gix::date::Time::default(),
+                author: author(b"author", b"author@example.com"),
+                attributions: 0..0,
+                title: "parent".into(),
+                metadata_loaded: true,
+                has_agent_marker: false,
+                signature: SignatureState::Unsigned,
+            },
+        ]);
+        complete(&mut app);
+        let changes = Changes {
+            parent: None,
+            paths: vec![
+                crate::app::PathChange {
+                    kind: ChangeKind::Added,
+                    source: None,
+                    path: "added".into(),
+                    lines: Some((10, 0)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Modified,
+                    source: None,
+                    path: "modified".into(),
+                    lines: Some((5, 2)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Deleted,
+                    source: None,
+                    path: "deleted".into(),
+                    lines: Some((0, 7)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Renamed,
+                    source: Some("old".into()),
+                    path: "new".into(),
+                    lines: Some((3, 3)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Copied,
+                    source: Some("source".into()),
+                    path: "copy".into(),
+                    lines: Some((0, 0)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::TypeChanged,
+                    source: None,
+                    path: format!("{}tail", "x".repeat(130)).into(),
+                    lines: Some((24, 5)),
+                },
+            ],
+            diffs: Vec::new(),
+            lines_added: 42,
+            lines_removed: 17,
+        };
+        let mut terminal = Terminal::new(TestBackend::new(120, 16))?;
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+
+        assert_eq!(
+            terminal.backend().buffer()[(20, 7)].symbol(),
+            "─",
+            "the changes pane starts at the screen's halfway point"
+        );
+        assert!(
+            terminal.backend().buffer()[(20, 7)].modifier.contains(Modifier::DIM),
+            "the inactive changes border is dimmed"
+        );
+        assert!(
+            !terminal.backend().buffer()[(5, 0)].modifier.contains(Modifier::DIM)
+                && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
+            "the focused history and its status use their normal intensity"
+        );
+        let summary = rendered_line(&terminal, 8);
+        assert!(
+            summary.contains("A = 1  M = 1  D = 1  R = 1  C = 1  T = 1 · 6 files changed · +42 -17"),
+            "the pane starts with nonzero status and line aggregates"
+        );
+        let added_x = summary.find("A = 1").expect("added aggregate is visible") as u16;
+        let deleted_x = summary.find("D = 1").expect("deleted aggregate is visible") as u16;
+        assert_eq!(terminal.backend().buffer()[(added_x, 8)].fg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(deleted_x, 8)].fg, Color::Red);
+        assert!(
+            terminal.backend().buffer()[(added_x, 8)]
+                .modifier
+                .contains(Modifier::DIM),
+            "the inactive summary is dimmed without losing its colors"
+        );
+        assert!(
+            rendered_line(&terminal, 9).contains("A added"),
+            "changed paths follow the summary in diff order"
+        );
+        let inactive_path = rendered_line(&terminal, 9);
+        let inactive_x = inactive_path.find("A added").expect("changed path is visible") as u16;
+        assert!(
+            terminal.backend().buffer()[(inactive_x, 9)]
+                .modifier
+                .contains(Modifier::DIM)
+                && terminal.backend().buffer()[(inactive_x + 2, 9)]
+                    .modifier
+                    .contains(Modifier::DIM),
+            "the inactive change kind and path are dimmed"
+        );
+        assert!(
+            !rendered_line(&terminal, 9).contains("+10"),
+            "inactive panes do not display a path selection"
+        );
+        assert!(
+            rendered_line(&terminal, 13).contains("… 2 lines not shown"),
+            "the capped pane reports paths that do not fit"
+        );
+        assert!(
+            rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"),
+            "the changes status advertises its navigation keys"
+        );
+        assert!(
+            terminal.backend().buffer()[(2, 14)].modifier.contains(Modifier::DIM),
+            "the inactive changes status is dimmed"
+        );
+        assert!(rendered_line(&terminal, 15).contains("Tab switch"));
+
+        app.changes_suppressed = true;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            !rendered_line(&terminal, 8).contains("files changed"),
+            "repeated history navigation temporarily hides the changes pane"
+        );
+        assert!(
+            app.show_changes && !footer_is_dim(&terminal, "c changes"),
+            "temporary suppression leaves the persistent changes setting enabled"
+        );
+        app.changes_suppressed = false;
+
+        app.update(Action::ToggleChangesFocus);
+        app.update(Action::MoveDown);
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            !terminal.backend().buffer()[(20, 7)].modifier.contains(Modifier::DIM),
+            "the focused changes border uses its normal style"
+        );
+        assert!(
+            terminal.backend().buffer()[(5, 0)].modifier.contains(Modifier::DIM)
+                && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
+            "the inactive history is dimmed without dimming the main status"
+        );
+        assert!(rendered_line(&terminal, 15).contains("Tab → changes"));
+        assert!(rendered_line(&terminal, 15).contains("q/Esc history"));
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 15).contains("Tab switch"),
+            "focus feedback lasts for one redraw"
+        );
+        assert!(
+            !terminal.backend().buffer()[(added_x, 8)]
+                .modifier
+                .contains(Modifier::DIM)
+                && !terminal.backend().buffer()[(2, 14)].modifier.contains(Modifier::DIM),
+            "the focused summary and status use their normal intensity"
+        );
+        let selected = rendered_line(&terminal, 10);
+        assert!(selected.contains("M modified +5 -2"));
+        let path_x = selected.find("modified").expect("selected path is visible") as u16;
+        let kind_x = selected.find("M modified").expect("selected kind is visible") as u16;
+        let added_x = selected.find("+5").expect("selected additions are visible") as u16;
+        let removed_x = selected.find("-2").expect("selected removals are visible") as u16;
+        assert!(
+            !terminal.backend().buffer()[(kind_x, 10)]
+                .modifier
+                .contains(Modifier::DIM)
+                && !terminal.backend().buffer()[(path_x, 10)]
+                    .modifier
+                    .contains(Modifier::DIM),
+            "focused paths use their normal intensity"
+        );
+        assert!(
+            terminal.backend().buffer()[(path_x, 10)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the selected filepath is inverted"
+        );
+        assert_eq!(terminal.backend().buffer()[(added_x, 10)].fg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(removed_x, 10)].fg, Color::Red);
+        assert!(
+            !terminal.backend().buffer()[(added_x, 10)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the diff-line suffix keeps its normal background"
+        );
+        assert!(
+            !rendered_line(&terminal, 9).contains("+10"),
+            "only the selected path displays its line counts"
+        );
+        assert!(rendered_line(&terminal, 13).contains("… 2 lines not shown"));
+        assert!(rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"));
+
+        assert!(
+            rendered_line(&terminal, 14).contains("Enter diff · c to hide"),
+            "the visible changes pane advertises how to hide it"
+        );
+
+        app.update(Action::Last);
+        app.update(Action::ScrollRight);
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert_eq!(app.changes_horizontal_offset, 20);
+        assert!(
+            rendered_line(&terminal, 12).contains("tail"),
+            "h/l pans long path rows while the summary remains fixed"
+        );
+        assert!(
+            !rendered_line(&terminal, 13).contains("not shown"),
+            "the overflow indicator disappears at the end"
+        );
+
+        let mut short_terminal = Terminal::new(TestBackend::new(120, 8))?;
+        short_terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            rendered_line(&short_terminal, 5).contains("… 1 line not shown"),
+            "the overflow count follows the selected final path when no path row fits"
+        );
+
+        let mut merge_changes = changes.clone();
+        merge_changes.parent = Some(crate::app::ComparedParent {
+            index: 0,
+            total: 2,
+            id: gix::ObjectId::Sha1([2; 20]),
+        });
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&merge_changes),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 8).starts_with("  A = 1"),
+            "parent context no longer crowds the aggregate summary"
+        );
+        assert!(
+            rendered_line(&terminal, 14)
+                .contains("vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · c to hide"),
+            "merge diffs keep parent controls alongside navigation"
+        );
+        let parent = rendered_line(&terminal, 1);
+        let disk_x = parent.find('●').expect("the parent disk is visible") as u16;
+        let hash_x = parent.find("0202020").expect("the parent hash is visible") as u16;
+        let buffer = terminal.backend().buffer();
+        assert_eq!(buffer[(disk_x, 1)].fg, COMPARED_PARENT_COLOR);
+        assert!(buffer[(disk_x, 1)].modifier.contains(Modifier::REVERSED));
+        assert!(
+            buffer[(hash_x, 1)].modifier.contains(Modifier::REVERSED),
+            "the compared parent's hash is inverted"
+        );
+        assert!(
+            !rendered_line(&terminal, 15).contains("p next parent"),
+            "parent cycling is absent from the main status line"
+        );
+
+        app.update(Action::ToggleCommit);
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(b"subject".as_bstr()),
+                Some(&changes),
+            );
+        })?;
+        assert_eq!(
+            terminal.backend().buffer()[(62, 7)].symbol(),
+            " ",
+            "the right commit pane is rendered over the bottom changes pane"
+        );
+        Ok(())
+    }
+
     #[test]
     fn aligns_commit_trailers_and_wraps_only_in_the_value_column() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(40, 8))?;
@@ -1427,6 +2138,7 @@ mod tests {
             buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
             "a clipped selection marker uses the right border"
         );
+        let hash_color = buffer[(5, 1)].fg;
         assert_eq!(app.selected, Some(2), "drawing preserves the global selection");
         assert_eq!(app.offset, 1, "drawing preserves the global offset");
 
@@ -1434,9 +2146,22 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let buffer = terminal.backend().buffer();
         assert!(
-            buffer[(0, 1)].modifier.contains(Modifier::REVERSED),
-            "the final frame keeps the left selection marker"
+            !buffer[(0, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
+            "the inactive marker has no selection modifiers"
         );
+        assert!(
+            !buffer[(5, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
+            "the inactive hash has no selection modifiers"
+        );
+        assert_eq!(buffer[(0, 1)].symbol(), ">", "the inactive row keeps its marker");
+        assert_eq!(buffer[(0, 1)].fg, Color::Reset, "the marker uses normal text color");
+        assert_eq!(
+            buffer[(0, 1)].bg,
+            Color::Reset,
+            "the marker has no selection background"
+        );
+        assert_eq!(buffer[(5, 1)].fg, hash_color, "the hash returns to its normal color");
+        assert_eq!(buffer[(5, 1)].bg, Color::Reset, "the hash has no selection background");
         assert!(
             !buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
             "the final frame hides the trailing selection marker"
@@ -1457,6 +2182,7 @@ mod tests {
                     attributions: 0..0,
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
+                    has_agent_marker: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -1537,6 +2263,7 @@ mod tests {
             attributions: 0..0,
             title: format!("subject {n}").into(),
             metadata_loaded: true,
+            has_agent_marker: false,
             signature: SignatureState::Unsigned,
         };
         let mut app = App::new(4);
@@ -1742,9 +2469,14 @@ mod tests {
 
         app.update(Action::ScrollRight);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(
+            terminal.backend().buffer()[(4, 0)].symbol(),
+            "0",
+            "l leaves aligned metadata fixed when there is no graph left to pan"
+        );
         assert!(
-            rendered_row(&terminal).contains("subject-tail"),
-            "l reveals clipped aligned metadata after graph panning is exhausted"
+            !rendered_row(&terminal).contains("subject-tail"),
+            "aligned metadata remains clipped instead of becoming horizontal-scroll content"
         );
         Ok(())
     }
diff --git a/gix-tix/tests/fixtures/history.sh b/gix-tix/tests/fixtures/history.sh
index b053f6040c4..a85ee743cbd 100755
--- a/gix-tix/tests/fixtures/history.sh
+++ b/gix-tix/tests/fixtures/history.sh
@@ -21,8 +21,10 @@ git switch -q main
 commit main "2000-01-03T00:00:00"
 git merge -q --no-edit merged
 git switch -q -c topic HEAD~1
+# Two files make parallel changed-line aggregation and diff ordering observable.
 echo topic >topic
-git add topic
+echo topic-extra >topic-extra
+git add topic topic-extra
 GIT_AUTHOR_DATE="2000-01-04T00:00:00 +0000" GIT_COMMITTER_DATE="2000-01-04T00:00:00 +0000" \
   git commit -q --author="Codex <Codex@OpenAI.com>" -m topic \
     -m "--- agent

From 7d8a087e900c597619c9e8b74e70e15912860322 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 30 Jul 2026 14:33:44 +0200
Subject: [PATCH 010/282] feat: enrich commit details in tix

Show Git notes in history with a bright-purple [N] marker and render their
contents before trailers in the commit view. Load notes lazily for visible
commits through the repository notes platform and refresh them with the view.

Make overflowing commit messages page-scrollable with PgUp/PgDn and Ctrl-b/
Ctrl-f, clamp offsets when content changes, and show pane-specific navigation
status only while scrolling is possible and the pane is focused. Give pane
status bars a distinct background without changing the main status line.
---
 gix-tix/Cargo.toml |   2 +-
 gix-tix/src/app.rs |  69 +++++++-
 gix-tix/src/lib.rs |  45 ++++-
 gix-tix/src/ui.rs  | 410 ++++++++++++++++++++++++++++++++++++---------
 4 files changed, 440 insertions(+), 86 deletions(-)

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 595ca6c70d3..99b7666b7e4 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -25,7 +25,7 @@ sha256 = ["gix/sha256"]
 [dependencies]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
-gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "parallel", "revision", "command"] }
+gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command"] }
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 
 [dev-dependencies]
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index d5f6bfebbbd..8a0bfc7f247 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -237,6 +237,7 @@ pub(crate) struct App {
     pub rows: Vec<CommitRow>,
     hidden_rows: HashSet<ObjectId>,
     titles: Vec<u8>,
+    notes: HashMap<ObjectId, Vec<BString>>,
     graph: Option<Graph>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
@@ -264,6 +265,9 @@ pub(crate) struct App {
     pub(crate) changes_horizontal_offset: usize,
     pub(crate) changes_parent: usize,
     pub(crate) diff_error: Option<String>,
+    pub(crate) commit_offset: usize,
+    commit_page: usize,
+    commit_max: usize,
     changes_page: usize,
     changes_max: usize,
     changes_horizontal_page: usize,
@@ -292,6 +296,7 @@ impl App {
             rows: Vec::new(),
             hidden_rows: HashSet::new(),
             titles: Vec::new(),
+            notes: HashMap::new(),
             graph: None,
             attributions: Vec::new(),
             #[cfg(test)]
@@ -319,6 +324,9 @@ impl App {
             changes_horizontal_offset: 0,
             changes_parent: 0,
             diff_error: None,
+            commit_offset: 0,
+            commit_page: 1,
+            commit_max: 0,
             changes_page: 1,
             changes_max: 0,
             changes_horizontal_page: 1,
@@ -445,6 +453,18 @@ impl App {
         self.titles[row.title.clone()].as_bstr()
     }
 
+    pub(crate) fn notes_loaded(&self, id: ObjectId) -> bool {
+        self.notes.contains_key(&id)
+    }
+
+    pub(crate) fn set_notes(&mut self, id: ObjectId, notes: Vec<BString>) {
+        self.notes.insert(id, notes);
+    }
+
+    pub(crate) fn notes(&self, id: ObjectId) -> &[BString] {
+        self.notes.get(&id).map(Vec::as_slice).unwrap_or_default()
+    }
+
     pub(crate) fn render_lanes(&self, range: Range<usize>) -> RenderedLanes {
         #[cfg(test)]
         if !self.test_lanes.is_empty() {
@@ -491,6 +511,12 @@ impl App {
             Action::HalfPageDown if self.changes_focused => self.move_changes((self.changes_page / 2).max(1), true),
             Action::PageUp if self.changes_focused => self.move_changes(self.changes_page, false),
             Action::PageDown if self.changes_focused => self.move_changes(self.changes_page, true),
+            Action::PageUp if self.show_commit && self.commit_max > 0 => {
+                self.commit_offset = self.commit_offset.saturating_sub(self.commit_page);
+            }
+            Action::PageDown if self.show_commit && self.commit_max > 0 => {
+                self.commit_offset = self.commit_offset.saturating_add(self.commit_page).min(self.commit_max);
+            }
             Action::HalfPageUp => self.move_selection((self.viewport_rows / 2).max(1), false),
             Action::HalfPageDown => self.move_selection((self.viewport_rows / 2).max(1), true),
             Action::PageUp => self.move_selection(self.viewport_rows.max(1), false),
@@ -549,7 +575,10 @@ impl App {
                 return vec![Effect::Reload(!self.show_hidden)];
             }
             Action::ToggleAlign => self.align_metadata = !self.align_metadata,
-            Action::ToggleCommit => self.show_commit = !self.show_commit,
+            Action::ToggleCommit => {
+                self.show_commit = !self.show_commit;
+                self.reset_commit_view();
+            }
             Action::ToggleChanges => {
                 self.focus_feedback = None;
                 self.show_changes = !self.show_changes;
@@ -707,6 +736,7 @@ impl App {
         self.rows = Vec::new();
         self.hidden_rows.clear();
         self.titles = Vec::new();
+        self.notes.clear();
         self.graph = None;
         self.attributions = Vec::new();
         #[cfg(test)]
@@ -720,6 +750,7 @@ impl App {
         self.changes_suppressed = false;
         self.horizontal_offset = 0;
         self.focus_history();
+        self.reset_commit_view();
         self.reset_changes_view();
         self.follow_tail = false;
         self.clear_preview_author_copy();
@@ -966,6 +997,17 @@ impl App {
         self.horizontal_offset = self.horizontal_offset.min(max);
     }
 
+    pub(crate) fn set_commit_bounds(&mut self, page: usize, max: usize) {
+        self.commit_page = page.max(1);
+        self.commit_max = max;
+        self.commit_offset = self.commit_offset.min(max);
+    }
+
+    pub(crate) fn reset_commit_view(&mut self) {
+        self.commit_offset = 0;
+        self.commit_max = 0;
+    }
+
     pub(crate) fn set_changes_bounds(
         &mut self,
         page: usize,
@@ -1667,6 +1709,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn full_pages_target_changes_then_commit_messages_then_history() {
+        let mut app = App::new(2);
+        app.extend_commits((1..=5).map(row).collect::<Vec<_>>());
+        app.show_commit = true;
+        app.set_commit_bounds(3, 7);
+
+        app.update(Action::PageDown);
+        assert_eq!(app.commit_offset, 3);
+        assert_eq!(app.selected, Some(0), "commit paging leaves history selection alone");
+        app.update(Action::PageDown);
+        assert_eq!(app.commit_offset, 6);
+
+        app.changes_focused = true;
+        app.set_changes_bounds(2, 5, 1, 0);
+        app.update(Action::PageDown);
+        assert_eq!(app.changes_selected, 2, "focused changes retain paging priority");
+        assert_eq!(app.commit_offset, 6);
+
+        app.changes_focused = false;
+        app.set_commit_bounds(3, 0);
+        app.update(Action::PageDown);
+        assert_eq!(app.selected, Some(2), "history paging resumes when the commit fits");
+    }
+
     #[test]
     fn half_pages_use_half_the_viewport() {
         let mut app = App::new(4);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 74ce7a073d1..94525eae814 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -464,9 +464,13 @@ fn event_loop(
         screen,
     } = options;
     let repository_path = repository.git_dir().to_owned();
-    let mailmap = gix::open(&repository_path)
-        .context("could not open repository for mailmap")?
-        .open_mailmap();
+    let mut view_repository = gix::open(&repository_path).context("could not open repository for history view")?;
+    view_repository.object_cache_size(None);
+    let mailmap = view_repository.open_mailmap();
+    let mut notes = view_repository
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes")?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
     let (mut cancelled, mut receiver) = start_history(
         repository,
@@ -503,6 +507,7 @@ fn event_loop(
         &mailmap,
         &authors,
         &mut fill_repository,
+        &mut notes,
         &mut commit_message,
         &mut changes,
         &mut line_diff_pool,
@@ -563,6 +568,7 @@ fn event_loop(
                 &mailmap,
                 &authors,
                 &mut fill_repository,
+                &mut notes,
                 &mut commit_message,
                 &mut changes,
                 &mut line_diff_pool,
@@ -638,6 +644,7 @@ fn event_loop(
                 &mailmap,
                 &authors,
                 &mut fill_repository,
+                &mut notes,
                 &mut commit_message,
                 &mut changes,
                 &mut line_diff_pool,
@@ -728,6 +735,7 @@ fn event_loop(
                 Effect::Reload(show_hidden) => {
                     cancelled.store(true, Ordering::Relaxed);
                     app.reload(show_hidden);
+                    notes = open_notes(&repository_path)?;
                     decorations.clear();
                     let hidden = if show_hidden { &[][..] } else { hide.as_slice() };
                     (cancelled, receiver) = start_history(
@@ -791,6 +799,7 @@ fn event_loop(
             &mailmap,
             &authors,
             &mut fill_repository,
+            &mut notes,
             &mut commit_message,
             &mut changes,
             &mut line_diff_pool,
@@ -890,6 +899,7 @@ fn draw(
     mailmap: &gix::mailmap::Snapshot,
     authors: &SharedAuthors,
     fill_repository: &mut FillRepository<'_>,
+    notes: &mut gix::note::Platform,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     changes: &mut Option<(gix::ObjectId, usize, Changes)>,
     line_diff_pool: &mut Option<LineDiffPool>,
@@ -905,6 +915,23 @@ fn draw(
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
+    for index in start..end {
+        let id = app.rows[index].id;
+        if app.notes_loaded(id) {
+            continue;
+        }
+        let loaded = notes
+            .get(id)
+            .map_err(gix::Exn::into_error)
+            .context("could not load visible commit notes")?
+            .into_iter()
+            .map(|note| {
+                let mut blob = note.blob;
+                BString::from(blob.take_data())
+            })
+            .collect();
+        app.set_notes(id, loaded);
+    }
     let changes_visible = app.changes_visible();
     let selected = (app.show_commit || changes_visible)
         .then(|| app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id))
@@ -914,6 +941,9 @@ fn draw(
         .then_some(selected)
         .flatten()
         .filter(|id| commit_message.as_ref().map(|(cached, _)| cached) != Some(id));
+    if message_to_load.is_some() {
+        app.reset_commit_view();
+    }
     if changes_visible && selected.is_some() && changes.as_ref().map(|(cached, _, _)| *cached) != selected {
         app.changes_parent = 0;
     }
@@ -983,6 +1013,15 @@ fn open_fill_repository(repository_path: &Path) -> Result<gix::Repository> {
     Ok(repository)
 }
 
+fn open_notes(repository_path: &Path) -> Result<gix::note::Platform> {
+    let mut repository = gix::open(repository_path).context("could not open repository for Git notes")?;
+    repository.object_cache_size(None);
+    repository
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes")
+}
+
 fn prepare_file_diff(
     repository_path: &Path,
     change: &gix::object::tree::diff::ChangeDetached,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 803318bf0fe..f03e9452cc8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -15,6 +15,7 @@ use crate::{
 
 const COMPARED_PARENT_COLOR: Color = Color::Cyan;
 const NOTE_COLOR: Color = Color::LightMagenta;
+const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
 pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset: usize, horizontal_offset: usize) {
     let [header, body, footer] =
@@ -164,6 +165,7 @@ pub(crate) fn draw(
                     show_author_name,
                     show_emails: app.show_emails,
                     show_trailers,
+                    has_notes: !app.notes(row.id).is_empty(),
                     use_mailmap: app.use_mailmap && !preview_author_copy && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
                     selected: (selected == Some(start + index) && app.show_selection_tail)
@@ -316,34 +318,39 @@ pub(crate) fn draw(
         frame.render_widget(Block::new().borders(Borders::TOP), outer);
         if let Some(changes) = changes.filter(|changes| changes.is_visible()) {
             render_changes(frame, area, changes, app);
-            let status = Rect::new(
-                outer.x.saturating_add(2),
-                outer.bottom().saturating_sub(1),
-                outer.width.saturating_sub(4),
-                1,
-            );
-            let mut spans = Vec::new();
-            if let Some(parent) = changes.parent {
-                spans.extend([
-                    Span::styled(
-                        format!(
-                            "vs parent {}/{} {}",
-                            parent.index + 1,
-                            parent.total,
-                            parent.id.to_hex_with_len(7)
+            if app.changes_focused {
+                let status = Rect::new(
+                    outer.x.saturating_add(2),
+                    outer.bottom().saturating_sub(1),
+                    outer.width.saturating_sub(4),
+                    1,
+                );
+                let mut spans = Vec::new();
+                if let Some(parent) = changes.parent {
+                    spans.extend([
+                        Span::styled(
+                            format!(
+                                "vs parent {}/{} {}",
+                                parent.index + 1,
+                                parent.total,
+                                parent.id.to_hex_with_len(7)
+                            ),
+                            color(COMPARED_PARENT_COLOR),
                         ),
-                        color(COMPARED_PARENT_COLOR),
-                    ),
-                    Span::raw(" · p next parent · "),
-                ]);
-            }
-            if let Some(error) = &app.diff_error {
-                spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
-            } else {
-                spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
+                        Span::raw(" · p next parent · "),
+                    ]);
+                }
+                if let Some(error) = &app.diff_error {
+                    spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
+                } else {
+                    spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
+                }
+                spans.push(Span::raw(" · c to hide"));
+                frame.render_widget(
+                    Paragraph::new(Line::from(spans)).style(Style::default().bg(PANE_STATUS_BACKGROUND)),
+                    status,
+                );
             }
-            spans.push(Span::raw(" · c to hide"));
-            frame.render_widget(Paragraph::new(Line::from(spans)), status);
         }
         if !app.changes_focused {
             frame
@@ -353,8 +360,28 @@ pub(crate) fn draw(
     }
     if let Some((outer, area)) = commit_pane {
         frame.render_widget(Clear, outer);
-        if let Some(message) = commit_message {
-            render_commit_message(frame, area, message);
+        let max_offset = if let Some(message) = commit_message {
+            let notes = app
+                .selected
+                .and_then(|index| app.rows.get(index))
+                .map(|row| app.notes(row.id))
+                .unwrap_or_default();
+            render_commit_message(frame, area, message, notes, app.commit_offset)
+        } else {
+            0
+        };
+        app.set_commit_bounds(area.height as usize, max_offset);
+        if max_offset > 0 {
+            frame.render_widget(
+                Paragraph::new("PgUp/C-b up page · PgDn/C-f down page · o to hide")
+                    .style(Style::default().bg(PANE_STATUS_BACKGROUND)),
+                Rect::new(
+                    outer.x.saturating_add(2),
+                    outer.bottom().saturating_sub(1),
+                    outer.width.saturating_sub(4),
+                    1,
+                ),
+            );
         }
     }
 
@@ -579,74 +606,128 @@ fn change_color(kind: ChangeKind) -> Color {
     }
 }
 
-fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr) {
+fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, notes: &[BString], offset: usize) -> usize {
     let parsed = gix::objs::commit::MessageRef::from_bytes(message);
-    let Some(body) = parsed.body() else {
-        frame.render_widget(
-            Paragraph::new(commit_text(parsed.title, None)).wrap(Wrap { trim: false }),
-            area,
-        );
-        return;
-    };
     let mut body_message = BString::default();
     let mut trailers = Vec::new();
-    for block in body.message_blocks() {
-        body_message.extend_from_slice(block.message);
-        trailers.extend(block.trailers());
+    if let Some(body) = parsed.body() {
+        for block in body.message_blocks() {
+            body_message.extend_from_slice(block.message);
+            trailers.extend(block.trailers());
+        }
     }
-    if trailers.is_empty() || area.width < 3 {
-        frame.render_widget(
-            Paragraph::new(commit_text(parsed.title, parsed.body)).wrap(Wrap { trim: false }),
+    let body_message = body_message.trim_end().as_bstr();
+    let body_message = (!body_message.is_empty()).then_some(body_message);
+    if trailers.is_empty() {
+        return render_scrolling_paragraph(
+            frame,
             area,
+            Paragraph::new(commit_text(parsed.title, parsed.body, notes)).wrap(Wrap { trim: false }),
+            offset,
         );
-        return;
     }
     let key_width = trailers
         .iter()
         .map(|trailer| Line::raw(trailer.token.to_str_lossy()).width())
         .max()
         .unwrap_or_default();
-    if key_width > area.width.saturating_sub(3) as usize {
-        frame.render_widget(
-            Paragraph::new(commit_text(parsed.title, parsed.body)).wrap(Wrap { trim: false }),
-            area,
-        );
-        return;
+    if area.width < 3 || key_width > area.width.saturating_sub(3) as usize {
+        if notes.is_empty() {
+            return render_scrolling_paragraph(
+                frame,
+                area,
+                Paragraph::new(commit_text(parsed.title, parsed.body, notes)).wrap(Wrap { trim: false }),
+                offset,
+            );
+        }
+        let mut text = commit_text(parsed.title, body_message, notes);
+        text.lines.push(Line::default());
+        for trailer in trailers {
+            text.lines.extend(
+                Text::raw(format!(
+                    "{}: {}",
+                    trailer.token.to_str_lossy(),
+                    trailer.value.to_str_lossy()
+                ))
+                .lines,
+            );
+        }
+        return render_scrolling_paragraph(frame, area, Paragraph::new(text).wrap(Wrap { trim: false }), offset);
     }
     let key_width = key_width as u16;
 
-    let body_message = body_message.trim_end().as_bstr();
-    let text = commit_text(parsed.title, (!body_message.is_empty()).then_some(body_message));
+    let text = commit_text(parsed.title, body_message, notes);
     let paragraph = Paragraph::new(text).wrap(Wrap { trim: false });
-    let mut y = area
-        .y
-        .saturating_add(u16::try_from(paragraph.line_count(area.width)).unwrap_or(u16::MAX))
-        .saturating_add(1);
-    frame.render_widget(paragraph, area);
-
+    let body_height = paragraph.line_count(area.width);
     let value_x = area.x.saturating_add(key_width).saturating_add(2);
     let value_width = area.right().saturating_sub(value_x);
-    for trailer in trailers {
-        if y >= area.bottom() {
+    let trailers: Vec<_> = trailers
+        .into_iter()
+        .map(|trailer| {
+            let value = Paragraph::new(trailer.value.to_str_lossy()).wrap(Wrap { trim: false });
+            let height = value.line_count(value_width).max(1);
+            (trailer, height)
+        })
+        .collect();
+    let total_height = body_height
+        .saturating_add(1)
+        .saturating_add(trailers.iter().map(|(_, height)| height).sum::<usize>());
+    let max_offset = total_height.saturating_sub(area.height as usize).min(u16::MAX as usize);
+    let offset = offset.min(max_offset);
+    frame.render_widget(paragraph.scroll((u16::try_from(offset).unwrap_or(u16::MAX), 0)), area);
+
+    let viewport_end = offset.saturating_add(area.height as usize);
+    let mut start = body_height.saturating_add(1);
+    for (trailer, height) in trailers {
+        let end = start.saturating_add(height);
+        if start >= viewport_end {
             break;
         }
-        let value = Paragraph::new(trailer.value.to_str_lossy()).wrap(Wrap { trim: false });
-        let height = u16::try_from(value.line_count(value_width))
-            .unwrap_or(u16::MAX)
-            .max(1)
-            .min(area.bottom().saturating_sub(y));
-        frame.render_widget(
-            Paragraph::new(format!("{}:", trailer.token.to_str_lossy()))
-                .style(color(Color::Green))
-                .right_aligned(),
-            Rect::new(area.x, y, key_width.saturating_add(1), 1),
-        );
-        frame.render_widget(value, Rect::new(value_x, y, value_width, height));
-        y = y.saturating_add(height);
+        if end > offset {
+            let skipped = offset.saturating_sub(start);
+            let y = area
+                .y
+                .saturating_add(u16::try_from(start.saturating_sub(offset)).unwrap_or_default());
+            let visible_height = height
+                .saturating_sub(skipped)
+                .min(area.bottom().saturating_sub(y) as usize);
+            if skipped == 0 {
+                frame.render_widget(
+                    Paragraph::new(format!("{}:", trailer.token.to_str_lossy()))
+                        .style(color(Color::Green))
+                        .right_aligned(),
+                    Rect::new(area.x, y, key_width.saturating_add(1), 1),
+                );
+            }
+            let value = Paragraph::new(trailer.value.to_str_lossy()).wrap(Wrap { trim: false });
+            frame.render_widget(
+                value.scroll((u16::try_from(skipped).unwrap_or(u16::MAX), 0)),
+                Rect::new(
+                    value_x,
+                    y,
+                    value_width,
+                    u16::try_from(visible_height).unwrap_or(u16::MAX),
+                ),
+            );
+        }
+        start = end;
     }
+    max_offset
 }
 
-fn commit_text<'a>(title: &'a BStr, body: Option<&'a BStr>) -> Text<'a> {
+fn render_scrolling_paragraph(frame: &mut Frame<'_>, area: Rect, paragraph: Paragraph<'_>, offset: usize) -> usize {
+    let max_offset = paragraph
+        .line_count(area.width)
+        .saturating_sub(area.height as usize)
+        .min(u16::MAX as usize);
+    frame.render_widget(
+        paragraph.scroll((u16::try_from(offset.min(max_offset)).unwrap_or(u16::MAX), 0)),
+        area,
+    );
+    max_offset
+}
+
+fn commit_text<'a>(title: &'a BStr, body: Option<&'a BStr>, notes: &'a [BString]) -> Text<'a> {
     let mut text = Text::raw(title.to_str_lossy());
     for line in &mut text.lines {
         line.style = Style::default().add_modifier(Modifier::BOLD);
@@ -655,6 +736,18 @@ fn commit_text<'a>(title: &'a BStr, body: Option<&'a BStr>) -> Text<'a> {
         text.lines.push(Line::default());
         text.lines.extend(Text::raw(body.to_str_lossy()).lines);
     }
+    for note in notes {
+        text.lines.push(Line::default());
+        text.lines.push(Line::from(vec![
+            Span::styled("Notes", color(NOTE_COLOR).add_modifier(Modifier::BOLD)),
+            Span::styled(":", color(NOTE_COLOR)),
+        ]));
+        let mut note = Text::raw(note.to_str_lossy());
+        for line in &mut note.lines {
+            line.style = color(NOTE_COLOR);
+        }
+        text.lines.extend(note.lines);
+    }
     text
 }
 
@@ -675,6 +768,7 @@ struct MetadataOptions {
     show_author_name: bool,
     show_emails: bool,
     show_trailers: bool,
+    has_notes: bool,
     use_mailmap: bool,
     ref_mode: RefMode,
     selected: bool,
@@ -696,6 +790,7 @@ fn metadata_line<'a>(
         show_author_name,
         show_emails,
         show_trailers,
+        has_notes,
         use_mailmap,
         ref_mode,
         selected,
@@ -831,6 +926,9 @@ fn metadata_line<'a>(
     if row.has_agent_marker {
         spans.push(Span::styled("[A] ", color(NOTE_COLOR)));
     }
+    if has_notes {
+        spans.push(Span::styled("[N] ", color(NOTE_COLOR)));
+    }
     if !show_emails {
         spans.push(Span::raw(title.to_str_lossy()));
     }
@@ -1665,6 +1763,85 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pages_overflowing_commit_messages_and_hides_the_status_when_they_fit() -> Result<(), Box<dyn std::error::Error>>
+    {
+        let mut app = App::new(4);
+        app.extend_commits(vec![Commit {
+            id: gix::ObjectId::Sha1([1; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        app.update(Action::ToggleCommit);
+        let message = b"subject\n\none\ntwo\nthree\nfour\nfive\nsix\n\nSigned-off-by: Alice".as_bstr();
+        let mut terminal = Terminal::new(TestBackend::new(120, 7))?;
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(message),
+                None,
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 5).contains("PgUp/C-b up page · PgDn/C-f down page"),
+            "overflowing commit messages advertise both full-page key pairs"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(62, 5)].bg,
+            PANE_STATUS_BACKGROUND,
+            "the commit status has the shared pane-status background"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(0, 6)].bg,
+            Color::Reset,
+            "the main status keeps its original background"
+        );
+
+        app.update(Action::PageDown);
+        app.update(Action::PageDown);
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(message),
+                None,
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 4).contains("Alice"),
+            "the last page reaches aligned trailers"
+        );
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(b"subject".as_bstr()),
+                None,
+            );
+        })?;
+        assert!(
+            !rendered_line(&terminal, 5).contains("PgUp"),
+            "the commit status disappears when all content fits"
+        );
+        assert_eq!(app.commit_offset, 0, "shorter content clamps the old offset");
+        Ok(())
+    }
+
     #[test]
     fn shows_changed_paths_in_a_bottom_pane_below_the_summary() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(6);
@@ -1805,12 +1982,13 @@ mod tests {
             "the capped pane reports paths that do not fit"
         );
         assert!(
-            rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"),
-            "the changes status advertises its navigation keys"
+            !rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"),
+            "the unfocused changes status is hidden"
         );
-        assert!(
-            terminal.backend().buffer()[(2, 14)].modifier.contains(Modifier::DIM),
-            "the inactive changes status is dimmed"
+        assert_eq!(
+            terminal.backend().buffer()[(2, 15)].bg,
+            Color::Reset,
+            "the main status keeps its original background"
         );
         assert!(rendered_line(&terminal, 15).contains("Tab switch"));
 
@@ -1851,6 +2029,15 @@ mod tests {
             !terminal.backend().buffer()[(20, 7)].modifier.contains(Modifier::DIM),
             "the focused changes border uses its normal style"
         );
+        assert!(
+            rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"),
+            "the focused changes status advertises its navigation keys"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(2, 14)].bg,
+            PANE_STATUS_BACKGROUND,
+            "the focused changes status uses the shared pane-status background"
+        );
         assert!(
             terminal.backend().buffer()[(5, 0)].modifier.contains(Modifier::DIM)
                 && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
@@ -2022,7 +2209,9 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(40, 8))?;
         let message = b"subject\n\nbody\n\nShort: one two three four five six seven\nCo-authored-by: Alice".as_bstr();
 
-        terminal.draw(|frame| render_commit_message(frame, frame.area(), message))?;
+        terminal.draw(|frame| {
+            render_commit_message(frame, frame.area(), message, &[], 0);
+        })?;
 
         assert_eq!(
             rendered_line(&terminal, 4).find("one"),
@@ -2063,7 +2252,7 @@ mod tests {
 
         let mut plain_terminal = Terminal::new(TestBackend::new(40, 4))?;
         plain_terminal.draw(|frame| {
-            render_commit_message(frame, frame.area(), b"plain subject\n\nplain body".as_bstr());
+            render_commit_message(frame, frame.area(), b"plain subject\n\nplain body".as_bstr(), &[], 0);
         })?;
         assert!(
             plain_terminal.backend().buffer()[(0, 0)]
@@ -2080,7 +2269,9 @@ mod tests {
 
         let mut terminal = Terminal::new(TestBackend::new(60, 8))?;
         let message = b"subject\n\nnot a trailer\nSigned-off-by: Alice\nanother note\nSigned-off-by: Bob".as_bstr();
-        terminal.draw(|frame| render_commit_message(frame, frame.area(), message))?;
+        terminal.draw(|frame| {
+            render_commit_message(frame, frame.area(), message, &[], 0);
+        })?;
         assert!(
             rendered_line(&terminal, 2).contains("not a trailer")
                 && rendered_line(&terminal, 3).contains("another note"),
@@ -2103,6 +2294,62 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renders_note_markers_and_notes_before_trailers() -> Result<(), Box<dyn std::error::Error>> {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: true,
+            signature: SignatureState::Unsigned,
+        }]);
+        app.set_notes(id, vec!["review note".into()]);
+        app.selected = None;
+        let mut history = Terminal::new(TestBackend::new(100, 2))?;
+        history.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let row = rendered_row(&history);
+        let agent_x = row.find("[A]").expect("the agent marker is visible") as u16;
+        let note_x = row.find("[N]").expect("the note marker is visible") as u16;
+        assert!(
+            row.contains("[A] [N] subject"),
+            "agent and note markers precede the title"
+        );
+        assert_eq!(history.backend().buffer()[(agent_x, 0)].fg, Color::LightMagenta);
+        assert_eq!(history.backend().buffer()[(note_x, 0)].fg, Color::LightMagenta);
+
+        let mut message = Terminal::new(TestBackend::new(40, 9))?;
+        message.draw(|frame| {
+            render_commit_message(
+                frame,
+                frame.area(),
+                b"subject\n\nbody\n\nSigned-off-by: Alice".as_bstr(),
+                &["review note".into()],
+                0,
+            );
+        })?;
+        assert_eq!(rendered_line(&message, 4).trim(), "Notes:");
+        assert_eq!(rendered_line(&message, 5).trim(), "review note");
+        assert!(rendered_line(&message, 7).contains("Alice"), "trailers follow notes");
+        let notes_label = &message.backend().buffer()[(0, 4)];
+        assert_eq!(notes_label.fg, NOTE_COLOR);
+        assert!(
+            notes_label.modifier.contains(Modifier::BOLD),
+            "only the Notes label is bold"
+        );
+        assert!(
+            !message.backend().buffer()[(5, 4)].modifier.contains(Modifier::BOLD)
+                && !message.backend().buffer()[(0, 5)].modifier.contains(Modifier::BOLD),
+            "the colon and note body are not bold"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_only_the_visible_rows() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);
@@ -2353,6 +2600,7 @@ mod tests {
                 show_author_name: true,
                 show_emails: false,
                 show_trailers: true,
+                has_notes: false,
                 use_mailmap: false,
                 ref_mode: RefMode::All,
                 selected: false,

From 55baddbfb57d82bba310bc46f64027762ba5d5df Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 3 Aug 2026 15:35:19 +0200
Subject: [PATCH 011/282] feat: refresh tix history when input references move

Watch the repository reference stores with native filesystem notifications and extract every direct or symbolic reference used by the view and hidden revspecs. Re-evaluate notifications lazily: traversal-tip changes refresh history, while unrelated reference changes are ignored and visible decoration changes update without retraversal. Defer tip refreshes until the active traversal and lane computation finish, and retain Shift-R only as a fallback when a watcher cannot be established.

Keep an append-only cache of discovered commit rows and their complete parent topology. Incremental walks stop at cached commits, decode only newly encountered ODB commits, and derive the current visible and hidden-boundary projection in memory without pruning commits that leave the view. Recompute lanes off-thread and atomically replace the rendered graph so the old frame and selection remain stable until the refreshed graph is ready.

Reopen isolated repositories with a small object cache for incremental traversal, preserve notes refresh behavior for manual view toggles, and re-evaluate inline versus alternate-screen sizing after the projected history changes. Treat refs that disappear between filesystem enumeration and reading as transient, while continuing to report malformed or inaccessible refs. Add coverage for symbolic reference discovery, missing-ref races, and cached fast-forward, rewind, and restoration.
---
 Cargo.lock             |  77 +++++++++++++++++
 gix-tix/Cargo.toml     |   1 +
 gix-tix/src/app.rs     | 191 ++++++++++++++++++++++++++++++++++++----
 gix-tix/src/history.rs | 192 ++++++++++++++++++++++++++++++++++++++++-
 gix-tix/src/lib.rs     | 186 ++++++++++++++++++++++++++++++++++-----
 gix-tix/src/ui.rs      |  29 +++++--
 6 files changed, 628 insertions(+), 48 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8bc0c36cdae..94051ba0a1e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1340,6 +1340,15 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
 
+[[package]]
+name = "fsevent-sys"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "futures-channel"
 version = "0.3.32"
@@ -2568,6 +2577,7 @@ dependencies = [
  "crossterm",
  "gix",
  "gix-testtools",
+ "notify",
  "ratatui",
 ]
 
@@ -3187,6 +3197,26 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "inotify"
+version = "0.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "153be1941a183ec9ccd095ddbe17a8b8d435ef6c76e9e02451b933c3999af2c8"
+dependencies = [
+ "bitflags 2.13.0",
+ "inotify-sys",
+ "libc",
+]
+
+[[package]]
+name = "inotify-sys"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c033f80b2c113cdf91ab7a33faa9cbc014726dcad99880c8609af2a370edf37d"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "insta"
 version = "1.48.0"
@@ -3470,6 +3500,26 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "kqueue"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "273c0752728918e0ac4976f2b275b6fefb9ecd400585dec929419f3844cd87b5"
+dependencies = [
+ "kqueue-sys",
+ "libc",
+]
+
+[[package]]
+name = "kqueue-sys"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "07293a4e297ac234359b510362495713f75ea345d5307140414f20c69ffeb087"
+dependencies = [
+ "bitflags 2.13.0",
+ "libc",
+]
+
 [[package]]
 name = "kv-log-macro"
 version = "1.0.7"
@@ -3717,6 +3767,33 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "notify"
+version = "8.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d3d07927151ff8575b7087f245456e549fea62edf0ec4e565a5ee50c8402bc3"
+dependencies = [
+ "bitflags 2.13.0",
+ "fsevent-sys",
+ "inotify",
+ "kqueue",
+ "libc",
+ "log",
+ "mio",
+ "notify-types",
+ "walkdir",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "notify-types"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42b8cfee0e339a0337359f3c88165702ac6e600dc01c0cc9579a92d62b08477a"
+dependencies = [
+ "bitflags 2.13.0",
+]
+
 [[package]]
 name = "ntapi"
 version = "0.4.3"
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 99b7666b7e4..ca927441ebc 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -26,6 +26,7 @@ sha256 = ["gix/sha256"]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
 gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command"] }
+notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 
 [dev-dependencies]
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 8a0bfc7f247..894780743d8 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -205,6 +205,7 @@ pub(crate) enum Action {
     ToggleTrailers,
     ToggleMailmap,
     ToggleRefs,
+    Refresh,
     ToggleHidden,
     ToggleAlign,
     ToggleCommit,
@@ -235,7 +236,10 @@ pub(crate) enum Effect {
 #[derive(Debug)]
 pub(crate) struct App {
     pub rows: Vec<CommitRow>,
+    all_rows: HashMap<ObjectId, CommitRow>,
+    all_order: Vec<ObjectId>,
     hidden_rows: HashSet<ObjectId>,
+    pending_hidden_rows: Option<HashSet<ObjectId>>,
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
     graph: Option<Graph>,
@@ -288,13 +292,17 @@ pub(crate) struct App {
     reload_selection: Option<ObjectId>,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
+    pub(crate) manual_refresh: bool,
 }
 
 impl App {
     pub fn new(viewport_rows: usize) -> Self {
         App {
             rows: Vec::new(),
+            all_rows: HashMap::new(),
+            all_order: Vec::new(),
             hidden_rows: HashSet::new(),
+            pending_hidden_rows: None,
             titles: Vec::new(),
             notes: HashMap::new(),
             graph: None,
@@ -347,6 +355,7 @@ impl App {
             reload_selection: None,
             signature_failures: 0,
             signature_verification_running: false,
+            manual_refresh: false,
         }
     }
 
@@ -358,29 +367,15 @@ impl App {
     }
 
     pub(crate) fn extend_commits(&mut self, commits: impl Into<LoadedCommits>) {
-        let LoadedCommits { rows, attributions } = commits.into();
-        if self.state != State::Loading || rows.is_empty() {
+        let commits = commits.into();
+        if self.state != State::Loading || commits.rows.is_empty() {
             return;
         }
+        let rows = self.store_commits(commits);
         let was_empty = self.rows.is_empty();
-        self.titles.reserve(rows.iter().map(|row| row.title.len()).sum());
-        let attribution_base = self.attributions.len();
-        self.attributions.extend(attributions);
         self.rows.reserve(rows.len());
         for row in rows {
-            let start = self.titles.len();
-            self.titles.extend_from_slice(&row.title);
-            self.rows.push(Commit {
-                id: row.id,
-                parent_ids: row.parent_ids,
-                committer_time: row.committer_time,
-                author: row.author,
-                attributions: attribution_base + row.attributions.start..attribution_base + row.attributions.end,
-                title: start..self.titles.len(),
-                metadata_loaded: row.metadata_loaded,
-                has_agent_marker: row.has_agent_marker,
-                signature: row.signature,
-            });
+            self.rows.push(row);
         }
         if was_empty {
             self.estimated_lane_width = estimate_lane_width(&self.rows[..self.viewport_rows.min(self.rows.len())]);
@@ -405,6 +400,34 @@ impl App {
         }
     }
 
+    fn store_commits(&mut self, commits: LoadedCommits) -> Vec<CommitRow> {
+        let LoadedCommits { rows, attributions } = commits;
+        self.titles.reserve(rows.iter().map(|row| row.title.len()).sum());
+        let attribution_base = self.attributions.len();
+        self.attributions.extend(attributions);
+        rows.into_iter()
+            .map(|row| {
+                let start = self.titles.len();
+                self.titles.extend_from_slice(&row.title);
+                let row = Commit {
+                    id: row.id,
+                    parent_ids: row.parent_ids,
+                    committer_time: row.committer_time,
+                    author: row.author,
+                    attributions: attribution_base + row.attributions.start..attribution_base + row.attributions.end,
+                    title: start..self.titles.len(),
+                    metadata_loaded: row.metadata_loaded,
+                    has_agent_marker: row.has_agent_marker,
+                    signature: row.signature,
+                };
+                if self.all_rows.insert(row.id, row.clone()).is_none() {
+                    self.all_order.push(row.id);
+                }
+                row
+            })
+            .collect()
+    }
+
     pub(crate) fn extend_hidden_commits(&mut self, commits: impl Into<LoadedCommits>) {
         let commits = commits.into();
         self.hidden_rows.extend(commits.rows.iter().map(|row| row.id));
@@ -446,6 +469,7 @@ impl App {
         row.metadata_loaded = true;
         row.has_agent_marker = has_agent_marker;
         row.signature = signature;
+        self.all_rows.insert(row.id, row.clone());
     }
 
     pub(crate) fn title(&self, row: &CommitRow) -> &BStr {
@@ -569,6 +593,9 @@ impl App {
                     RefMode::None => RefMode::All,
                 };
             }
+            Action::Refresh if self.manual_refresh && matches!(self.state, State::Complete | State::Cancelled) => {
+                return vec![Effect::Reload(self.show_hidden)];
+            }
             Action::ToggleHidden
                 if self.has_hidden_filter && matches!(self.state, State::Complete | State::Cancelled) =>
             {
@@ -683,6 +710,61 @@ impl App {
         }
     }
 
+    pub(crate) fn known_ids(&self) -> HashSet<ObjectId> {
+        self.all_rows.keys().copied().collect()
+    }
+
+    pub(crate) fn hidden_ids(&self) -> HashSet<ObjectId> {
+        self.hidden_rows.clone()
+    }
+
+    pub(crate) fn start_refresh(
+        &mut self,
+        commits: LoadedCommits,
+        view_tips: &[ObjectId],
+        hidden_tips: &[ObjectId],
+    ) -> Option<Vec<CommitRow>> {
+        drop(self.store_commits(commits));
+
+        let visible = self.reachable_from(view_tips);
+        let hidden = self.reachable_from(hidden_tips);
+        let visible: HashSet<_> = visible.difference(&hidden).copied().collect();
+        let boundary: HashSet<_> = if hidden_tips.is_empty() {
+            HashSet::new()
+        } else {
+            visible
+                .iter()
+                .filter_map(|id| self.all_rows.get(id))
+                .flat_map(|row| row.parent_ids.iter().copied())
+                .filter(|id| !visible.contains(id))
+                .collect()
+        };
+        let rows: Vec<_> = self
+            .all_order
+            .iter()
+            .filter(|id| visible.contains(*id) || boundary.contains(*id))
+            .filter_map(|id| self.all_rows.get(id).cloned())
+            .collect();
+        self.pending_hidden_rows = Some(boundary);
+        self.state = State::Computing;
+        self.follow_tail = false;
+        Some(rows)
+    }
+
+    fn reachable_from(&self, tips: &[ObjectId]) -> HashSet<ObjectId> {
+        let mut reachable = HashSet::new();
+        let mut pending = tips.to_vec();
+        while let Some(id) = pending.pop() {
+            if !reachable.insert(id) {
+                continue;
+            }
+            if let Some(row) = self.all_rows.get(&id) {
+                pending.extend(row.parent_ids.iter().copied());
+            }
+        }
+        reachable
+    }
+
     pub(crate) fn finish_lane_computation(&mut self, rows: Vec<CommitRow>, graph: Graph, lane_time: Duration) {
         if self.state != State::Computing {
             return;
@@ -710,6 +792,9 @@ impl App {
             HashMap::new()
         };
         self.rows = rows;
+        if let Some(hidden) = self.pending_hidden_rows.take() {
+            self.hidden_rows = hidden;
+        }
         for row in &mut self.rows {
             if let Some(metadata) = metadata.get(&row.id) {
                 row.committer_time = metadata.committer_time;
@@ -723,7 +808,9 @@ impl App {
         }
         self.graph = Some(graph);
         self.lane_time = Some(lane_time);
-        self.selected = selected.and_then(|id| self.rows.iter().position(|row| row.id == id));
+        self.selected = selected
+            .and_then(|id| self.rows.iter().position(|row| row.id == id))
+            .or_else(|| self.first_selectable());
         self.state = State::Complete;
         if self.reachability_anchor.is_some() {
             self.compute_reachable_rows();
@@ -731,10 +818,14 @@ impl App {
         self.ensure_visible();
     }
 
+    #[cfg(test)]
     pub(crate) fn reload(&mut self, show_hidden: bool) {
         self.reload_selection = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
         self.rows = Vec::new();
+        self.all_rows.clear();
+        self.all_order.clear();
         self.hidden_rows.clear();
+        self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
         self.graph = None;
@@ -770,6 +861,7 @@ impl App {
                 failed += 1;
                 SignatureState::Failed
             };
+            self.all_rows.insert(row.id, row.clone());
         }
         self.signature_verification_running = false;
         self.signature_failures = failed;
@@ -1439,6 +1531,45 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_projects_from_an_append_only_commit_cache() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[])
+            .expect("a refresh computes lanes");
+        assert_eq!(
+            app.rows.len(),
+            3,
+            "the current frame stays intact while lanes are computed"
+        );
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(4), id(3), id(2), id(1)]
+        );
+
+        let rows = app
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(2)], &[])
+            .expect("a rewind reprojects cached topology");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(app.rows.iter().map(|row| row.id).collect::<Vec<_>>(), [id(2), id(1)]);
+
+        let rows = app
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(4)], &[])
+            .expect("a fast-forward to retained commits needs no new objects");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(4), id(3), id(2), id(1)]
+        );
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
@@ -1908,6 +2039,28 @@ mod tests {
         assert_eq!(app.update(Action::ToggleHidden), vec![Effect::Reload(false)]);
     }
 
+    #[test]
+    fn refresh_reloads_only_finished_history() {
+        let mut app = App::new(1);
+        app.manual_refresh = true;
+        assert!(
+            app.update(Action::Refresh).is_empty(),
+            "a running walk cannot be replaced"
+        );
+
+        app.extend_commits(vec![row(1)]);
+        complete(&mut app);
+        assert_eq!(app.update(Action::Refresh), vec![Effect::Reload(false)]);
+
+        app.show_hidden = true;
+        app.state = State::Cancelled;
+        assert_eq!(
+            app.update(Action::Refresh),
+            vec![Effect::Reload(true)],
+            "refresh preserves the hidden-history setting"
+        );
+    }
+
     #[test]
     fn reload_retains_selection_or_falls_back_to_the_top() {
         let mut app = App::new(3);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index b052d6c0546..e33550a5793 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -36,6 +36,21 @@ pub(crate) enum DecorationKind {
 }
 
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RefSnapshot {
+    pub view: HashMap<BString, gix::refs::Target>,
+    pub hidden: HashMap<BString, gix::refs::Target>,
+    pub view_tips: Vec<ObjectId>,
+    pub hidden_tips: Vec<ObjectId>,
+}
+
+#[derive(Debug)]
+pub(crate) struct Refresh {
+    pub refs: RefSnapshot,
+    pub decorations: Decorations,
+    pub commits: LoadedCommits,
+}
 #[derive(Default)]
 pub(crate) struct Authors {
     strings: HashSet<&'static [u8]>,
@@ -180,6 +195,126 @@ pub(crate) fn load(
     Ok(())
 }
 
+pub(crate) fn snapshot(repo: &gix::Repository, revisions: &[OsString], hidden: &[OsString]) -> Result<RefSnapshot> {
+    Ok(RefSnapshot {
+        view: referenced_refs(repo, revisions)?,
+        hidden: referenced_refs(repo, hidden)?,
+        view_tips: resolve_tips(repo, revisions)?.unwrap_or_default(),
+        hidden_tips: resolve_revisions(repo, hidden, "hidden ")?,
+    })
+}
+
+pub(crate) fn refresh(
+    repo: &gix::Repository,
+    revisions: &[OsString],
+    hidden_revisions: &[OsString],
+    known: &HashSet<ObjectId>,
+    expand: &HashSet<ObjectId>,
+    authors: &SharedAuthors,
+) -> Result<Refresh> {
+    let refs = snapshot(repo, revisions, hidden_revisions)?;
+    let mut tips = refs.view_tips.clone();
+    tips.extend(refs.hidden_tips.iter().copied());
+    tips.extend(expand.iter().copied());
+    let mut rows = Vec::new();
+    let mut attributions = Vec::new();
+    if !tips.is_empty() {
+        let walk = repo
+            .rev_walk(tips)
+            .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
+            .selected(|id| !known.contains(id) || expand.contains(id))
+            .context("could not start incremental revision walk")?;
+        for info in walk {
+            let info = info.context("could not refresh revision history")?;
+            if known.contains(&info.id) {
+                continue;
+            }
+            let metadata = if info.generation.is_some() {
+                None
+            } else {
+                let object = info.object().context("could not read commit")?;
+                let mut authors = gix::features::threading::lock(authors);
+                Some(decode_metadata(object.iter(), &mut authors, &mut attributions)?)
+            };
+            let metadata_loaded = metadata.is_some();
+            let Metadata {
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                has_agent_marker,
+                signature,
+            } = metadata.unwrap_or_else(|| Metadata {
+                committer_time: Default::default(),
+                author: &EMPTY_AUTHOR,
+                attributions: 0..0,
+                title: BString::default(),
+                has_agent_marker: false,
+                signature: SignatureState::Unsigned,
+            });
+            rows.push(Commit {
+                id: info.id,
+                parent_ids: info.parent_ids,
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                metadata_loaded,
+                has_agent_marker,
+                signature,
+            });
+        }
+    }
+    Ok(Refresh {
+        refs,
+        decorations: decorations(repo)?,
+        commits: LoadedCommits { rows, attributions },
+    })
+}
+
+fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {
+    let implicit_head = OsString::from("HEAD");
+    let revisions = if revisions.is_empty() {
+        std::slice::from_ref(&implicit_head)
+    } else {
+        revisions
+    };
+    let mut out = HashMap::new();
+    for revision in revisions {
+        let revision = gix::path::os_str_into_bstr(revision)
+            .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
+        let spec = repo
+            .rev_parse(revision)
+            .with_context(|| format!("could not parse revision {revision}"))?;
+        for reference in [spec.first_reference(), spec.second_reference()].into_iter().flatten() {
+            insert_ref_chain(repo, reference.name.as_bstr(), &mut out)?;
+        }
+    }
+    Ok(out)
+}
+
+fn insert_ref_chain(repo: &gix::Repository, name: &BStr, out: &mut HashMap<BString, gix::refs::Target>) -> Result<()> {
+    let mut name = name.to_owned();
+    loop {
+        if out.contains_key(&name) {
+            return Ok(());
+        }
+        let reference = match repo.try_find_reference(name.as_bstr()) {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&err) => return Ok(()),
+            Err(err) => return Err(err).with_context(|| format!("could not read reference {name}")),
+        };
+        let Some(reference) = reference else {
+            return Ok(());
+        };
+        let target = reference.target().into_owned();
+        let next = target.try_name().map(|name| name.as_bstr().to_owned());
+        out.insert(name, target);
+        let Some(next) = next else { return Ok(()) };
+        name = next;
+    }
+}
+
 pub(crate) fn load_metadata(
     repo: &gix::Repository,
     id: ObjectId,
@@ -354,7 +489,7 @@ impl Authors {
     }
 }
 
-fn decorations(repo: &gix::Repository) -> Result<Decorations> {
+pub(crate) fn decorations(repo: &gix::Repository) -> Result<Decorations> {
     let mut out = Decorations::new();
     for reference in repo
         .references()
@@ -362,7 +497,11 @@ fn decorations(repo: &gix::Repository) -> Result<Decorations> {
         .all()
         .context("could not iterate references")?
     {
-        let mut reference = reference.map_err(|err| anyhow::anyhow!("could not read reference: {err}"))?;
+        let mut reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
+        };
         let mut kind = decoration_kind(reference.name().as_bstr());
         if kind == DecorationKind::Tag {
             let annotated = match reference.try_id() {
@@ -397,6 +536,19 @@ fn decorations(repo: &gix::Repository) -> Result<Decorations> {
     Ok(out)
 }
 
+fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
+    loop {
+        if err
+            .downcast_ref::<std::io::Error>()
+            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
+        {
+            return true;
+        }
+        let Some(source) = err.source() else { return false };
+        err = source;
+    }
+}
+
 fn decoration_kind(name: &[u8]) -> DecorationKind {
     if name.starts_with(b"refs/heads/") {
         DecorationKind::Local
@@ -439,6 +591,22 @@ mod tests {
         Ok(events)
     }
 
+    #[test]
+    fn only_missing_ref_reads_are_ignored() {
+        let ref_error = |kind| gix::refs::file::iter::loose_then_packed::Error::ReadFileContents {
+            source: std::io::Error::from(kind),
+            path: "refs/heads/racing".into(),
+        };
+        assert!(
+            is_missing_ref(&ref_error(std::io::ErrorKind::NotFound)),
+            "a ref removed after iteration began is transient"
+        );
+        assert!(
+            !is_missing_ref(&ref_error(std::io::ErrorKind::PermissionDenied)),
+            "unrelated ref read errors remain actionable"
+        );
+    }
+
     #[test]
     fn walks_the_same_reachable_set_as_git_for_multiple_tips() -> gix_testtools::Result {
         let fixture = fixture()?;
@@ -515,6 +683,26 @@ mod tests {
         assert!(!contains_agent_marker(b"subject\n\nagent"));
     }
 
+    #[test]
+    fn snapshots_references_and_symbolic_targets_from_revisions() -> gix_testtools::Result {
+        let fixture = fixture()?;
+        let repo = gix::open(fixture)?;
+        let implicit = snapshot(&repo, &[], &[])?;
+        assert!(
+            implicit.view.contains_key(b"HEAD".as_bstr()),
+            "an implicit revision watches HEAD"
+        );
+        assert!(
+            implicit.view.contains_key(b"refs/heads/main".as_bstr()),
+            "the symbolic target of HEAD is watched as well"
+        );
+
+        let explicit = snapshot(&repo, &[OsString::from("main")], &[OsString::from("topic")])?;
+        assert!(explicit.view.contains_key(b"refs/heads/main".as_bstr()));
+        assert!(explicit.hidden.contains_key(b"refs/heads/topic".as_bstr()));
+        Ok(())
+    }
+
     #[test]
     fn decodes_commits_missing_from_a_stale_graph_and_defers_graph_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 94525eae814..715da9bdf81 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -38,6 +38,7 @@ use gix::{
     prelude::TreeDiffChangeExt,
 };
 use history::{Authors, Decorations, Event, SharedAuthors};
+use notify::{RecommendedWatcher, RecursiveMode, Watcher};
 use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
 
 const EVENT_BATCH_SIZE: usize = 256;
@@ -45,6 +46,7 @@ const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
+const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 
 struct FillRepository<'a> {
     path: &'a Path,
@@ -464,6 +466,7 @@ fn event_loop(
         screen,
     } = options;
     let repository_path = repository.git_dir().to_owned();
+    let common_dir = repository.common_dir.clone().unwrap_or_else(|| repository_path.clone());
     let mut view_repository = gix::open(&repository_path).context("could not open repository for history view")?;
     view_repository.object_cache_size(None);
     let mailmap = view_repository.open_mailmap();
@@ -472,7 +475,9 @@ fn event_loop(
         .map_err(gix::Exn::into_error)
         .context("could not open Git notes")?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-    let (mut cancelled, mut receiver) = start_history(
+    let mut ref_snapshot = history::snapshot(&view_repository, &revisions, &hide)?;
+    let (mut ref_watcher, ref_events) = start_ref_watcher(&repository_path, &common_dir);
+    let (cancelled, receiver) = start_history(
         repository,
         &revisions,
         &hide,
@@ -480,7 +485,11 @@ fn event_loop(
     );
 
     let mut app = App::new(1);
+    app.manual_refresh = ref_watcher.is_none();
     let mut lane_receiver = None;
+    let mut refresh_receiver: Option<mpsc::Receiver<Result<history::Refresh>>> = None;
+    let mut refresh_pending = false;
+    let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
     let mut changes = None;
@@ -517,9 +526,21 @@ fn event_loop(
     let mut urgent = false;
     let mut inline_terminal = None;
     let mut history_requires_alternate_screen = false;
+    let mut resize_inline_pending = false;
+    let mut history_finished = false;
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
     let result: Result<Option<Duration>> = (|| loop {
+        while let Ok(event) = ref_events.try_recv() {
+            match event {
+                Ok(event) if !matches!(event.kind, notify::EventKind::Access(_)) => refresh_pending = true,
+                Ok(_) => {}
+                Err(_) => {
+                    ref_watcher = None;
+                    app.manual_refresh = true;
+                }
+            }
+        }
         if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
             repeat_deadline = None;
             if app.changes_suppressed {
@@ -549,6 +570,9 @@ fn event_loop(
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
                     lane_receiver = None;
+                    history_requires_alternate_screen =
+                        history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
+                    resize_inline_pending = true;
                     dirty = true;
                     if quit_on_finish {
                         return Ok(app.lane_time);
@@ -560,6 +584,63 @@ fn event_loop(
                 }
             }
         }
+        if let Some(result) = refresh_receiver.as_ref().map(mpsc::Receiver::try_recv) {
+            match result {
+                Ok(result) => {
+                    let result = result?;
+                    decorations = result.decorations;
+                    let hidden_tips = if app.show_hidden {
+                        &[][..]
+                    } else {
+                        result.refs.hidden_tips.as_slice()
+                    };
+                    if let Some(rows) = app.start_refresh(result.commits, &result.refs.view_tips, hidden_tips) {
+                        lane_receiver = Some(start_lane_worker(rows));
+                    }
+                    refresh_receiver = None;
+                    dirty = true;
+                }
+                Err(mpsc::TryRecvError::Empty) => {}
+                Err(mpsc::TryRecvError::Disconnected) => anyhow::bail!("history refresh worker stopped unexpectedly"),
+            }
+        }
+        if refresh_pending
+            && refresh_receiver.is_none()
+            && lane_receiver.is_none()
+            && matches!(app.state, State::Complete | State::Cancelled)
+        {
+            let repository = gix::open_opts(&repository_path, gix::open::Options::isolated())
+                .context("could not inspect changed references")?;
+            let next = history::snapshot(&repository, &revisions, &hide)?;
+            let hidden_changed = next.hidden != ref_snapshot.hidden;
+            let tips_changed = next.view != ref_snapshot.view || hidden_changed;
+            ref_snapshot = next;
+            refresh_pending = false;
+            if tips_changed || refresh_expand_hidden {
+                let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
+                let expand = if refresh_expand_hidden || hidden_changed {
+                    app.hidden_ids()
+                } else {
+                    Default::default()
+                };
+                refresh_receiver = Some(start_history_refresh(
+                    repository_path.clone(),
+                    revisions.clone(),
+                    hidden,
+                    app.known_ids(),
+                    expand,
+                    gix::features::threading::OwnShared::clone(&authors),
+                ));
+                refresh_expand_hidden = false;
+                app.state = State::Loading;
+            } else {
+                let next = history::decorations(&repository)?;
+                if visible_decorations_changed(&decorations, &next, &app.rows) {
+                    decorations = next;
+                    dirty = true;
+                }
+            }
+        }
         if urgent {
             draw(
                 terminal,
@@ -583,16 +664,11 @@ fn event_loop(
             continue;
         }
         let mut events = 0;
-        let mut resize_inline = false;
-        while events < EVENT_BATCH_SIZE {
+        let mut resize_inline = std::mem::take(&mut resize_inline_pending);
+        while !history_finished && events < EVENT_BATCH_SIZE {
             let message = match receiver.try_recv() {
                 Ok(message) => message,
                 Err(mpsc::TryRecvError::Empty) => break,
-                Err(mpsc::TryRecvError::Disconnected)
-                    if matches!(app.state, State::Computing | State::Complete | State::Cancelled) =>
-                {
-                    break;
-                }
                 Err(mpsc::TryRecvError::Disconnected) => {
                     anyhow::bail!("history worker stopped unexpectedly")
                 }
@@ -614,6 +690,7 @@ fn event_loop(
                     }
                 }
                 Event::Complete => {
+                    history_finished = true;
                     resize_inline = true;
                     history_requires_alternate_screen =
                         history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
@@ -621,7 +698,10 @@ fn event_loop(
                         lane_receiver = Some(start_lane_worker(rows));
                     }
                 }
-                Event::Cancelled => drop(app.update(Action::Cancelled)),
+                Event::Cancelled => {
+                    history_finished = true;
+                    drop(app.update(Action::Cancelled));
+                }
             }
         }
         sync_screen(
@@ -653,7 +733,13 @@ fn event_loop(
             dirty = false;
         }
         let repeat_timeout = repeat_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
-        let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed(), repeat_timeout) {
+        let watcher_timeout = ref_watcher.as_ref().map(|_| REF_EVENT_INTERVAL);
+        let wake_after = match (repeat_timeout, watcher_timeout) {
+            (Some(repeat), Some(watcher)) => Some(repeat.min(watcher)),
+            (Some(timeout), None) | (None, Some(timeout)) => Some(timeout),
+            (None, None) => None,
+        };
+        let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
             Some(timeout) if event::poll(timeout)? => Some(event::read()?),
             Some(_) => None,
             None => Some(event::read()?),
@@ -733,18 +819,10 @@ fn event_loop(
                     execute!(terminal.backend_mut(), CopyToClipboard::to_clipboard_from(actor))?;
                 }
                 Effect::Reload(show_hidden) => {
-                    cancelled.store(true, Ordering::Relaxed);
-                    app.reload(show_hidden);
+                    app.show_hidden = show_hidden;
                     notes = open_notes(&repository_path)?;
-                    decorations.clear();
-                    let hidden = if show_hidden { &[][..] } else { hide.as_slice() };
-                    (cancelled, receiver) = start_history(
-                        gix::ThreadSafeRepository::open_opts(&repository_path, gix::open::Options::isolated())
-                            .context("could not reopen repository for history reload")?,
-                        &revisions,
-                        hidden,
-                        gix::features::threading::OwnShared::clone(&authors),
-                    );
+                    refresh_pending = true;
+                    refresh_expand_hidden = true;
                 }
                 Effect::OpenDiff(index) => {
                     let result = changes
@@ -891,6 +969,60 @@ fn start_history(
     (cancelled, receiver)
 }
 
+fn start_history_refresh(
+    repository_path: PathBuf,
+    revisions: Vec<OsString>,
+    hidden_revisions: Vec<OsString>,
+    known: std::collections::HashSet<gix::ObjectId>,
+    expand: std::collections::HashSet<gix::ObjectId>,
+    authors: SharedAuthors,
+) -> mpsc::Receiver<Result<history::Refresh>> {
+    let (sender, receiver) = mpsc::channel();
+    std::thread::spawn(move || {
+        let result = gix::open_opts(repository_path, gix::open::Options::isolated())
+            .context("could not reopen repository for history refresh")
+            .and_then(|mut repository| {
+                repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
+                history::refresh(&repository, &revisions, &hidden_revisions, &known, &expand, &authors)
+            });
+        let _ = sender.send(result);
+    });
+    receiver
+}
+
+fn start_ref_watcher(
+    git_dir: &Path,
+    common_dir: &Path,
+) -> (
+    Option<RecommendedWatcher>,
+    mpsc::Receiver<notify::Result<notify::Event>>,
+) {
+    let (sender, receiver) = mpsc::channel();
+    let Ok(mut watcher) = notify::recommended_watcher(move |event| {
+        let _ = sender.send(event);
+    }) else {
+        return (None, receiver);
+    };
+    let mut roots = vec![(common_dir.to_owned(), RecursiveMode::NonRecursive)];
+    if git_dir != common_dir {
+        roots.push((git_dir.to_owned(), RecursiveMode::NonRecursive));
+    }
+    for root in [common_dir.join("refs"), git_dir.join("refs")] {
+        if root.is_dir() && !roots.iter().any(|(path, _)| path == &root) {
+            roots.push((root, RecursiveMode::Recursive));
+        }
+    }
+    if roots.into_iter().all(|(path, mode)| watcher.watch(&path, mode).is_ok()) {
+        (Some(watcher), receiver)
+    } else {
+        (None, receiver)
+    }
+}
+
+fn visible_decorations_changed(old: &Decorations, new: &Decorations, rows: &[CommitRow]) -> bool {
+    rows.iter().any(|row| old.get(&row.id) != new.get(&row.id))
+}
+
 #[expect(clippy::too_many_arguments, reason = "drawing needs the complete view state")]
 fn draw(
     terminal: &mut ratatui::DefaultTerminal,
@@ -1520,6 +1652,8 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Char('n') => Some(Action::ToggleName),
         KeyCode::Char('t') => Some(Action::ToggleTrailers),
         KeyCode::Char('m') => Some(Action::ToggleMailmap),
+        KeyCode::Char('R') => Some(Action::Refresh),
+        KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHidden),
@@ -1933,6 +2067,16 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
             Some(Action::ToggleRefs)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
+            Some(Action::Refresh),
+            "terminals which preserve lowercase shifted letters map Shift-R to refresh"
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('R'), KeyModifiers::NONE)),
+            Some(Action::Refresh),
+            "terminals which encode Shift-R as an uppercase letter map it to refresh"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE)),
             Some(Action::ToggleHidden)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index f03e9452cc8..0267c0b4752 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -432,12 +432,20 @@ pub(crate) fn draw(
     for (label, enabled) in [("m mailmap", app.use_mailmap), ("t trailers", app.show_trailers)] {
         footer_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
     }
-    let ref_label = match app.ref_mode {
-        RefMode::All => "r all refs",
-        RefMode::Default => "r refs",
-        RefMode::None => "r no refs",
-    };
-    footer_spans.extend([Span::raw(" · "), toggle(ref_label, app.ref_mode != RefMode::None)]);
+    footer_spans.push(Span::raw(" · "));
+    if app.preview_author_copy && app.manual_refresh {
+        footer_spans.push(toggle(
+            "R refresh",
+            matches!(app.state, State::Complete | State::Cancelled),
+        ));
+    } else {
+        let ref_label = match app.ref_mode {
+            RefMode::All => "r all refs",
+            RefMode::Default => "r refs",
+            RefMode::None => "r no refs",
+        };
+        footer_spans.push(toggle(ref_label, app.ref_mode != RefMode::None));
+    }
     footer_spans.push(Span::raw(if app.preview_author_copy {
         " · Y copy author"
     } else {
@@ -1450,6 +1458,7 @@ mod tests {
             "the footer reflects the unfiltered view"
         );
 
+        app.manual_refresh = true;
         app.update(Action::PreviewAuthorCopy(true));
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         let row = rendered_row(&terminal);
@@ -1470,6 +1479,14 @@ mod tests {
             rendered_line(&terminal, 1).contains("Y copy author"),
             "the footer previews the shifted shortcut"
         );
+        assert!(
+            rendered_line(&terminal, 1).contains("R refresh"),
+            "the footer previews the shifted refresh shortcut"
+        );
+        assert!(
+            !rendered_line(&terminal, 1).contains("r refs"),
+            "the shifted refresh shortcut replaces the reference toggle"
+        );
         Ok(())
     }
 

From 7d802a6f1b2dbc3fd1b9d44cb81ebc7ecbcdae05 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 4 Aug 2026 14:59:47 +0200
Subject: [PATCH 012/282] feat: show contextual information beside the tix
 selection

Reserve space before the history selection tail for compact information about
the selected commit. Reuse bright tree-change line counts, and for commits
pointed to by refs show one deterministic upstream ahead/behind relation or a
visible-ancestry count when hidden history exists.

Resolve fetch tracking branches through gix, use commit-graph-aware counts,
cache results by commit and upstream targets, invalidate them with reference
or projected-history changes, and reuse the navigation repository and object
cache during repeated movement.

Keep blank margins around contextual information and the right-hand selection
marker even when clipped. Clear the marker cell before applying inversion so
row text is never inverted accidentally.
---
 gix-tix/src/app.rs |  50 +++++++++++
 gix-tix/src/lib.rs | 211 +++++++++++++++++++++++++++++++++++++++++++--
 gix-tix/src/ui.rs  | 185 ++++++++++++++++++++++++++++++++++++++-
 3 files changed, 436 insertions(+), 10 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 894780743d8..4769b3006f6 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -96,6 +96,12 @@ pub(crate) struct ComparedParent {
     pub id: ObjectId,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum SelectionRelation {
+    Tracking { ahead: usize, behind: usize },
+    Visible(usize),
+}
+
 #[derive(Debug, Eq, Hash, PartialEq)]
 pub(crate) struct Author {
     pub name: &'static BStr,
@@ -293,6 +299,7 @@ pub(crate) struct App {
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
     pub(crate) manual_refresh: bool,
+    pub(crate) selection_relation: Option<SelectionRelation>,
 }
 
 impl App {
@@ -356,6 +363,7 @@ impl App {
             signature_failures: 0,
             signature_verification_running: false,
             manual_refresh: false,
+            selection_relation: None,
         }
     }
 
@@ -718,6 +726,26 @@ impl App {
         self.hidden_rows.clone()
     }
 
+    pub(crate) fn visible_ancestry_to_hidden(&self, tip: ObjectId) -> Option<usize> {
+        let mut pending = vec![tip];
+        let mut seen = HashSet::new();
+        let mut visible = 0;
+        let mut reached_hidden = false;
+        while let Some(id) = pending.pop() {
+            if !seen.insert(id) {
+                continue;
+            }
+            if self.hidden_rows.contains(&id) {
+                reached_hidden = true;
+                continue;
+            }
+            let Some(row) = self.all_rows.get(&id) else { continue };
+            visible += 1;
+            pending.extend(row.parent_ids.iter().copied());
+        }
+        reached_hidden.then_some(visible)
+    }
+
     pub(crate) fn start_refresh(
         &mut self,
         commits: LoadedCommits,
@@ -1570,6 +1598,28 @@ mod tests {
         );
     }
 
+    #[test]
+    fn counts_distinct_visible_ancestry_only_when_it_reaches_hidden_history() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(4, &[3, 2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+        ]);
+        app.extend_hidden_commits(vec![row(1)]);
+
+        assert_eq!(app.visible_ancestry_to_hidden(id(4)), Some(3));
+        assert_eq!(app.visible_ancestry_to_hidden(id(3)), Some(1));
+        assert_eq!(app.visible_ancestry_to_hidden(id(1)), Some(0));
+
+        app.hidden_rows.clear();
+        assert_eq!(
+            app.visible_ancestry_to_hidden(id(4)),
+            None,
+            "without hidden history the fallback count has no useful base"
+        );
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 715da9bdf81..b45f1d92edc 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -20,7 +20,7 @@ use std::{
 };
 
 use anyhow::{Context, Result};
-use app::{Action, App, ChangeKind, Changes, CommitRow, ComparedParent, Effect, PathChange, State};
+use app::{Action, App, ChangeKind, Changes, CommitRow, ComparedParent, Effect, PathChange, SelectionRelation, State};
 use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
@@ -37,7 +37,7 @@ use gix::{
     bstr::{BString, ByteSlice},
     prelude::TreeDiffChangeExt,
 };
-use history::{Authors, Decorations, Event, SharedAuthors};
+use history::{Authors, DecorationKind, Decorations, Event, SharedAuthors};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
 use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
 
@@ -54,6 +54,19 @@ struct FillRepository<'a> {
     retain: bool,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct SelectionRef {
+    name: BString,
+    upstream: Option<Option<gix::ObjectId>>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct SelectionRelationCache {
+    id: gix::ObjectId,
+    refs: Vec<SelectionRef>,
+    relation: Option<SelectionRelation>,
+}
+
 type LineCounts = Option<(u32, u32)>;
 type LineDiffResult = (usize, gix::object::tree::diff::ChangeDetached, Result<LineCounts>);
 
@@ -493,6 +506,7 @@ fn event_loop(
     let mut verification_receiver = None;
     let mut commit_message = None;
     let mut changes = None;
+    let mut selection_relation = None;
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
     let mut line_diff_pool = None;
     let mut fill_repository = FillRepository {
@@ -519,6 +533,7 @@ fn event_loop(
         &mut notes,
         &mut commit_message,
         &mut changes,
+        &mut selection_relation,
         &mut line_diff_pool,
     )?;
     let mut last_draw = Instant::now();
@@ -569,6 +584,8 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    selection_relation = None;
+                    app.selection_relation = None;
                     lane_receiver = None;
                     history_requires_alternate_screen =
                         history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
@@ -589,6 +606,8 @@ fn event_loop(
                 Ok(result) => {
                     let result = result?;
                     decorations = result.decorations;
+                    selection_relation = None;
+                    app.selection_relation = None;
                     let hidden_tips = if app.show_hidden {
                         &[][..]
                     } else {
@@ -635,7 +654,14 @@ fn event_loop(
                 app.state = State::Loading;
             } else {
                 let next = history::decorations(&repository)?;
-                if visible_decorations_changed(&decorations, &next, &app.rows) {
+                let relation_changed = selection_relation
+                    .as_ref()
+                    .is_some_and(|cached: &SelectionRelationCache| {
+                        selection_refs(&repository, cached.id, &next) != cached.refs
+                    });
+                if visible_decorations_changed(&decorations, &next, &app.rows) || relation_changed {
+                    selection_relation = None;
+                    app.selection_relation = None;
                     decorations = next;
                     dirty = true;
                 }
@@ -652,6 +678,7 @@ fn event_loop(
                 &mut notes,
                 &mut commit_message,
                 &mut changes,
+                &mut selection_relation,
                 &mut line_diff_pool,
             )?;
             last_draw = Instant::now();
@@ -727,6 +754,7 @@ fn event_loop(
                 &mut notes,
                 &mut commit_message,
                 &mut changes,
+                &mut selection_relation,
                 &mut line_diff_pool,
             )?;
             last_draw = Instant::now();
@@ -880,6 +908,7 @@ fn event_loop(
             &mut notes,
             &mut commit_message,
             &mut changes,
+            &mut selection_relation,
             &mut line_diff_pool,
         )?;
     }
@@ -1023,6 +1052,73 @@ fn visible_decorations_changed(old: &Decorations, new: &Decorations, rows: &[Com
     rows.iter().any(|row| old.get(&row.id) != new.get(&row.id))
 }
 
+fn selection_refs(repo: &gix::Repository, id: gix::ObjectId, decorations: &Decorations) -> Vec<SelectionRef> {
+    let mut refs: Vec<_> = decorations
+        .get(&id)
+        .into_iter()
+        .flatten()
+        .map(|decoration| {
+            let upstream = if decoration.kind == DecorationKind::Local {
+                let mut name = BString::from("refs/heads/");
+                name.extend_from_slice(&decoration.name);
+                repo.try_find_reference(name.as_bstr())
+                    .ok()
+                    .flatten()
+                    .and_then(|reference| reference.remote_tracking_ref_name(gix::remote::Direction::Fetch))
+                    .map(|name| {
+                        name.ok().and_then(|name| {
+                            repo.try_find_reference(name.as_bstr())
+                                .ok()
+                                .flatten()
+                                .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach))
+                        })
+                    })
+            } else {
+                None
+            };
+            SelectionRef {
+                name: decoration.name.clone(),
+                upstream,
+            }
+        })
+        .collect();
+    refs.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.upstream.cmp(&b.upstream)));
+    refs
+}
+
+fn selection_relation(
+    repo: &gix::Repository,
+    id: gix::ObjectId,
+    refs: &[SelectionRef],
+    visible: Option<usize>,
+) -> Option<SelectionRelation> {
+    let has_upstream = refs.iter().any(|reference| reference.upstream.is_some());
+    for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
+        let Ok(ahead) = count_exclusive_commits(repo, id, upstream) else {
+            continue;
+        };
+        let Ok(behind) = count_exclusive_commits(repo, upstream, id) else {
+            continue;
+        };
+        return Some(SelectionRelation::Tracking { ahead, behind });
+    }
+    (!has_upstream && !refs.is_empty())
+        .then_some(visible)
+        .flatten()
+        .map(SelectionRelation::Visible)
+}
+
+fn count_exclusive_commits(repo: &gix::Repository, tip: gix::ObjectId, hidden: gix::ObjectId) -> Result<usize> {
+    let mut walk = repo
+        .rev_walk([tip])
+        .with_hidden([hidden])
+        .all()
+        .context("could not compare branch with its upstream")?;
+    walk.try_fold(0usize, |count, info| {
+        info.context("could not traverse branch comparison").map(|_| count + 1)
+    })
+}
+
 #[expect(clippy::too_many_arguments, reason = "drawing needs the complete view state")]
 fn draw(
     terminal: &mut ratatui::DefaultTerminal,
@@ -1034,6 +1130,7 @@ fn draw(
     notes: &mut gix::note::Platform,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     changes: &mut Option<(gix::ObjectId, usize, Changes)>,
+    selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
 ) -> Result<()> {
     app.viewport_rows = terminal
@@ -1065,9 +1162,16 @@ fn draw(
         app.set_notes(id, loaded);
     }
     let changes_visible = app.changes_visible();
-    let selected = (app.show_commit || changes_visible)
-        .then(|| app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id))
-        .flatten();
+    let selected_id = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
+    app.selection_relation = selection_cache
+        .as_ref()
+        .filter(|cached| Some(cached.id) == selected_id)
+        .and_then(|cached| cached.relation);
+    let relation_to_load = matches!(app.state, State::Complete | State::Cancelled)
+        .then_some(selected_id)
+        .flatten()
+        .filter(|id| selection_cache.as_ref().is_none_or(|cached| cached.id != *id));
+    let selected = (app.show_commit || changes_visible).then_some(selected_id).flatten();
     let message_to_load = app
         .show_commit
         .then_some(selected)
@@ -1096,6 +1200,7 @@ fn draw(
     if app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
         || changes_to_load.is_some()
+        || relation_to_load.is_some()
     {
         let mut one_shot_repository = None;
         let repository = if fill_repository.retain {
@@ -1117,6 +1222,14 @@ fn draw(
         if let Some(id) = message_to_load {
             *commit_message = Some((id, load_commit_message(repository, id)?));
         }
+        if let Some(id) = relation_to_load {
+            repository.object_cache_size(OBJECT_CACHE_SIZE);
+            let refs = selection_refs(repository, id, decorations);
+            let relation = selection_relation(repository, id, &refs, app.visible_ancestry_to_hidden(id));
+            repository.object_cache_size(None);
+            *selection_cache = Some(SelectionRelationCache { id, refs, relation });
+            app.selection_relation = relation;
+        }
         if let Some(id) = changes_to_load {
             repository.object_cache_size(OBJECT_CACHE_SIZE);
             let loaded = load_changes(
@@ -1700,7 +1813,7 @@ mod tests {
     #[test]
     fn loads_commit_messages_from_an_existing_repository() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let repository = gix::open(&fixture)?;
+        let repository = open_test_repository(&fixture)?;
         let id = repository.rev_parse_single("topic")?.detach();
 
         assert!(
@@ -1710,6 +1823,90 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn selection_relation_prefers_tracking_counts_and_handles_missing_upstreams() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let mut repository = gix::open(&fixture)?;
+        repository.object_cache_size(OBJECT_CACHE_SIZE);
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let tracking = SelectionRef {
+            name: "topic".into(),
+            upstream: Some(Some(main)),
+        };
+        assert_eq!(
+            selection_relation(&repository, topic, &[tracking.clone(), tracking], Some(99)),
+            Some(SelectionRelation::Tracking { ahead: 1, behind: 2 }),
+            "one upstream comparison wins over the visible-history fallback"
+        );
+        assert_eq!(
+            selection_relation(
+                &repository,
+                topic,
+                &[SelectionRef {
+                    name: "topic".into(),
+                    upstream: Some(None),
+                }],
+                Some(1),
+            ),
+            None,
+            "a configured but missing tracking ref does not masquerade as an untracked branch"
+        );
+        assert_eq!(
+            selection_relation(
+                &repository,
+                topic,
+                &[SelectionRef {
+                    name: "tag: topic".into(),
+                    upstream: None,
+                }],
+                Some(1),
+            ),
+            Some(SelectionRelation::Visible(1))
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn selection_refs_resolve_the_configured_fetch_tracking_branch() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        for args in [
+            ["config", "remote.origin.url", "https://example.com/repo"],
+            ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+            ["config", "branch.topic.remote", "origin"],
+            ["config", "branch.topic.merge", "refs/heads/main"],
+        ] {
+            let status = std::process::Command::new("git")
+                .current_dir(path)
+                .args(args)
+                .status()?;
+            assert!(status.success(), "git config prepares the tracking relationship");
+        }
+        let repository = open_test_repository(path)?;
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let status = std::process::Command::new("git")
+            .current_dir(path)
+            .args(["update-ref", "refs/remotes/origin/main", &main.to_hex().to_string()])
+            .status()?;
+        assert!(status.success(), "the configured tracking ref exists");
+        let repository = gix::open(path)?;
+        let refs = selection_refs(
+            &repository,
+            topic,
+            &Decorations::from([(
+                topic,
+                vec![history::Decoration {
+                    name: "topic".into(),
+                    kind: DecorationKind::Local,
+                }],
+            )]),
+        );
+        assert_eq!(refs[0].upstream, Some(Some(main)));
+        Ok(())
+    }
+
     #[test]
     fn loads_changes_against_each_merge_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 0267c0b4752..9273affa298 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -9,7 +9,10 @@ use ratatui::{
 
 use crate::{
     BuiltInDiff,
-    app::{App, AttributionKind, ChangeKind, Changes, CommitRow, CopyKind, NameMode, RefMode, SignatureState, State},
+    app::{
+        App, AttributionKind, ChangeKind, Changes, CommitRow, CopyKind, NameMode, RefMode, SelectionRelation,
+        SignatureState, State,
+    },
     history::{DecorationKind, Decorations},
 };
 
@@ -195,6 +198,15 @@ pub(crate) fn draw(
     .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
     let graph_offset = horizontal_offset.min(graph_max_offset);
+    let selection_info = selection_info_line(
+        app.changes_visible()
+            .then_some(changes)
+            .flatten()
+            .filter(|changes| changes.is_visible()),
+        app.selection_relation,
+    );
+    let selection_info_width = selection_info.width();
+    let mut selection_info_area = None;
 
     for (index, metadata) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
@@ -295,8 +307,25 @@ pub(crate) fn draw(
                 .x
                 .saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
                 .saturating_add(1)
+                .saturating_add(u16::try_from(selection_info_width).unwrap_or(u16::MAX))
+                .saturating_add(1)
                 .min(body.right().saturating_sub(1));
-            frame.buffer_mut()[(marker_x, y)].set_style(style);
+            if selection_info_width > 0 {
+                let width = u16::try_from(selection_info_width)
+                    .unwrap_or(u16::MAX)
+                    .min(marker_x.saturating_sub(content.x).saturating_sub(2));
+                let area = Rect::new(marker_x.saturating_sub(width).saturating_sub(1), y, width, 1);
+                if width > 0 {
+                    frame.buffer_mut()[(area.x - 1, y)].set_symbol(" ");
+                    frame.render_widget(Paragraph::new(selection_info.clone()), area);
+                    selection_info_area = Some(area);
+                }
+            }
+            let buffer = frame.buffer_mut();
+            if marker_x > body.x {
+                buffer[(marker_x - 1, y)].set_symbol(" ");
+            }
+            buffer[(marker_x, y)].set_symbol(" ").set_style(style);
         }
         if !app.is_row_reachable(start + index) {
             for x in body.x..body.right() {
@@ -475,7 +504,60 @@ pub(crate) fn draw(
         frame
             .buffer_mut()
             .set_style(body, Style::default().add_modifier(Modifier::DIM));
+        if let Some(area) = selection_info_area {
+            frame.render_widget(Paragraph::new(selection_info), area);
+        }
+    }
+}
+
+fn selection_info_line(changes: Option<&Changes>, relation: Option<SelectionRelation>) -> Line<'static> {
+    let mut spans = Vec::new();
+    if let Some(changes) = changes {
+        spans.extend([
+            Span::styled(format!("+{}", changes.lines_added), selection_color(Color::Green)),
+            Span::raw(" "),
+            Span::styled(format!("-{}", changes.lines_removed), selection_color(Color::Red)),
+        ]);
+    }
+    match relation {
+        Some(SelectionRelation::Tracking { ahead, behind }) => {
+            if ahead > 0 {
+                push_selection_span(
+                    &mut spans,
+                    Span::styled(format!("⇡{ahead}"), selection_color(Color::Green)),
+                );
+            }
+            if behind > 0 {
+                if ahead == 0 {
+                    push_selection_span(
+                        &mut spans,
+                        Span::styled(format!("⇣{behind}"), selection_color(Color::Red)),
+                    );
+                } else {
+                    spans.push(Span::styled(format!("⇣{behind}"), selection_color(Color::Red)));
+                }
+            }
+        }
+        Some(SelectionRelation::Visible(commits)) => {
+            push_selection_span(
+                &mut spans,
+                Span::styled(format!("⇡{commits}"), selection_color(Color::Green)),
+            );
+        }
+        None => {}
+    }
+    Line::from(spans)
+}
+
+fn selection_color(color: Color) -> Style {
+    Style::default().fg(color).remove_modifier(Modifier::DIM)
+}
+
+fn push_selection_span(spans: &mut Vec<Span<'static>>, span: Span<'static>) {
+    if !spans.is_empty() {
+        spans.push(Span::raw(" "));
     }
+    spans.push(span);
 }
 
 fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, app: &mut App) {
@@ -1062,6 +1144,103 @@ mod tests {
         app.finish_lane_computation(rows, lanes, lane_time);
     }
 
+    #[test]
+    fn renders_selection_info_beside_the_right_marker_without_dimming_it() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(2);
+        app.extend_commits(vec![Commit {
+            id: gix::ObjectId::Sha1([1; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "a subject which is deliberately too long".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        complete(&mut app);
+        app.selection_relation = Some(SelectionRelation::Tracking { ahead: 1, behind: 2 });
+        let changes = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                source: None,
+                path: "file".into(),
+                lines: Some((3, 4)),
+            }],
+            lines_added: 3,
+            lines_removed: 4,
+            ..Changes::default()
+        };
+        app.changes_focused = true;
+        let mut terminal = Terminal::new(TestBackend::new(38, 7))?;
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        let row = rendered_row(&terminal);
+        let info = "+3 -4 ⇡1⇣2";
+        let info_byte = row.find(info).expect("selection info wins over the long subject");
+        let info_x = row[..info_byte].chars().count() as u16;
+        let buffer = terminal.backend().buffer();
+        assert_eq!(
+            buffer[(info_x - 1, 0)].symbol(),
+            " ",
+            "selection info has a left margin"
+        );
+        assert_eq!(buffer[(info_x, 0)].fg, Color::Green);
+        assert_eq!(buffer[(info_x + 3, 0)].fg, Color::Red);
+        assert!(!buffer[(info_x, 0)].modifier.contains(Modifier::DIM));
+        let spacer_x = info_x + info.chars().count() as u16;
+        assert_eq!(buffer[(spacer_x, 0)].symbol(), " ", "the marker has a left spacer");
+        assert!(
+            buffer[(spacer_x + 1, 0)].modifier.contains(Modifier::REVERSED),
+            "the right selection block follows the spacer"
+        );
+        assert_eq!(
+            buffer[(spacer_x + 1, 0)].symbol(),
+            " ",
+            "the right selection block never inverts text"
+        );
+
+        app.selection_relation = None;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let buffer = terminal.backend().buffer();
+        assert_eq!(buffer[(36, 0)].symbol(), " ", "a plain marker has a left spacer");
+        assert_eq!(buffer[(37, 0)].symbol(), " ", "a plain marker never inverts text");
+        assert!(buffer[(37, 0)].modifier.contains(Modifier::REVERSED));
+
+        app.show_selection_tail = false;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(!rendered_row(&terminal).contains(info));
+
+        let text = |relation| {
+            selection_info_line(None, relation)
+                .spans
+                .into_iter()
+                .map(|span| span.content.into_owned())
+                .collect::<String>()
+        };
+        assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 2 })), "⇣2");
+        assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 0 })), "");
+        Ok(())
+    }
+
     #[test]
     fn renders_a_colored_file_diff_pager() -> Result<(), Box<dyn std::error::Error>> {
         let diff = BuiltInDiff::new(
@@ -1339,7 +1518,7 @@ mod tests {
         for x in 30..44 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Green));
         }
-        expected[(selected_line.chars().count() as u16 + 1, 0)]
+        expected[(selected_line.chars().count() as u16 + 2, 0)]
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         let commit = footer_text[..footer_text.find("o commit").expect("the commit toggle is present")]
             .chars()

From 2315dec094a5f63220ebbef6bf66bf8bafb3a09d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 4 Aug 2026 15:24:28 +0200
Subject: [PATCH 013/282] feat: show tree and worktree changes together

Show Tree and Worktree changes together by default and cycle c from Both to
Tree to Hidden. Collect staged, unstaged, untracked, and conflicted paths with
the cancellable status iterator, preserve Git-like ordering and colors, and
reuse computed per-path line counts for summaries, selected rows, and the
existing external or built-in diff pipeline.

Watch the worktree and index only while needed, debounce updates for 75ms, and
retain independent caches, selection, scrolling, and errors for both sources.
Represent conflicts, submodules, unavailable diffs, and an enabled clean
worktree without launching inappropriate pagers.

Render both blocks over the full-height history, side by side when their
condensed summaries fit and stacked otherwise. Join unequal borders, cap their
height, keep history visible beside shorter blocks, and bound navigation above
the top-most block so advancing scrolls history while the selected row stays
fixed. Cycle focus in visual order and keep merge-parent controls on Tree.
---
 gix-tix/Cargo.toml |   2 +-
 gix-tix/src/app.rs | 423 +++++++++++++++------
 gix-tix/src/lib.rs | 927 ++++++++++++++++++++++++++++++++++++++------
 gix-tix/src/ui.rs  | 930 +++++++++++++++++++++++++++++++++------------
 4 files changed, 1815 insertions(+), 467 deletions(-)

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index ca927441ebc..37ad53d3fcb 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -25,7 +25,7 @@ sha256 = ["gix/sha256"]
 [dependencies]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
-gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command"] }
+gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command", "status"] }
 notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 4769b3006f6..df55b9edd68 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -51,6 +51,7 @@ pub(crate) enum ChangeKind {
     Renamed,
     Copied,
     TypeChanged,
+    Unmerged,
 }
 
 impl ChangeKind {
@@ -62,13 +63,70 @@ impl ChangeKind {
             ChangeKind::Renamed => 'R',
             ChangeKind::Copied => 'C',
             ChangeKind::TypeChanged => 'T',
+            ChangeKind::Unmerged => 'U',
         }
     }
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum ChangesMode {
+    #[default]
+    Tree,
+    Both,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum ChangePane {
+    Tree,
+    Worktree,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum ChangesLayout {
+    #[default]
+    SideBySide,
+    Stacked,
+}
+
+#[derive(Debug)]
+pub(crate) struct ChangesView {
+    pub selected: usize,
+    pub offset: usize,
+    pub horizontal_offset: usize,
+    pub error: Option<String>,
+    page: usize,
+    max: usize,
+    horizontal_page: usize,
+    horizontal_max: usize,
+}
+
+impl Default for ChangesView {
+    fn default() -> Self {
+        Self {
+            selected: 0,
+            offset: 0,
+            horizontal_offset: 0,
+            error: None,
+            page: 1,
+            max: 0,
+            horizontal_page: 1,
+            horizontal_max: 0,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum ChangeGroup {
+    #[default]
+    Tree,
+    Staged,
+    Unstaged,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct PathChange {
     pub kind: ChangeKind,
+    pub group: ChangeGroup,
     pub source: Option<BString>,
     pub path: BString,
     pub lines: Option<(u32, u32)>,
@@ -78,7 +136,7 @@ pub(crate) struct PathChange {
 pub(crate) struct Changes {
     pub parent: Option<ComparedParent>,
     pub paths: Vec<PathChange>,
-    pub diffs: Vec<gix::object::tree::diff::ChangeDetached>,
+    pub diffs: Vec<crate::FileChange>,
     pub lines_added: u64,
     pub lines_removed: u64,
 }
@@ -234,7 +292,7 @@ pub(crate) enum Effect {
     CopyId(ObjectId),
     CopyAuthor(&'static Author),
     Reload(bool),
-    OpenDiff(usize),
+    OpenDiff(ChangePane, usize),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -267,21 +325,18 @@ pub(crate) struct App {
     pub show_hidden: bool,
     pub align_metadata: bool,
     pub show_commit: bool,
-    pub show_changes: bool,
+    pub changes_mode: Option<ChangesMode>,
     pub(crate) changes_suppressed: bool,
-    pub(crate) changes_focused: bool,
-    pub(crate) changes_selected: usize,
-    pub(crate) changes_offset: usize,
-    pub(crate) changes_horizontal_offset: usize,
+    pub(crate) changes_focus: Option<ChangePane>,
+    pub(crate) changes_layout: ChangesLayout,
+    pub(crate) tree_changes_visible: bool,
+    pub(crate) worktree_changes_visible: bool,
+    pub(crate) tree_changes: ChangesView,
+    pub(crate) worktree_changes: ChangesView,
     pub(crate) changes_parent: usize,
-    pub(crate) diff_error: Option<String>,
     pub(crate) commit_offset: usize,
     commit_page: usize,
     commit_max: usize,
-    changes_page: usize,
-    changes_max: usize,
-    changes_horizontal_page: usize,
-    changes_horizontal_max: usize,
     pub(crate) show_selection_tail: bool,
     pub inline: bool,
     pub preview_author_copy: bool,
@@ -331,21 +386,18 @@ impl App {
             show_hidden: false,
             align_metadata: true,
             show_commit: false,
-            show_changes: true,
+            changes_mode: Some(ChangesMode::Both),
             changes_suppressed: false,
-            changes_focused: false,
-            changes_selected: 0,
-            changes_offset: 0,
-            changes_horizontal_offset: 0,
+            changes_focus: None,
+            changes_layout: ChangesLayout::SideBySide,
+            tree_changes_visible: false,
+            worktree_changes_visible: false,
+            tree_changes: ChangesView::default(),
+            worktree_changes: ChangesView::default(),
             changes_parent: 0,
-            diff_error: None,
             commit_offset: 0,
             commit_page: 1,
             commit_max: 0,
-            changes_page: 1,
-            changes_max: 0,
-            changes_horizontal_page: 1,
-            changes_horizontal_max: 0,
             show_selection_tail: true,
             inline: false,
             preview_author_copy: false,
@@ -518,19 +570,19 @@ impl App {
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
-            Action::MoveUp if self.changes_focused => self.move_changes(1, false),
-            Action::MoveDown if self.changes_focused => self.move_changes(1, true),
+            Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
+            Action::MoveDown if self.changes_focus.is_some() => self.move_changes(1, true),
             Action::MoveUp => self.move_reachable(false),
             Action::MoveDown => self.move_reachable(true),
             Action::ScrollLeft => {
-                if self.changes_focused {
+                if self.changes_focus.is_some() {
                     self.pan_changes(false);
                 } else if !self.cycle_junction_parent(false) {
                     self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
                 }
             }
             Action::ScrollRight => {
-                if self.changes_focused {
+                if self.changes_focus.is_some() {
                     self.pan_changes(true);
                 } else if !self.cycle_junction_parent(true) {
                     self.horizontal_offset = self
@@ -539,10 +591,14 @@ impl App {
                         .min(self.horizontal_max);
                 }
             }
-            Action::HalfPageUp if self.changes_focused => self.move_changes((self.changes_page / 2).max(1), false),
-            Action::HalfPageDown if self.changes_focused => self.move_changes((self.changes_page / 2).max(1), true),
-            Action::PageUp if self.changes_focused => self.move_changes(self.changes_page, false),
-            Action::PageDown if self.changes_focused => self.move_changes(self.changes_page, true),
+            Action::HalfPageUp if self.changes_focus.is_some() => {
+                self.move_changes((self.focused_changes().page / 2).max(1), false);
+            }
+            Action::HalfPageDown if self.changes_focus.is_some() => {
+                self.move_changes((self.focused_changes().page / 2).max(1), true);
+            }
+            Action::PageUp if self.changes_focus.is_some() => self.move_changes(self.focused_changes().page, false),
+            Action::PageDown if self.changes_focus.is_some() => self.move_changes(self.focused_changes().page, true),
             Action::PageUp if self.show_commit && self.commit_max > 0 => {
                 self.commit_offset = self.commit_offset.saturating_sub(self.commit_page);
             }
@@ -553,9 +609,10 @@ impl App {
             Action::HalfPageDown => self.move_selection((self.viewport_rows / 2).max(1), true),
             Action::PageUp => self.move_selection(self.viewport_rows.max(1), false),
             Action::PageDown => self.move_selection(self.viewport_rows.max(1), true),
-            Action::First if self.changes_focused => {
-                self.changes_selected = 0;
-                self.diff_error = None;
+            Action::First if self.changes_focus.is_some() => {
+                let changes = self.focused_changes_mut();
+                changes.selected = 0;
+                changes.error = None;
                 self.ensure_changes_visible();
             }
             Action::First => {
@@ -563,9 +620,10 @@ impl App {
                     self.select(index);
                 }
             }
-            Action::Last if self.changes_focused => {
-                self.changes_selected = self.changes_max;
-                self.diff_error = None;
+            Action::Last if self.changes_focus.is_some() => {
+                let changes = self.focused_changes_mut();
+                changes.selected = changes.max;
+                changes.error = None;
                 self.ensure_changes_visible();
             }
             Action::Last if self.last_selectable().is_some() => {
@@ -616,29 +674,40 @@ impl App {
             }
             Action::ToggleChanges => {
                 self.focus_feedback = None;
-                self.show_changes = !self.show_changes;
-                if !self.show_changes {
+                self.changes_mode = match self.changes_mode {
+                    Some(ChangesMode::Both) => Some(ChangesMode::Tree),
+                    Some(ChangesMode::Tree) => None,
+                    None => Some(ChangesMode::Both),
+                };
+                self.reset_changes_view();
+                self.changes_parent = 0;
+                if self.changes_mode.is_none() {
                     self.changes_suppressed = false;
-                    self.changes_focused = false;
-                    self.reset_changes_view();
+                    self.changes_focus = None;
                 }
             }
-            Action::ToggleChangesFocus if self.show_changes => {
-                self.changes_focused = !self.changes_focused;
-                if self.changes_focused {
+            Action::ToggleChangesFocus if self.changes_mode.is_some() => {
+                self.cycle_changes_focus();
+                if self.changes_focus.is_some() {
                     self.clear_preview_author_copy();
                 }
-                self.focus_feedback = Some(if self.changes_focused { "changes" } else { "history" });
+                self.focus_feedback = Some(match self.changes_focus {
+                    Some(ChangePane::Tree) => "tree changes",
+                    Some(ChangePane::Worktree) => "worktree changes",
+                    None => "history",
+                });
             }
             Action::CycleChangesParent => {
-                if self.show_changes {
+                if self.changes_focus == Some(ChangePane::Tree) {
                     self.changes_parent = self.changes_parent.saturating_add(1);
-                    self.diff_error = None;
+                    self.tree_changes.error = None;
                 }
             }
-            Action::OpenDiff if self.changes_focused => {
-                self.diff_error = None;
-                return vec![Effect::OpenDiff(self.changes_selected)];
+            Action::OpenDiff if self.changes_focus.is_some() => {
+                let pane = self.changes_focus.expect("focus was checked");
+                let changes = self.focused_changes_mut();
+                changes.error = None;
+                return vec![Effect::OpenDiff(pane, changes.selected)];
             }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
@@ -657,8 +726,8 @@ impl App {
                 }
             }
             Action::ForceQuit => return vec![Effect::Quit],
-            Action::Cancel | Action::Quit if self.changes_focused => self.focus_history(),
-            Action::PreviewAuthorCopy(_) if self.changes_focused => {}
+            Action::Cancel | Action::Quit if self.changes_focus.is_some() => self.focus_history(),
+            Action::PreviewAuthorCopy(_) if self.changes_focus.is_some() => {}
             Action::PreviewAuthorCopy(value) => {
                 if value && !self.preview_author_copy {
                     self.reachability_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
@@ -896,11 +965,12 @@ impl App {
     }
 
     fn move_changes(&mut self, distance: usize, down: bool) {
-        self.diff_error = None;
-        self.changes_selected = if down {
-            self.changes_selected.saturating_add(distance).min(self.changes_max)
+        let changes = self.focused_changes_mut();
+        changes.error = None;
+        changes.selected = if down {
+            changes.selected.saturating_add(distance).min(changes.max)
         } else {
-            self.changes_selected.saturating_sub(distance)
+            changes.selected.saturating_sub(distance)
         };
         self.ensure_changes_visible();
     }
@@ -913,33 +983,35 @@ impl App {
     }
 
     pub(crate) fn focus_history(&mut self) {
-        self.changes_focused = false;
+        self.changes_focus = None;
         self.focus_feedback = None;
     }
 
     pub(crate) fn changes_visible(&self) -> bool {
-        self.show_changes && !self.changes_suppressed
+        self.changes_mode.is_some() && !self.changes_suppressed
     }
 
     fn ensure_changes_visible(&mut self) {
-        if self.changes_selected < self.changes_offset {
-            self.changes_offset = self.changes_selected;
-        } else if self.changes_selected >= self.changes_offset.saturating_add(self.changes_page) {
-            self.changes_offset = self.changes_selected + 1 - self.changes_page;
+        let changes = self.focused_changes_mut();
+        if changes.selected < changes.offset {
+            changes.offset = changes.selected;
+        } else if changes.selected >= changes.offset.saturating_add(changes.page) {
+            changes.offset = changes.selected + 1 - changes.page;
         }
-        self.changes_offset = self
-            .changes_offset
-            .min(self.changes_max.saturating_add(1).saturating_sub(self.changes_page));
+        changes.offset = changes
+            .offset
+            .min(changes.max.saturating_add(1).saturating_sub(changes.page));
     }
 
     fn pan_changes(&mut self, right: bool) {
-        self.changes_horizontal_offset = if right {
-            self.changes_horizontal_offset
-                .saturating_add(self.changes_horizontal_page)
-                .min(self.changes_horizontal_max)
+        let changes = self.focused_changes_mut();
+        changes.horizontal_offset = if right {
+            changes
+                .horizontal_offset
+                .saturating_add(changes.horizontal_page)
+                .min(changes.horizontal_max)
         } else {
-            self.changes_horizontal_offset
-                .saturating_sub(self.changes_horizontal_page)
+            changes.horizontal_offset.saturating_sub(changes.horizontal_page)
         };
     }
 
@@ -1130,30 +1202,87 @@ impl App {
 
     pub(crate) fn set_changes_bounds(
         &mut self,
+        pane: ChangePane,
         page: usize,
         len: usize,
         horizontal_page: usize,
         horizontal_max: usize,
     ) {
-        self.changes_page = page.max(1);
-        self.changes_max = len.saturating_sub(1);
+        let changes = self.changes_mut(pane);
+        changes.page = page.max(1);
+        changes.max = len.saturating_sub(1);
         if len == 0 {
-            self.changes_selected = 0;
-            self.changes_offset = 0;
+            changes.selected = 0;
+            changes.offset = 0;
         } else {
-            self.changes_selected = self.changes_selected.min(self.changes_max);
-            self.ensure_changes_visible();
+            changes.selected = changes.selected.min(changes.max);
+            if changes.selected < changes.offset {
+                changes.offset = changes.selected;
+            } else if changes.selected >= changes.offset.saturating_add(changes.page) {
+                changes.offset = changes.selected + 1 - changes.page;
+            }
+            changes.offset = changes
+                .offset
+                .min(changes.max.saturating_add(1).saturating_sub(changes.page));
         }
-        self.changes_horizontal_page = horizontal_page.max(1);
-        self.changes_horizontal_max = horizontal_max;
-        self.changes_horizontal_offset = self.changes_horizontal_offset.min(horizontal_max);
+        changes.horizontal_page = horizontal_page.max(1);
+        changes.horizontal_max = horizontal_max;
+        changes.horizontal_offset = changes.horizontal_offset.min(horizontal_max);
     }
 
     pub(crate) fn reset_changes_view(&mut self) {
-        self.diff_error = None;
-        self.changes_selected = 0;
-        self.changes_offset = 0;
-        self.changes_horizontal_offset = 0;
+        self.tree_changes = ChangesView::default();
+        self.worktree_changes = ChangesView::default();
+    }
+
+    pub(crate) fn changes(&self, pane: ChangePane) -> &ChangesView {
+        match pane {
+            ChangePane::Tree => &self.tree_changes,
+            ChangePane::Worktree => &self.worktree_changes,
+        }
+    }
+
+    pub(crate) fn changes_mut(&mut self, pane: ChangePane) -> &mut ChangesView {
+        match pane {
+            ChangePane::Tree => &mut self.tree_changes,
+            ChangePane::Worktree => &mut self.worktree_changes,
+        }
+    }
+
+    fn focused_changes(&self) -> &ChangesView {
+        self.changes(self.changes_focus.expect("changes are focused"))
+    }
+
+    fn focused_changes_mut(&mut self) -> &mut ChangesView {
+        self.changes_mut(self.changes_focus.expect("changes are focused"))
+    }
+
+    fn cycle_changes_focus(&mut self) {
+        let (first, second) = match self.changes_layout {
+            ChangesLayout::SideBySide => (ChangePane::Tree, ChangePane::Worktree),
+            ChangesLayout::Stacked => (ChangePane::Worktree, ChangePane::Tree),
+        };
+        let visible = |pane| match pane {
+            ChangePane::Tree => self.tree_changes_visible,
+            ChangePane::Worktree => self.worktree_changes_visible,
+        };
+        self.changes_focus = match self.changes_focus {
+            None if visible(first) => Some(first),
+            None if visible(second) => Some(second),
+            Some(current) if current == first && visible(second) => Some(second),
+            Some(_) | None => None,
+        };
+    }
+
+    pub(crate) fn set_changes_layout(&mut self, layout: ChangesLayout, tree_visible: bool, worktree_visible: bool) {
+        self.changes_layout = layout;
+        self.tree_changes_visible = tree_visible;
+        self.worktree_changes_visible = worktree_visible;
+        if self.changes_focus == Some(ChangePane::Tree) && !tree_visible {
+            self.changes_focus = worktree_visible.then_some(ChangePane::Worktree);
+        } else if self.changes_focus == Some(ChangePane::Worktree) && !worktree_visible {
+            self.changes_focus = tree_visible.then_some(ChangePane::Tree);
+        }
     }
 
     #[cfg(test)]
@@ -1532,6 +1661,10 @@ mod tests {
         app.finish_lane_computation(rows, graph, lane_time);
     }
 
+    fn show_tree_changes(app: &mut App) {
+        app.set_changes_layout(ChangesLayout::SideBySide, true, false);
+    }
+
     #[test]
     fn completion_orders_and_draws_merge_lanes() {
         let mut app = App::new(10);
@@ -1795,9 +1928,10 @@ mod tests {
         app.update(Action::PreviewAuthorCopy(true));
         assert!(app.preview_author_copy && app.reachable_rows.is_some());
 
+        show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
         assert!(
-            app.changes_focused && !app.preview_author_copy && app.reachable_rows.is_none(),
+            app.changes_focus == Some(ChangePane::Tree) && !app.preview_author_copy && app.reachable_rows.is_none(),
             "entering the changes pane clears transient history navigation"
         );
 
@@ -1903,13 +2037,13 @@ mod tests {
         app.update(Action::PageDown);
         assert_eq!(app.commit_offset, 6);
 
-        app.changes_focused = true;
-        app.set_changes_bounds(2, 5, 1, 0);
+        app.changes_focus = Some(ChangePane::Tree);
+        app.set_changes_bounds(ChangePane::Tree, 2, 5, 1, 0);
         app.update(Action::PageDown);
-        assert_eq!(app.changes_selected, 2, "focused changes retain paging priority");
+        assert_eq!(app.tree_changes.selected, 2, "focused changes retain paging priority");
         assert_eq!(app.commit_offset, 6);
 
-        app.changes_focused = false;
+        app.changes_focus = None;
         app.set_commit_bounds(3, 0);
         app.update(Action::PageDown);
         assert_eq!(app.selected, Some(2), "history paging resumes when the commit fits");
@@ -1947,53 +2081,62 @@ mod tests {
     fn focused_changes_redirect_navigation_to_the_path_viewport() {
         let mut app = App::new(2);
         app.extend_commits((1..=3).map(row).collect::<Vec<_>>());
-        app.set_changes_bounds(4, 10, 20, 45);
+        app.set_changes_bounds(ChangePane::Tree, 4, 10, 20, 45);
+        show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
-        assert!(app.changes_focused);
-        assert_eq!(app.focus_feedback.take(), Some("changes"));
+        assert_eq!(app.changes_focus, Some(ChangePane::Tree));
+        assert_eq!(app.focus_feedback.take(), Some("tree changes"));
         app.update(Action::ToggleChangesFocus);
-        assert!(!app.changes_focused);
+        assert_eq!(app.changes_focus, None);
         assert_eq!(app.focus_feedback.take(), Some("history"));
         app.update(Action::ToggleChangesFocus);
 
         app.update(Action::MoveDown);
-        assert_eq!((app.changes_selected, app.changes_offset), (1, 0));
-        assert_eq!(app.update(Action::OpenDiff), vec![Effect::OpenDiff(1)]);
+        assert_eq!((app.tree_changes.selected, app.tree_changes.offset), (1, 0));
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::OpenDiff(ChangePane::Tree, 1)]
+        );
         assert_eq!(
             app.selected,
             Some(0),
             "path selection leaves commit selection untouched"
         );
         app.update(Action::PageDown);
-        assert_eq!((app.changes_selected, app.changes_offset), (5, 2));
+        assert_eq!((app.tree_changes.selected, app.tree_changes.offset), (5, 2));
         app.update(Action::HalfPageDown);
-        assert_eq!((app.changes_selected, app.changes_offset), (7, 4));
+        assert_eq!((app.tree_changes.selected, app.tree_changes.offset), (7, 4));
         app.update(Action::Last);
-        assert_eq!((app.changes_selected, app.changes_offset), (9, 6));
+        assert_eq!((app.tree_changes.selected, app.tree_changes.offset), (9, 6));
         app.update(Action::First);
-        assert_eq!((app.changes_selected, app.changes_offset), (0, 0));
+        assert_eq!((app.tree_changes.selected, app.tree_changes.offset), (0, 0));
 
         app.update(Action::ScrollRight);
         app.update(Action::ScrollRight);
         app.update(Action::ScrollRight);
-        assert_eq!(app.changes_horizontal_offset, 45);
+        assert_eq!(app.tree_changes.horizontal_offset, 45);
         assert_eq!(app.horizontal_offset, 0, "path panning leaves the graph untouched");
         app.update(Action::ScrollLeft);
-        assert_eq!(app.changes_horizontal_offset, 25);
+        assert_eq!(app.tree_changes.horizontal_offset, 25);
 
         app.update(Action::ToggleChanges);
-        assert!(!app.changes_focused, "closing the panel returns focus to history");
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_focus, None, "closing the panel returns focus to history");
         assert!(app.update(Action::OpenDiff).is_empty());
-        assert_eq!(app.changes_selected, 0);
-        assert_eq!(app.changes_offset, 0);
-        assert_eq!(app.changes_horizontal_offset, 0);
+        assert_eq!(app.tree_changes.selected, 0);
+        assert_eq!(app.tree_changes.offset, 0);
+        assert_eq!(app.tree_changes.horizontal_offset, 0);
     }
 
     #[test]
     fn toggles_metadata_columns() {
         let mut app = App::new(1);
         assert!(app.show_trailers, "trailer attribution is visible by default");
-        assert!(app.show_changes, "changed paths are visible by default");
+        assert_eq!(
+            app.changes_mode,
+            Some(ChangesMode::Both),
+            "tree and worktree changes are visible by default"
+        );
 
         app.update(Action::ToggleDate);
         app.update(Action::ToggleEmail);
@@ -2018,12 +2161,64 @@ mod tests {
         assert_eq!(app.ref_mode, RefMode::Default);
         assert!(!app.align_metadata);
         assert!(app.show_commit);
-        assert!(!app.show_changes);
-        assert_eq!(app.changes_parent, 1);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Tree));
+        assert_eq!(app.changes_parent, 0);
         app.update(Action::ToggleAlign);
         assert!(app.align_metadata);
     }
 
+    #[test]
+    fn cycles_both_tree_and_hidden_changes() {
+        let mut app = App::new(1);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Both));
+
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Tree));
+
+        app.changes_focus = Some(ChangePane::Tree);
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_mode, None);
+        assert_eq!(app.changes_focus, None, "hiding changes returns focus to history");
+
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Both));
+    }
+
+    #[test]
+    fn cycles_changes_focus_in_visual_order_and_keeps_navigation_independent() {
+        let mut app = App::new(1);
+        app.changes_mode = Some(ChangesMode::Both);
+        app.set_changes_bounds(ChangePane::Tree, 2, 4, 10, 20);
+        app.set_changes_bounds(ChangePane::Worktree, 2, 4, 10, 20);
+        app.set_changes_layout(ChangesLayout::SideBySide, true, true);
+
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(app.changes_focus, Some(ChangePane::Tree));
+        app.update(Action::MoveDown);
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(app.changes_focus, Some(ChangePane::Worktree));
+        app.update(Action::MoveDown);
+        assert_eq!(app.tree_changes.selected, 1);
+        assert_eq!(app.worktree_changes.selected, 1);
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::OpenDiff(ChangePane::Worktree, 1)]
+        );
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(app.changes_focus, None);
+
+        app.set_changes_layout(ChangesLayout::Stacked, true, true);
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(app.changes_focus, Some(ChangePane::Worktree));
+        app.update(Action::ToggleChangesFocus);
+        assert_eq!(app.changes_focus, Some(ChangePane::Tree));
+
+        app.set_changes_layout(ChangesLayout::Stacked, false, true);
+        assert_eq!(app.changes_focus, Some(ChangePane::Worktree));
+        app.set_changes_layout(ChangesLayout::Stacked, false, false);
+        assert_eq!(app.changes_focus, None);
+    }
+
     #[test]
     fn cycles_author_names_without_inert_states() {
         let mut app = App::new(1);
@@ -2118,15 +2313,16 @@ mod tests {
         complete(&mut app);
         app.update(Action::MoveDown);
         let selected = app.rows[app.selected.expect("a row is selected")].id;
-        app.set_changes_bounds(1, 3, 1, 2);
+        app.set_changes_bounds(ChangePane::Tree, 1, 3, 1, 2);
+        show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
         app.update(Action::MoveDown);
         app.update(Action::ScrollRight);
 
         app.reload(true);
-        assert!(!app.changes_focused, "reload returns focus to history");
-        assert_eq!(app.changes_selected, 0);
-        assert_eq!((app.changes_offset, app.changes_horizontal_offset), (0, 0));
+        assert_eq!(app.changes_focus, None, "reload returns focus to history");
+        assert_eq!(app.tree_changes.selected, 0);
+        assert_eq!((app.tree_changes.offset, app.tree_changes.horizontal_offset), (0, 0));
         app.extend_commits(vec![row(1), row(2), row(3)]);
         complete(&mut app);
         assert_eq!(
@@ -2167,10 +2363,11 @@ mod tests {
     #[test]
     fn pane_exit_keys_return_to_history_but_control_c_quits() {
         let mut app = App::new(1);
+        show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
 
         assert!(app.update(Action::Quit).is_empty());
-        assert!(!app.changes_focused, "q returns focus to history");
+        assert_eq!(app.changes_focus, None, "q returns focus to history");
 
         app.update(Action::ToggleChangesFocus);
         assert_eq!(
@@ -2179,7 +2376,7 @@ mod tests {
             "Ctrl-C quits even while changes have focus"
         );
         assert!(app.update(Action::Cancel).is_empty());
-        assert!(!app.changes_focused, "Escape returns focus to history");
+        assert_eq!(app.changes_focus, None, "Escape returns focus to history");
         assert_eq!(
             app.state,
             State::Loading,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b45f1d92edc..108cfb7ec77 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -20,7 +20,10 @@ use std::{
 };
 
 use anyhow::{Context, Result};
-use app::{Action, App, ChangeKind, Changes, CommitRow, ComparedParent, Effect, PathChange, SelectionRelation, State};
+use app::{
+    Action, App, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesMode, CommitRow, ComparedParent, Effect,
+    PathChange, SelectionRelation, State,
+};
 use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
@@ -45,6 +48,7 @@ const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
+const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 
@@ -54,6 +58,34 @@ struct FillRepository<'a> {
     retain: bool,
 }
 
+struct WorktreeWatcher {
+    _watcher: RecommendedWatcher,
+    events: mpsc::Receiver<notify::Result<notify::Event>>,
+    workdir: PathBuf,
+    dot_git: PathBuf,
+    git_dir: PathBuf,
+    index: PathBuf,
+}
+
+impl WorktreeWatcher {
+    fn event_is_relevant(&self, event: &notify::Event) -> bool {
+        worktree_event_is_relevant(event, &self.workdir, &self.dot_git, &self.git_dir, &self.index)
+    }
+}
+
+fn worktree_event_is_relevant(
+    event: &notify::Event,
+    workdir: &Path,
+    dot_git: &Path,
+    git_dir: &Path,
+    index: &Path,
+) -> bool {
+    !matches!(event.kind, notify::EventKind::Access(_))
+        && event.paths.iter().any(|path| {
+            path == index || (path.starts_with(workdir) && !path.starts_with(dot_git) && !path.starts_with(git_dir))
+        })
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct SelectionRef {
     name: BString,
@@ -68,11 +100,29 @@ struct SelectionRelationCache {
 }
 
 type LineCounts = Option<(u32, u32)>;
-type LineDiffResult = (usize, gix::object::tree::diff::ChangeDetached, Result<LineCounts>);
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct DiffResource {
+    id: gix::ObjectId,
+    mode: gix::objs::tree::EntryMode,
+    path: BString,
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum FileChange {
+    Tree(gix::object::tree::diff::ChangeDetached),
+    Worktree {
+        old: Option<DiffResource>,
+        new: Option<DiffResource>,
+    },
+    Unavailable(&'static str),
+}
+
+type LineDiffResult = (usize, FileChange, Result<LineCounts>);
 
 struct LineDiffJob {
     index: usize,
-    change: gix::object::tree::diff::ChangeDetached,
+    change: FileChange,
 }
 
 struct LineDiffPool {
@@ -81,6 +131,80 @@ struct LineDiffPool {
     workers: Vec<std::thread::JoinHandle<()>>,
 }
 
+fn worktree_diff_cache(
+    repository: &gix::Repository,
+    mode: gix::diff::blob::pipeline::Mode,
+) -> Result<Option<gix::diff::blob::Platform>> {
+    let Some(workdir) = repository.workdir() else {
+        return Ok(None);
+    };
+    repository
+        .diff_resource_cache(
+            mode,
+            gix::diff::blob::pipeline::WorktreeRoots {
+                old_root: None,
+                new_root: Some(workdir.to_owned()),
+            },
+        )
+        .map(Some)
+        .context("could not initialize worktree diff resources")
+}
+
+fn set_worktree_resources(
+    repository: &gix::Repository,
+    cache: &mut gix::diff::blob::Platform,
+    old: Option<&DiffResource>,
+    new: Option<&DiffResource>,
+) -> Result<()> {
+    let fallback = old.or(new).context("a file diff needs at least one resource")?;
+    let old_resource = old.unwrap_or(fallback);
+    cache
+        .set_resource(
+            old.map_or_else(|| repository.object_hash().null(), |resource| resource.id),
+            old_resource.mode.kind(),
+            old_resource.path.as_bstr(),
+            gix::diff::blob::ResourceKind::OldOrSource,
+            repository,
+        )
+        .context("could not prepare old worktree diff resource")?;
+    let new_resource = new.unwrap_or(fallback);
+    cache
+        .set_resource(
+            new.map_or_else(|| repository.object_hash().null(), |resource| resource.id),
+            new_resource.mode.kind(),
+            new_resource.path.as_bstr(),
+            gix::diff::blob::ResourceKind::NewOrDestination,
+            repository,
+        )
+        .context("could not prepare new worktree diff resource")?;
+    Ok(())
+}
+
+fn line_counts_for_change(
+    repository: &gix::Repository,
+    change: &FileChange,
+    tree_cache: &mut gix::diff::blob::Platform,
+    worktree_cache: Option<&mut gix::diff::blob::Platform>,
+) -> Result<LineCounts> {
+    let counts = match change {
+        FileChange::Tree(change) => change
+            .attach(repository, repository)
+            .diff(tree_cache)
+            .context("could not prepare line diff")?
+            .line_counts()
+            .context("could not count changed lines")?,
+        FileChange::Worktree { old, new } => {
+            let cache = worktree_cache.context("a working tree is required to count changed lines")?;
+            set_worktree_resources(repository, cache, old.as_ref(), new.as_ref())?;
+            gix::object::blob::diff::Platform { resource_cache: cache }
+                .line_counts()
+                .context("could not count worktree changed lines")?
+        }
+        FileChange::Unavailable(_) => None,
+    };
+    Ok(counts.map(|counts| (counts.insertions, counts.removals)))
+}
+
 impl LineDiffPool {
     fn new(repository_path: &Path, parallelism: usize) -> Result<Self> {
         let repository = gix::open(repository_path)
@@ -90,10 +214,12 @@ impl LineDiffPool {
         for _ in 0..parallelism {
             let mut repository = repository.to_thread_local();
             repository.object_cache_size(OBJECT_CACHE_SIZE);
-            let resource_cache = repository
+            let tree_cache = repository
                 .diff_resource_cache_for_tree_diff()
                 .context("could not initialize parallel line diffs")?;
-            worker_state.push((repository, resource_cache));
+            let worktree_cache = worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)
+                .context("could not initialize parallel worktree line diffs")?;
+            worker_state.push((repository, tree_cache, worktree_cache));
         }
 
         let (jobs, job_receiver) = mpsc::channel::<LineDiffJob>();
@@ -102,7 +228,7 @@ impl LineDiffPool {
         let (result_sender, results) = mpsc::channel();
         let workers = worker_state
             .into_iter()
-            .map(|(repository, mut resource_cache)| {
+            .map(|(repository, mut tree_cache, mut worktree_cache)| {
                 let job_receiver = gix::features::threading::OwnShared::clone(&job_receiver);
                 let result_sender = result_sender.clone();
                 std::thread::spawn(move || {
@@ -110,17 +236,12 @@ impl LineDiffPool {
                         let Ok(job) = gix::features::threading::lock(&job_receiver).recv() else {
                             break;
                         };
-                        let result = job
-                            .change
-                            .attach(&repository, &repository)
-                            .diff(&mut resource_cache)
-                            .context("could not prepare line diff")
-                            .and_then(|mut diff| {
-                                diff.line_counts()
-                                    .context("could not count changed lines")
-                                    .map(|counts| counts.map(|counts| (counts.insertions, counts.removals)))
-                            });
-                        resource_cache.clear_resource_cache_keep_allocation();
+                        let result =
+                            line_counts_for_change(&repository, &job.change, &mut tree_cache, worktree_cache.as_mut());
+                        tree_cache.clear_resource_cache_keep_allocation();
+                        if let Some(cache) = worktree_cache.as_mut() {
+                            cache.clear_resource_cache_keep_allocation();
+                        }
                         if result_sender.send((job.index, job.change, result)).is_err() {
                             break;
                         }
@@ -135,10 +256,7 @@ impl LineDiffPool {
         })
     }
 
-    fn line_counts(
-        &mut self,
-        changes: Vec<gix::object::tree::diff::ChangeDetached>,
-    ) -> Result<Vec<(gix::object::tree::diff::ChangeDetached, LineCounts)>> {
+    fn line_counts(&mut self, changes: Vec<FileChange>) -> Result<Vec<(FileChange, LineCounts)>> {
         let len = changes.len();
         let jobs = self.jobs.as_ref().context("line diff pool is shutting down")?;
         for (index, change) in changes.into_iter().enumerate() {
@@ -395,7 +513,7 @@ fn should_switch_screen(started_inline: bool, needs_alternate_screen: bool, in_a
 fn configure_initial_screen(app: &mut App, inline: bool) {
     app.inline = inline;
     if inline {
-        app.show_changes = false;
+        app.changes_mode = None;
     }
 }
 
@@ -441,7 +559,7 @@ fn sync_screen(
 ) -> Result<()> {
     let inline_height = inline_height(screen, terminal::size()?.1, app.rows.len());
     let needs_alternate_screen = needs_alternate_screen(
-        app.show_commit || app.show_changes,
+        app.show_commit || app.changes_mode.is_some(),
         history_requires_alternate_screen,
         inline_height,
     );
@@ -505,7 +623,10 @@ fn event_loop(
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
-    let mut changes = None;
+    let mut tree_changes = None;
+    let mut worktree_changes = None;
+    let mut worktree_watcher: Option<WorktreeWatcher> = None;
+    let mut worktree_refresh_deadline: Option<Instant> = None;
     let mut selection_relation = None;
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
     let mut line_diff_pool = None;
@@ -518,7 +639,7 @@ fn event_loop(
     app.configure_hidden_filter(!hide.is_empty());
     sync_line_diff_pool(
         &mut line_diff_pool,
-        app.show_changes,
+        app.changes_mode.is_some(),
         &repository_path,
         line_diff_parallelism,
     )?;
@@ -532,7 +653,8 @@ fn event_loop(
         &mut fill_repository,
         &mut notes,
         &mut commit_message,
-        &mut changes,
+        &mut tree_changes,
+        &mut worktree_changes,
         &mut selection_relation,
         &mut line_diff_pool,
     )?;
@@ -546,6 +668,30 @@ fn event_loop(
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
     let result: Result<Option<Duration>> = (|| loop {
+        if let Some(watcher) = worktree_watcher.as_mut() {
+            while let Ok(event) = watcher.events.try_recv() {
+                match event {
+                    Ok(event) if watcher.event_is_relevant(&event) => {
+                        worktree_refresh_deadline = Some(Instant::now() + WORKTREE_EVENT_IDLE);
+                    }
+                    Ok(_) => {}
+                    Err(err) => {
+                        app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                        worktree_watcher = None;
+                        worktree_refresh_deadline = None;
+                        dirty = true;
+                        urgent = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if worktree_refresh_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
+            worktree_refresh_deadline = None;
+            invalidate_worktree_changes(&mut worktree_changes);
+            dirty = true;
+            urgent = true;
+        }
         while let Ok(event) = ref_events.try_recv() {
             match event {
                 Ok(event) if !matches!(event.kind, notify::EventKind::Access(_)) => refresh_pending = true,
@@ -677,7 +823,8 @@ fn event_loop(
                 &mut fill_repository,
                 &mut notes,
                 &mut commit_message,
-                &mut changes,
+                &mut tree_changes,
+                &mut worktree_changes,
                 &mut selection_relation,
                 &mut line_diff_pool,
             )?;
@@ -753,7 +900,8 @@ fn event_loop(
                 &mut fill_repository,
                 &mut notes,
                 &mut commit_message,
-                &mut changes,
+                &mut tree_changes,
+                &mut worktree_changes,
                 &mut selection_relation,
                 &mut line_diff_pool,
             )?;
@@ -762,11 +910,13 @@ fn event_loop(
         }
         let repeat_timeout = repeat_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let watcher_timeout = ref_watcher.as_ref().map(|_| REF_EVENT_INTERVAL);
-        let wake_after = match (repeat_timeout, watcher_timeout) {
-            (Some(repeat), Some(watcher)) => Some(repeat.min(watcher)),
-            (Some(timeout), None) | (None, Some(timeout)) => Some(timeout),
-            (None, None) => None,
-        };
+        let worktree_timeout = worktree_refresh_deadline
+            .map(|deadline| deadline.saturating_duration_since(Instant::now()))
+            .or_else(|| worktree_watcher.as_ref().map(|_| REF_EVENT_INTERVAL));
+        let wake_after = [repeat_timeout, watcher_timeout, worktree_timeout]
+            .into_iter()
+            .flatten()
+            .min();
         let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
             Some(timeout) if event::poll(timeout)? => Some(event::read()?),
             Some(_) => None,
@@ -801,7 +951,7 @@ fn event_loop(
             continue;
         }
         let action = action(key);
-        let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focused);
+        let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
         if repeats_history {
             fill_repository.retain = true;
             repeat_deadline = Some(Instant::now() + REPEAT_IDLE);
@@ -809,7 +959,7 @@ fn event_loop(
             fill_repository.retain = false;
             fill_repository.retained = None;
         }
-        if repeats_history && app.show_changes {
+        if repeats_history && app.changes_mode.is_some() {
             app.changes_suppressed = true;
         } else if key.kind != KeyEventKind::Repeat && app.changes_suppressed {
             app.changes_suppressed = false;
@@ -820,20 +970,32 @@ fn event_loop(
         let Some(action) = action else {
             continue;
         };
-        if action == Action::ToggleChangesFocus && !changes_focusable(changes.as_ref().map(|(_, _, changes)| changes)) {
-            continue;
-        }
         dirty = true;
         urgent = true;
+        let previous_changes_mode = app.changes_mode;
         let toggles_changes = action == Action::ToggleChanges;
+        let refreshes_worktree = action == Action::Refresh && app.changes_mode == Some(ChangesMode::Both);
         let effects = app.update(action);
+        if refreshes_worktree {
+            invalidate_worktree_changes(&mut worktree_changes);
+        }
         if toggles_changes {
             sync_line_diff_pool(
                 &mut line_diff_pool,
-                app.show_changes,
+                app.changes_mode.is_some(),
                 &repository_path,
                 line_diff_parallelism,
             )?;
+            if app.changes_mode == Some(ChangesMode::Both) {
+                invalidate_worktree_changes(&mut worktree_changes);
+                worktree_watcher = start_worktree_watcher(&view_repository);
+                if worktree_watcher.is_none() {
+                    app.worktree_changes.error = Some("worktree changes won't update automatically".into());
+                }
+            } else if previous_changes_mode == Some(ChangesMode::Both) {
+                worktree_watcher = None;
+                worktree_refresh_deadline = None;
+            }
         }
         for effect in effects {
             match effect {
@@ -852,10 +1014,13 @@ fn event_loop(
                     refresh_pending = true;
                     refresh_expand_hidden = true;
                 }
-                Effect::OpenDiff(index) => {
+                Effect::OpenDiff(pane, index) => {
+                    let changes = match pane {
+                        ChangePane::Tree => tree_changes.as_ref().map(|(_, _, changes)| changes),
+                        ChangePane::Worktree => worktree_changes.as_ref().map(|(_, changes)| changes),
+                    };
                     let result = changes
-                        .as_ref()
-                        .and_then(|(_, _, changes)| changes.diffs.get(index).zip(changes.paths.get(index)))
+                        .and_then(|changes| changes.diffs.get(index).zip(changes.paths.get(index)))
                         .context("selected path no longer has diff resources")
                         .and_then(|(change, path)| prepare_file_diff(&repository_path, change, path))
                         .and_then(|diff| match diff {
@@ -869,7 +1034,7 @@ fn event_loop(
                         });
                     match result {
                         Ok(true) => app.focus_history(),
-                        Err(err) => app.diff_error = Some(format!("{err:#}")),
+                        Err(err) => app.changes_mut(pane).error = Some(format!("{err:#}")),
                         Ok(false) => {}
                     }
                 }
@@ -907,7 +1072,8 @@ fn event_loop(
             &mut fill_repository,
             &mut notes,
             &mut commit_message,
-            &mut changes,
+            &mut tree_changes,
+            &mut worktree_changes,
             &mut selection_relation,
             &mut line_diff_pool,
         )?;
@@ -918,9 +1084,9 @@ fn event_loop(
 fn prepare_inline_exit(app: &mut App) {
     app.inline = true;
     app.show_commit = false;
-    app.show_changes = false;
+    app.changes_mode = None;
     app.changes_suppressed = false;
-    app.changes_focused = false;
+    app.changes_focus = None;
     app.reset_changes_view();
     app.show_selection_tail = false;
 }
@@ -1048,6 +1214,37 @@ fn start_ref_watcher(
     }
 }
 
+fn start_worktree_watcher(repository: &gix::Repository) -> Option<WorktreeWatcher> {
+    let workdir = repository.workdir()?.to_owned();
+    let index = repository.index_path();
+    let git_dir = repository.git_dir().to_owned();
+    let dot_git = workdir.join(gix::discover::DOT_GIT_DIR);
+    let (sender, events) = mpsc::channel();
+    let mut watcher = notify::recommended_watcher(move |event| {
+        let _ = sender.send(event);
+    })
+    .ok()?;
+    watcher.watch(&workdir, RecursiveMode::Recursive).ok()?;
+    let index_parent = index.parent()?;
+    if !index_parent.starts_with(&workdir) {
+        watcher.watch(index_parent, RecursiveMode::NonRecursive).ok()?;
+    }
+    Some(WorktreeWatcher {
+        _watcher: watcher,
+        events,
+        workdir,
+        dot_git,
+        git_dir,
+        index,
+    })
+}
+
+fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) {
+    if let Some((marker, _)) = changes {
+        *marker = usize::MAX;
+    }
+}
+
 fn visible_decorations_changed(old: &Decorations, new: &Decorations, rows: &[CommitRow]) -> bool {
     rows.iter().any(|row| old.get(&row.id) != new.get(&row.id))
 }
@@ -1129,11 +1326,12 @@ fn draw(
     fill_repository: &mut FillRepository<'_>,
     notes: &mut gix::note::Platform,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
-    changes: &mut Option<(gix::ObjectId, usize, Changes)>,
+    tree_changes: &mut Option<(gix::ObjectId, usize, Changes)>,
+    worktree_changes: &mut Option<(usize, Changes)>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
 ) -> Result<()> {
-    app.viewport_rows = terminal
+    let render_rows = terminal
         .get_frame()
         .area()
         .height
@@ -1141,9 +1339,10 @@ fn draw(
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
         return Ok(());
     }
+    app.viewport_rows = app.viewport_rows.min(render_rows.max(1));
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
-    let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
+    let end = start.saturating_add(render_rows).min(app.rows.len());
     for index in start..end {
         let id = app.rows[index].id;
         if app.notes_loaded(id) {
@@ -1171,7 +1370,9 @@ fn draw(
         .then_some(selected_id)
         .flatten()
         .filter(|id| selection_cache.as_ref().is_none_or(|cached| cached.id != *id));
-    let selected = (app.show_commit || changes_visible).then_some(selected_id).flatten();
+    let selected = (app.show_commit || app.changes_mode.is_some())
+        .then_some(selected_id)
+        .flatten();
     let message_to_load = app
         .show_commit
         .then_some(selected)
@@ -1180,26 +1381,36 @@ fn draw(
     if message_to_load.is_some() {
         app.reset_commit_view();
     }
-    if changes_visible && selected.is_some() && changes.as_ref().map(|(cached, _, _)| *cached) != selected {
+    if changes_visible && selected.is_some() && tree_changes.as_ref().map(|(cached, _, _)| *cached) != selected {
         app.changes_parent = 0;
     }
-    let changes_to_load = changes_visible.then_some(selected).flatten().filter(|id| {
-        changes
+    let tree_changes_to_load = (changes_visible && app.changes_mode.is_some())
+        .then_some(selected)
+        .flatten()
+        .filter(|id| {
+            tree_changes
+                .as_ref()
+                .is_none_or(|(cached, parent, _)| *cached != *id || *parent != app.changes_parent)
+        });
+    let worktree_changes_to_load = changes_visible
+        && app.changes_mode == Some(ChangesMode::Both)
+        && worktree_changes
             .as_ref()
-            .is_none_or(|(cached, parent, _)| cached != id || *parent != app.changes_parent)
-    });
-    if changes_to_load.is_some() {
+            .is_none_or(|(marker, _)| *marker == usize::MAX);
+    if tree_changes_to_load.is_some() || worktree_changes_to_load {
         app.reset_changes_view();
     }
     if !app.show_commit || selected.is_none() {
         *commit_message = None;
     }
-    if !app.show_changes || app.selected.is_none() {
-        *changes = None;
+    if app.changes_mode.is_none() {
+        *tree_changes = None;
+        *worktree_changes = None;
     }
     if app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
-        || changes_to_load.is_some()
+        || tree_changes_to_load.is_some()
+        || worktree_changes_to_load
         || relation_to_load.is_some()
     {
         let mut one_shot_repository = None;
@@ -1230,7 +1441,7 @@ fn draw(
             *selection_cache = Some(SelectionRelationCache { id, refs, relation });
             app.selection_relation = relation;
         }
-        if let Some(id) = changes_to_load {
+        if let Some(id) = tree_changes_to_load {
             repository.object_cache_size(OBJECT_CACHE_SIZE);
             let loaded = load_changes(
                 repository,
@@ -1243,12 +1454,47 @@ fn draw(
             repository.object_cache_size(None);
             let loaded = loaded?;
             app.changes_parent = loaded.parent.map_or(0, |parent| parent.index);
-            *changes = Some((id, app.changes_parent, loaded));
+            *tree_changes = Some((id, app.changes_parent, loaded));
+        }
+        if worktree_changes_to_load {
+            repository.object_cache_size(OBJECT_CACHE_SIZE);
+            let loaded = load_worktree_changes(
+                repository,
+                line_diff_pool
+                    .as_mut()
+                    .context("line diff pool is missing while the changes pane is visible")?,
+            );
+            repository.object_cache_size(None);
+            match loaded {
+                Ok(loaded) => {
+                    app.worktree_changes.error = None;
+                    *worktree_changes = Some((0, loaded));
+                }
+                Err(err) => {
+                    app.worktree_changes.error = Some(format!("status: {err:#}"));
+                    if let Some((marker, _)) = worktree_changes.as_mut() {
+                        *marker = 0;
+                    } else {
+                        *worktree_changes = Some((0, Changes::default()));
+                    }
+                }
+            }
         }
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
-    let changes = changes.as_ref().map(|(_, _, changes)| changes);
-    terminal.draw(|frame| ui::draw(frame, app, decorations, mailmap, message, changes))?;
+    let tree_changes = tree_changes.as_ref().map(|(_, _, changes)| changes);
+    let worktree_changes = worktree_changes.as_ref().map(|(_, changes)| changes);
+    terminal.draw(|frame| {
+        ui::draw_with_worktree(
+            frame,
+            app,
+            decorations,
+            mailmap,
+            message,
+            tree_changes,
+            worktree_changes,
+        );
+    })?;
     Ok(())
 }
 
@@ -1267,11 +1513,7 @@ fn open_notes(repository_path: &Path) -> Result<gix::note::Platform> {
         .context("could not open Git notes")
 }
 
-fn prepare_file_diff(
-    repository_path: &Path,
-    change: &gix::object::tree::diff::ChangeDetached,
-    path: &PathChange,
-) -> Result<FileDiff> {
+fn prepare_file_diff(repository_path: &Path, change: &FileChange, path: &PathChange) -> Result<FileDiff> {
     let mut repository = gix::open(repository_path).context("could not open repository for file diff")?;
     repository.object_cache_size(OBJECT_CACHE_SIZE);
     prepare_file_diff_with_repository(&repository, change, path)
@@ -1279,26 +1521,45 @@ fn prepare_file_diff(
 
 fn prepare_file_diff_with_repository(
     repository: &gix::Repository,
-    change: &gix::object::tree::diff::ChangeDetached,
+    change: &FileChange,
     path: &PathChange,
 ) -> Result<FileDiff> {
+    if let FileChange::Unavailable(message) = change {
+        anyhow::bail!("{message}");
+    }
     let global_command = repository
         .config_snapshot()
         .trusted_program(gix::config::tree::Diff::EXTERNAL)
         .map(gix::path::os_string_into_bstring)
         .transpose()
         .context("external diff command is not representable on this platform")?;
-    let mut resources = repository
-        .diff_resource_cache(
+    let mut resources = match change {
+        FileChange::Tree(_) => repository
+            .diff_resource_cache(
+                gix::diff::blob::pipeline::Mode::ToGitUnlessBinaryToTextIsPresent,
+                Default::default(),
+            )
+            .context("could not initialize file diff")?,
+        FileChange::Worktree { .. } => worktree_diff_cache(
+            repository,
             gix::diff::blob::pipeline::Mode::ToGitUnlessBinaryToTextIsPresent,
-            Default::default(),
-        )
-        .context("could not initialize file diff")?;
+        )?
+        .context("a working tree is required to show this diff")?,
+        FileChange::Unavailable(_) => unreachable!("handled above"),
+    };
     resources.options.skip_internal_diff_if_external_is_configured = true;
-    change
-        .attach(repository, repository)
-        .diff(&mut resources)
-        .context("could not prepare selected file")?;
+    match change {
+        FileChange::Tree(change) => {
+            change
+                .attach(repository, repository)
+                .diff(&mut resources)
+                .context("could not prepare selected file")?;
+        }
+        FileChange::Worktree { old, new } => {
+            set_worktree_resources(repository, &mut resources, old.as_ref(), new.as_ref())?;
+        }
+        FileChange::Unavailable(_) => unreachable!("handled above"),
+    }
     let prepared = resources.prepare_diff().context("could not prepare selected diff")?;
     match prepared.operation {
         gix::diff::blob::platform::prepare_diff::Operation::ExternalCommand { command } => {
@@ -1368,37 +1629,41 @@ fn prepare_external_diff(
     ))
 }
 
-fn built_in_diff(
-    path: &PathChange,
-    change: &gix::object::tree::diff::ChangeDetached,
-    rendered: Option<BString>,
-    binary: bool,
-) -> BuiltInDiff {
-    use gix::object::tree::diff::ChangeDetached;
-
+fn built_in_diff(path: &PathChange, change: &FileChange, rendered: Option<BString>, binary: bool) -> BuiltInDiff {
     let (old_path, new_path, old_mode, new_mode) = match change {
-        ChangeDetached::Addition { entry_mode, .. } => (None, Some(path.path.as_bstr()), None, Some(*entry_mode)),
-        ChangeDetached::Deletion { entry_mode, .. } => (Some(path.path.as_bstr()), None, Some(*entry_mode), None),
-        ChangeDetached::Modification {
+        FileChange::Tree(gix::object::tree::diff::ChangeDetached::Addition { entry_mode, .. }) => {
+            (None, Some(path.path.as_bstr()), None, Some(*entry_mode))
+        }
+        FileChange::Tree(gix::object::tree::diff::ChangeDetached::Deletion { entry_mode, .. }) => {
+            (Some(path.path.as_bstr()), None, Some(*entry_mode), None)
+        }
+        FileChange::Tree(gix::object::tree::diff::ChangeDetached::Modification {
             previous_entry_mode,
             entry_mode,
             ..
-        } => (
+        }) => (
             Some(path.path.as_bstr()),
             Some(path.path.as_bstr()),
             Some(*previous_entry_mode),
             Some(*entry_mode),
         ),
-        ChangeDetached::Rewrite {
+        FileChange::Tree(gix::object::tree::diff::ChangeDetached::Rewrite {
             source_entry_mode,
             entry_mode,
             ..
-        } => (
+        }) => (
             path.source.as_ref().map(|path| path.as_bstr()),
             Some(path.path.as_bstr()),
             Some(*source_entry_mode),
             Some(*entry_mode),
         ),
+        FileChange::Worktree { old, new } => (
+            old.as_ref().map(|resource| resource.path.as_bstr()),
+            new.as_ref().map(|resource| resource.path.as_bstr()),
+            old.as_ref().map(|resource| resource.mode),
+            new.as_ref().map(|resource| resource.mode),
+        ),
+        FileChange::Unavailable(_) => unreachable!("unavailable diffs aren't rendered"),
     };
     let display_path = |path: Option<&gix::bstr::BStr>, prefix: &str| -> BString {
         path.map_or_else(
@@ -1670,11 +1935,12 @@ fn load_changes(
         }
         out.paths.push(PathChange {
             kind,
+            group: ChangeGroup::Tree,
             source,
             path,
             lines: None,
         });
-        diffs.push(change);
+        diffs.push(FileChange::Tree(change));
     }
     for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
         path.lines = lines;
@@ -1687,6 +1953,323 @@ fn load_changes(
     Ok(out)
 }
 
+fn entry_mode(mode: gix::index::entry::Mode) -> Result<gix::objs::tree::EntryMode> {
+    mode.to_tree_entry_mode()
+        .context("status entry cannot be represented in a tree")
+}
+
+fn staged_change(change: gix::diff::index::Change) -> Result<(PathChange, FileChange)> {
+    use gix::diff::index::Change;
+    use gix::object::tree::diff::ChangeDetached;
+
+    let (kind, source, path, diff) = match change {
+        Change::Addition {
+            location,
+            entry_mode: mode,
+            id,
+            ..
+        } => {
+            let entry_mode = entry_mode(mode)?;
+            let path = location.into_owned();
+            let diff = ChangeDetached::Addition {
+                location: path.clone(),
+                entry_mode,
+                relation: None,
+                id: id.into_owned(),
+            };
+            (ChangeKind::Added, None, path, diff)
+        }
+        Change::Deletion {
+            location,
+            entry_mode: mode,
+            id,
+            ..
+        } => {
+            let entry_mode = entry_mode(mode)?;
+            let path = location.into_owned();
+            let diff = ChangeDetached::Deletion {
+                location: path.clone(),
+                entry_mode,
+                relation: None,
+                id: id.into_owned(),
+            };
+            (ChangeKind::Deleted, None, path, diff)
+        }
+        Change::Modification {
+            location,
+            previous_entry_mode,
+            previous_id,
+            entry_mode: mode,
+            id,
+            ..
+        } => {
+            let previous_entry_mode = entry_mode(previous_entry_mode)?;
+            let current_entry_mode = entry_mode(mode)?;
+            let path = location.into_owned();
+            let kind = if previous_entry_mode.kind() == current_entry_mode.kind() {
+                ChangeKind::Modified
+            } else {
+                ChangeKind::TypeChanged
+            };
+            let diff = ChangeDetached::Modification {
+                location: path.clone(),
+                previous_entry_mode,
+                previous_id: previous_id.into_owned(),
+                entry_mode: current_entry_mode,
+                id: id.into_owned(),
+            };
+            (kind, None, path, diff)
+        }
+        Change::Rewrite {
+            source_location,
+            source_entry_mode,
+            source_id,
+            location,
+            entry_mode: mode,
+            id,
+            copy,
+            ..
+        } => {
+            let source_entry_mode = entry_mode(source_entry_mode)?;
+            let current_entry_mode = entry_mode(mode)?;
+            let source = source_location.into_owned();
+            let path = location.into_owned();
+            let diff = ChangeDetached::Rewrite {
+                source_location: source.clone(),
+                source_entry_mode,
+                source_relation: None,
+                source_id: source_id.into_owned(),
+                diff: None,
+                entry_mode: current_entry_mode,
+                id: id.into_owned(),
+                location: path.clone(),
+                relation: None,
+                copy,
+            };
+            (
+                if copy { ChangeKind::Copied } else { ChangeKind::Renamed },
+                Some(source),
+                path,
+                diff,
+            )
+        }
+    };
+    let unavailable = matches!(diff, ChangeDetached::Addition { entry_mode, .. } if entry_mode.is_commit())
+        || matches!(diff, ChangeDetached::Deletion { entry_mode, .. } if entry_mode.is_commit())
+        || matches!(diff, ChangeDetached::Modification { previous_entry_mode, entry_mode, .. } if previous_entry_mode.is_commit() || entry_mode.is_commit())
+        || matches!(diff, ChangeDetached::Rewrite { source_entry_mode, entry_mode, .. } if source_entry_mode.is_commit() || entry_mode.is_commit());
+    Ok((
+        PathChange {
+            kind,
+            group: ChangeGroup::Staged,
+            source,
+            path,
+            lines: None,
+        },
+        if unavailable {
+            FileChange::Unavailable("submodule changes don't have a file diff")
+        } else {
+            FileChange::Tree(diff)
+        },
+    ))
+}
+
+fn worktree_resource(entry: &gix::index::Entry, path: &gix::bstr::BStr) -> Result<DiffResource> {
+    Ok(DiffResource {
+        id: entry.id,
+        mode: entry_mode(entry.mode)?,
+        path: path.to_owned(),
+    })
+}
+
+fn unstaged_change(
+    item: gix::status::index_worktree::Item,
+    object_hash: gix::hash::Kind,
+) -> Result<Option<(PathChange, FileChange)>> {
+    use gix::status::index_worktree::Item;
+    use gix::status::plumbing::index_as_worktree::{Change, EntryStatus};
+
+    let (kind, source, path, diff) = match item {
+        Item::Modification {
+            entry,
+            rela_path,
+            status,
+            ..
+        } => {
+            let old = worktree_resource(&entry, rela_path.as_bstr())?;
+            match status {
+                EntryStatus::Conflict { .. } => (
+                    ChangeKind::Unmerged,
+                    None,
+                    rela_path,
+                    FileChange::Unavailable("an unmerged path has no single file diff"),
+                ),
+                EntryStatus::IntentToAdd => (
+                    ChangeKind::Added,
+                    None,
+                    rela_path.clone(),
+                    FileChange::Worktree {
+                        old: None,
+                        new: Some(DiffResource {
+                            id: entry.id.kind().null(),
+                            mode: old.mode,
+                            path: rela_path,
+                        }),
+                    },
+                ),
+                EntryStatus::NeedsUpdate(_) => return Ok(None),
+                EntryStatus::Change(Change::Removed) => (
+                    ChangeKind::Deleted,
+                    None,
+                    rela_path,
+                    FileChange::Worktree {
+                        old: Some(old),
+                        new: None,
+                    },
+                ),
+                EntryStatus::Change(Change::Type { worktree_mode }) => {
+                    let new_mode = entry_mode(worktree_mode)?;
+                    (
+                        ChangeKind::TypeChanged,
+                        None,
+                        rela_path.clone(),
+                        FileChange::Worktree {
+                            old: Some(old),
+                            new: Some(DiffResource {
+                                id: entry.id.kind().null(),
+                                mode: new_mode,
+                                path: rela_path,
+                            }),
+                        },
+                    )
+                }
+                EntryStatus::Change(Change::Modification {
+                    executable_bit_changed, ..
+                }) => {
+                    let mode = if executable_bit_changed {
+                        if old.mode.is_executable() {
+                            gix::objs::tree::EntryKind::Blob
+                        } else {
+                            gix::objs::tree::EntryKind::BlobExecutable
+                        }
+                        .into()
+                    } else {
+                        old.mode
+                    };
+                    (
+                        ChangeKind::Modified,
+                        None,
+                        rela_path.clone(),
+                        FileChange::Worktree {
+                            old: Some(old),
+                            new: Some(DiffResource {
+                                id: entry.id.kind().null(),
+                                mode,
+                                path: rela_path,
+                            }),
+                        },
+                    )
+                }
+                EntryStatus::Change(Change::SubmoduleModification(_)) => (
+                    ChangeKind::Modified,
+                    None,
+                    rela_path,
+                    FileChange::Unavailable("submodule changes don't have a file diff"),
+                ),
+            }
+        }
+        Item::DirectoryContents { entry, .. } => {
+            let mode = match entry.disk_kind {
+                Some(gix::dir::entry::Kind::File) => gix::objs::tree::EntryKind::Blob.into(),
+                Some(gix::dir::entry::Kind::Symlink) => gix::objs::tree::EntryKind::Link.into(),
+                _ => return Ok(None),
+            };
+            let path = entry.rela_path;
+            (
+                ChangeKind::Added,
+                None,
+                path.clone(),
+                FileChange::Worktree {
+                    old: None,
+                    new: Some(DiffResource {
+                        id: object_hash.null(),
+                        mode,
+                        path,
+                    }),
+                },
+            )
+        }
+        Item::Rewrite {
+            source,
+            dirwalk_entry,
+            copy,
+            ..
+        } => {
+            let source = source.rela_path().to_owned();
+            let path = dirwalk_entry.rela_path;
+            (
+                if copy { ChangeKind::Copied } else { ChangeKind::Renamed },
+                Some(source),
+                path,
+                FileChange::Unavailable("unstaged rewrite diffs aren't available"),
+            )
+        }
+    };
+    Ok(Some((
+        PathChange {
+            kind,
+            group: ChangeGroup::Unstaged,
+            source,
+            path,
+            lines: None,
+        },
+        diff,
+    )))
+}
+
+fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
+    let mut status = repository
+        .status(gix::progress::Discard)
+        .context("could not initialize worktree status")?
+        .untracked_files(gix::status::UntrackedFiles::Files)
+        .index_worktree_options_mut(|options| {
+            options.sorting = Some(gix::status::plumbing::index_as_worktree_with_renames::Sorting::ByPathCaseSensitive);
+        })
+        .into_iter(Vec::<BString>::new())
+        .context("could not start worktree status")?;
+    let mut staged = Vec::new();
+    let mut unstaged = Vec::new();
+    for item in status.by_ref() {
+        match item.context("could not obtain worktree status")? {
+            gix::status::Item::TreeIndex(change) => staged.push(staged_change(change)?),
+            gix::status::Item::IndexWorktree(item) => {
+                if let Some(change) = unstaged_change(item, repository.object_hash())? {
+                    unstaged.push(change);
+                }
+            }
+        }
+    }
+    drop(status);
+    staged.sort_by(|(a, _), (b, _)| a.path.cmp(&b.path));
+    unstaged.sort_by(|(a, _), (b, _)| a.path.cmp(&b.path));
+    staged.extend(unstaged);
+
+    let (paths, diffs): (Vec<_>, Vec<_>) = staged.into_iter().unzip();
+    let mut out = Changes {
+        paths,
+        ..Changes::default()
+    };
+    for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
+        path.lines = lines;
+        if let Some((insertions, removals)) = lines {
+            out.lines_added += u64::from(insertions);
+            out.lines_removed += u64::from(removals);
+        }
+        out.diffs.push(change);
+    }
+    Ok(out)
+}
+
 fn actor_bytes(author: &app::Author) -> Vec<u8> {
     let mut out = Vec::with_capacity(author.name.len() + author.email.len() + 3);
     out.extend_from_slice(author.name);
@@ -1779,10 +2362,6 @@ fn action(key: KeyEvent) -> Option<Action> {
     }
 }
 
-fn changes_focusable(changes: Option<&Changes>) -> bool {
-    changes.is_some_and(Changes::is_visible)
-}
-
 fn repeats_viewport(action: &Action) -> bool {
     matches!(
         action,
@@ -1935,6 +2514,7 @@ mod tests {
             root.paths,
             [PathChange {
                 kind: ChangeKind::Added,
+                group: ChangeGroup::Tree,
                 source: None,
                 path: "root".into(),
                 lines: Some((1, 0)),
@@ -2011,12 +2591,14 @@ mod tests {
             [
                 PathChange {
                     kind: ChangeKind::Added,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: "topic".into(),
                     lines: Some((1, 0)),
                 },
                 PathChange {
                     kind: ChangeKind::Added,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: "topic-extra".into(),
                     lines: Some((1, 0)),
@@ -2040,6 +2622,7 @@ mod tests {
             first_parent.paths,
             [PathChange {
                 kind: ChangeKind::Added,
+                group: ChangeGroup::Tree,
                 source: None,
                 path: "merged".into(),
                 lines: Some((1, 0)),
@@ -2060,6 +2643,7 @@ mod tests {
             second_parent.paths,
             [PathChange {
                 kind: ChangeKind::Added,
+                group: ChangeGroup::Tree,
                 source: None,
                 path: "main".into(),
                 lines: Some((1, 0)),
@@ -2074,6 +2658,80 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn loads_staged_and_unstaged_worktree_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
+            std::process::Command::new("git")
+                .current_dir(path)
+                .args(["-c", "commit.gpgsign=false"])
+                .args(args)
+                .status()
+        };
+
+        assert!(git(&["switch", "-q", "-c", "conflict-other"])?.success());
+        std::fs::write(path.join("root"), "other\n")?;
+        assert!(git(&["commit", "-qam", "other"])?.success());
+        assert!(git(&["switch", "-q", "main"])?.success());
+        std::fs::write(path.join("root"), "ours\n")?;
+        assert!(git(&["commit", "-qam", "ours"])?.success());
+        assert!(
+            !git(&["merge", "--no-edit", "conflict-other"])?.success(),
+            "the fixture deliberately leaves an unresolved path"
+        );
+
+        std::fs::write(path.join("staged"), "staged\n")?;
+        std::fs::write(path.join("both"), "index\n")?;
+        assert!(git(&["add", "staged", "both"])?.success());
+        std::fs::write(path.join("both"), "index\nworktree\n")?;
+        std::fs::write(path.join("untracked"), "untracked\n")?;
+        std::fs::write(path.join(".git/info/exclude"), "ignored\n")?;
+        std::fs::write(path.join("ignored"), "ignored\n")?;
+
+        let repository = gix::open(path)?;
+        let mut line_diff_pool = LineDiffPool::new(path, 2)?;
+        let changes = load_worktree_changes(&repository, &mut line_diff_pool)?;
+        let rows: Vec<_> = changes
+            .paths
+            .iter()
+            .map(|change| (change.group, change.kind, change.path.to_string()))
+            .collect();
+        assert_eq!(
+            rows,
+            [
+                (ChangeGroup::Staged, ChangeKind::Added, "both".into()),
+                (ChangeGroup::Staged, ChangeKind::Added, "staged".into()),
+                (ChangeGroup::Unstaged, ChangeKind::Added, ".mailmap".into()),
+                (ChangeGroup::Unstaged, ChangeKind::Modified, "both".into()),
+                (ChangeGroup::Unstaged, ChangeKind::Unmerged, "root".into()),
+                (ChangeGroup::Unstaged, ChangeKind::Added, "untracked".into()),
+            ],
+            "status is partitioned, path-sorted, includes conflicts and untracked files, and excludes ignored files"
+        );
+        assert!(changes.lines_added > 0, "available file diffs contribute line counts");
+        for (path, diff) in changes.paths.iter().zip(&changes.diffs) {
+            if path.kind != ChangeKind::Unmerged {
+                prepare_file_diff_with_repository(&repository, diff, path)
+                    .with_context(|| format!("{} should produce a staged or worktree diff", path.path))?;
+            }
+        }
+        let conflict = changes
+            .paths
+            .iter()
+            .position(|change| change.kind == ChangeKind::Unmerged)
+            .expect("the conflict is visible");
+        assert!(
+            prepare_file_diff_with_repository(&repository, &changes.diffs[conflict], &changes.paths[conflict])
+                .err()
+                .expect("conflicts cannot produce a single file diff")
+                .to_string()
+                .contains("no single file diff"),
+            "opening an unresolved path produces actionable feedback"
+        );
+        Ok(())
+    }
+
     #[test]
     fn streams_diff_bytes_and_accepts_early_pager_exit() -> gix_testtools::Result {
         let diff = BuiltInDiff::new(
@@ -2155,13 +2813,16 @@ mod tests {
         let mut inline = App::new(1);
         configure_initial_screen(&mut inline, true);
         assert!(inline.inline);
-        assert!(!inline.show_changes, "inline startup hides the default changes view");
+        assert_eq!(
+            inline.changes_mode, None,
+            "inline startup hides the default changes view"
+        );
         let mut alternate = App::new(1);
         configure_initial_screen(&mut alternate, false);
         assert!(!alternate.inline);
         assert!(
-            alternate.show_changes,
-            "alternate-screen startup keeps the default changes view"
+            alternate.changes_mode == Some(ChangesMode::Both),
+            "alternate-screen startup keeps the default tree and worktree changes view"
         );
 
         assert!(
@@ -2329,22 +2990,6 @@ mod tests {
         assert_eq!(action(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE)), None);
     }
 
-    #[test]
-    fn only_visible_changes_can_take_focus() {
-        assert!(!changes_focusable(None));
-        assert!(!changes_focusable(Some(&Changes::default())));
-        let changes = Changes {
-            paths: vec![PathChange {
-                kind: ChangeKind::Modified,
-                source: None,
-                path: "file".into(),
-                lines: None,
-            }],
-            ..Changes::default()
-        };
-        assert!(changes_focusable(Some(&changes)));
-    }
-
     #[test]
     fn retains_the_fill_repository_only_for_repeated_viewport_navigation() {
         assert!(retains_fill_repository(
@@ -2383,17 +3028,17 @@ mod tests {
     fn prepares_a_reduced_selection_after_leaving_the_alternate_screen() {
         let mut app = App::new(1);
         app.show_commit = true;
-        app.show_changes = true;
-        app.changes_focused = true;
+        app.changes_mode = Some(ChangesMode::Tree);
+        app.changes_focus = Some(ChangePane::Tree);
 
         prepare_inline_exit(&mut app);
 
         assert!(app.inline, "the final frame is drawn into the restored inline screen");
         assert!(
-            !app.show_commit && !app.show_changes,
+            !app.show_commit && app.changes_mode.is_none(),
             "alternate-screen panels are omitted from the final frame"
         );
-        assert!(!app.changes_focused, "the hidden panel no longer owns focus");
+        assert_eq!(app.changes_focus, None, "the hidden panel no longer owns focus");
         assert!(!app.show_selection_tail, "only the left selection marker remains");
     }
 
@@ -2467,4 +3112,46 @@ mod tests {
             "the earlier frame deadline takes precedence over repeat-idle restoration"
         );
     }
+
+    #[test]
+    fn filters_worktree_watch_events_and_invalidates_cached_status() {
+        use notify::event::{AccessKind, ModifyKind};
+
+        let workdir = Path::new("/repo");
+        let dot_git = workdir.join(".git");
+        let git_dir = dot_git.clone();
+        let index = git_dir.join("index");
+        let modified =
+            |path: &Path| notify::Event::new(notify::EventKind::Modify(ModifyKind::Any)).add_path(path.to_owned());
+        assert!(worktree_event_is_relevant(
+            &modified(&workdir.join("src/lib.rs")),
+            workdir,
+            &dot_git,
+            &git_dir,
+            &index
+        ));
+        assert!(worktree_event_is_relevant(
+            &modified(&index),
+            workdir,
+            &dot_git,
+            &git_dir,
+            &index
+        ));
+        assert!(!worktree_event_is_relevant(
+            &modified(&git_dir.join("HEAD")),
+            workdir,
+            &dot_git,
+            &git_dir,
+            &index
+        ));
+        let access =
+            notify::Event::new(notify::EventKind::Access(AccessKind::Any)).add_path(workdir.join("src/lib.rs"));
+        assert!(!worktree_event_is_relevant(
+            &access, workdir, &dot_git, &git_dir, &index
+        ));
+
+        let mut changes = Some((0, Changes::default()));
+        invalidate_worktree_changes(&mut changes);
+        assert_eq!(changes.as_ref().map(|(marker, _)| *marker), Some(usize::MAX));
+    }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 9273affa298..08618812700 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -10,8 +10,8 @@ use ratatui::{
 use crate::{
     BuiltInDiff,
     app::{
-        App, AttributionKind, ChangeKind, Changes, CommitRow, CopyKind, NameMode, RefMode, SelectionRelation,
-        SignatureState, State,
+        App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesLayout, ChangesMode, CommitRow,
+        CopyKind, NameMode, RefMode, SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -20,6 +20,113 @@ const COMPARED_PARENT_COLOR: Color = Color::Cyan;
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct ChangesPaneArea {
+    pane: ChangePane,
+    outer: Rect,
+}
+
+fn changes_pane_areas(
+    area: Rect,
+    max_height: u16,
+    tree: Option<(u16, usize)>,
+    worktree: Option<(u16, usize)>,
+) -> (ChangesLayout, Vec<ChangesPaneArea>, u16) {
+    match (tree, worktree) {
+        (None, None) => (ChangesLayout::SideBySide, Vec::new(), 0),
+        (Some((height, _)), None) => {
+            let height = height.min(max_height);
+            (
+                ChangesLayout::SideBySide,
+                vec![ChangesPaneArea {
+                    pane: ChangePane::Tree,
+                    outer: Rect::new(area.x, area.bottom().saturating_sub(height), area.width, height),
+                }],
+                height,
+            )
+        }
+        (None, Some((height, _))) => {
+            let height = height.min(max_height);
+            (
+                ChangesLayout::SideBySide,
+                vec![ChangesPaneArea {
+                    pane: ChangePane::Worktree,
+                    outer: Rect::new(area.x, area.bottom().saturating_sub(height), area.width, height),
+                }],
+                height,
+            )
+        }
+        (Some((tree_height, tree_title)), Some((worktree_height, worktree_title))) => {
+            let tree_width = area.width / 2;
+            let worktree_width = area.width.saturating_sub(tree_width);
+            if tree_title <= usize::from(tree_width) && worktree_title <= usize::from(worktree_width) {
+                let tree_height = tree_height.min(max_height);
+                let worktree_height = worktree_height.min(max_height);
+                let height = tree_height.max(worktree_height);
+                (
+                    ChangesLayout::SideBySide,
+                    vec![
+                        ChangesPaneArea {
+                            pane: ChangePane::Tree,
+                            outer: Rect::new(
+                                area.x,
+                                area.bottom().saturating_sub(tree_height),
+                                tree_width,
+                                tree_height,
+                            ),
+                        },
+                        ChangesPaneArea {
+                            pane: ChangePane::Worktree,
+                            outer: Rect::new(
+                                area.x.saturating_add(tree_width),
+                                area.bottom().saturating_sub(worktree_height),
+                                worktree_width,
+                                worktree_height,
+                            ),
+                        },
+                    ],
+                    height,
+                )
+            } else {
+                let total = tree_height.saturating_add(worktree_height);
+                let (worktree_height, tree_height) = if total <= max_height {
+                    (worktree_height, tree_height)
+                } else {
+                    let half = max_height / 2;
+                    if worktree_height <= half {
+                        (worktree_height, max_height.saturating_sub(worktree_height))
+                    } else if tree_height <= half {
+                        (max_height.saturating_sub(tree_height), tree_height)
+                    } else {
+                        (half.saturating_add(max_height % 2), half)
+                    }
+                };
+                let height = worktree_height.saturating_add(tree_height);
+                let tree_y = area.bottom().saturating_sub(tree_height);
+                (
+                    ChangesLayout::Stacked,
+                    vec![
+                        ChangesPaneArea {
+                            pane: ChangePane::Worktree,
+                            outer: Rect::new(
+                                area.x,
+                                tree_y.saturating_sub(worktree_height),
+                                area.width,
+                                worktree_height,
+                            ),
+                        },
+                        ChangesPaneArea {
+                            pane: ChangePane::Tree,
+                            outer: Rect::new(area.x, tree_y, area.width, tree_height),
+                        },
+                    ],
+                    height,
+                )
+            }
+        }
+    }
+}
+
 pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset: usize, horizontal_offset: usize) {
     let [header, body, footer] =
         Layout::vertical([Constraint::Length(1), Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
@@ -59,13 +166,26 @@ pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset:
     );
 }
 
+#[cfg(test)]
 pub(crate) fn draw(
     frame: &mut Frame<'_>,
     app: &mut App,
     decorations: &Decorations,
     mailmap: &gix::mailmap::Snapshot,
     commit_message: Option<&BStr>,
-    changes: Option<&Changes>,
+    tree_changes: Option<&Changes>,
+) {
+    draw_with_worktree(frame, app, decorations, mailmap, commit_message, tree_changes, None);
+}
+
+pub(crate) fn draw_with_worktree(
+    frame: &mut Frame<'_>,
+    app: &mut App,
+    decorations: &Decorations,
+    mailmap: &gix::mailmap::Snapshot,
+    commit_message: Option<&BStr>,
+    tree_changes: Option<&Changes>,
+    worktree_changes: Option<&Changes>,
 ) {
     let [top_spacer, mut body, bottom_spacer, footer] = Layout::vertical([
         Constraint::Length(u16::from(app.inline)),
@@ -78,26 +198,44 @@ pub(crate) fn draw(
     frame.render_widget(Clear, bottom_spacer);
     let full_body = body;
     let compared_parent = if app.changes_visible() {
-        changes.and_then(|changes| changes.parent.map(|parent| parent.id))
+        tree_changes.and_then(|changes| changes.parent.map(|parent| parent.id))
     } else {
         None
     };
-    let changes_pane = app.changes_visible().then(|| {
-        let desired_height = changes.filter(|changes| changes.is_visible()).map_or(0, |changes| {
-            u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(3)
-        });
-        let max_height = frame.area().height / 2;
-        let height = desired_height.min(max_height);
-        let [commits, changes] = Layout::vertical([Constraint::Min(0), Constraint::Length(height)]).areas(full_body);
-        body = commits;
-        (
-            changes,
-            changes.inner(Margin {
-                horizontal: 2,
-                vertical: 1,
-            }),
-        )
-    });
+    let tree_visible = app.changes_visible() && tree_changes.is_some_and(Changes::is_visible);
+    let worktree_visible =
+        app.changes_visible() && app.changes_mode == Some(ChangesMode::Both) && worktree_changes.is_some();
+    let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
+    let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
+    let pane_height = |changes: &Changes| u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(2);
+    let (changes_layout, changes_panes, _) = changes_pane_areas(
+        full_body,
+        frame.area().height / 2,
+        tree_visible.then(|| {
+            (
+                pane_height(tree_changes.expect("visible tree changes exist")),
+                tree_summary.as_ref().map_or(0, Line::width),
+            )
+        }),
+        worktree_visible.then(|| {
+            (
+                pane_height(worktree_changes.expect("visible worktree changes exist")),
+                worktree_summary.as_ref().map_or(0, Line::width),
+            )
+        }),
+    );
+    if app.changes_visible() {
+        app.set_changes_layout(
+            changes_layout,
+            changes_panes
+                .iter()
+                .any(|pane| pane.pane == ChangePane::Tree && pane.outer.height > 0),
+            changes_panes
+                .iter()
+                .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0)
+                && worktree_changes.is_some_and(Changes::is_visible),
+        );
+    }
     let commit_pane = app.show_commit.then(|| {
         let width = 80.min(full_body.width / 2);
         let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
@@ -110,17 +248,21 @@ pub(crate) fn draw(
             }),
         )
     });
-    app.viewport_rows = body.height as usize;
+    app.viewport_rows = changes_panes
+        .iter()
+        .map(|pane| pane.outer.y.saturating_sub(body.y))
+        .min()
+        .unwrap_or(body.height)
+        .max(1) as usize;
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
-    let end = start.saturating_add(app.viewport_rows).min(app.rows.len());
-    let lane_end = start.saturating_add(full_body.height as usize).min(app.rows.len());
-    let visible_rows = &app.rows[start..end];
+    let render_end = start.saturating_add(body.height as usize).min(app.rows.len());
+    let visible_rows = &app.rows[start..render_end];
     let has_verifiable_signatures = visible_rows.iter().enumerate().any(|(index, row)| {
         !app.is_row_hidden(start + index)
             && matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying)
     });
-    let lanes = app.render_lanes(start..lane_end);
+    let lanes = app.render_lanes(start..render_end);
     let content = Rect::new(
         body.x.saturating_add(2),
         body.y,
@@ -200,7 +342,7 @@ pub(crate) fn draw(
     let graph_offset = horizontal_offset.min(graph_max_offset);
     let selection_info = selection_info_line(
         app.changes_visible()
-            .then_some(changes)
+            .then_some(tree_changes)
             .flatten()
             .filter(|changes| changes.is_visible()),
         app.selection_relation,
@@ -342,51 +484,79 @@ pub(crate) fn draw(
         }
     }
     app.set_horizontal_bounds(content.width as usize, max_offset);
-    if let Some((outer, area)) = changes_pane {
+    if app.changes_focus.is_some() {
+        frame
+            .buffer_mut()
+            .set_style(body, Style::default().add_modifier(Modifier::DIM));
+        if let Some(area) = selection_info_area {
+            frame.render_widget(Paragraph::new(selection_info), area);
+        }
+    }
+    for pane_area in &changes_panes {
+        let outer = pane_area.outer;
+        let pane = pane_area.pane;
+        let changes = match pane {
+            ChangePane::Tree => tree_changes.expect("visible tree changes exist"),
+            ChangePane::Worktree => worktree_changes.expect("visible worktree changes exist"),
+        };
+        let summary = match pane {
+            ChangePane::Tree => tree_summary.clone().expect("visible tree summary exists"),
+            ChangePane::Worktree => worktree_summary.clone().expect("visible worktree summary exists"),
+        };
+        let area = outer.inner(Margin {
+            horizontal: 2,
+            vertical: 1,
+        });
         frame.render_widget(Clear, outer);
-        frame.render_widget(Block::new().borders(Borders::TOP), outer);
-        if let Some(changes) = changes.filter(|changes| changes.is_visible()) {
-            render_changes(frame, area, changes, app);
-            if app.changes_focused {
-                let status = Rect::new(
-                    outer.x.saturating_add(2),
-                    outer.bottom().saturating_sub(1),
-                    outer.width.saturating_sub(4),
-                    1,
-                );
-                let mut spans = Vec::new();
-                if let Some(parent) = changes.parent {
-                    spans.extend([
-                        Span::styled(
-                            format!(
-                                "vs parent {}/{} {}",
-                                parent.index + 1,
-                                parent.total,
-                                parent.id.to_hex_with_len(7)
-                            ),
-                            color(COMPARED_PARENT_COLOR),
+        frame.render_widget(Block::new().borders(Borders::TOP).title(summary), outer);
+        render_changes(frame, area, changes, pane, app);
+        if app.changes_focus == Some(pane) {
+            let status = Rect::new(
+                outer.x.saturating_add(2),
+                outer.bottom().saturating_sub(1),
+                outer.width.saturating_sub(4),
+                1,
+            );
+            let mut spans = Vec::new();
+            if pane == ChangePane::Tree
+                && let Some(parent) = changes.parent
+            {
+                spans.extend([
+                    Span::styled(
+                        format!(
+                            "vs parent {}/{} {}",
+                            parent.index + 1,
+                            parent.total,
+                            parent.id.to_hex_with_len(7)
                         ),
-                        Span::raw(" · p next parent · "),
-                    ]);
-                }
-                if let Some(error) = &app.diff_error {
-                    spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
-                } else {
-                    spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
-                }
-                spans.push(Span::raw(" · c to hide"));
-                frame.render_widget(
-                    Paragraph::new(Line::from(spans)).style(Style::default().bg(PANE_STATUS_BACKGROUND)),
-                    status,
-                );
+                        color(COMPARED_PARENT_COLOR),
+                    ),
+                    Span::raw(" · p next parent · "),
+                ]);
             }
-        }
-        if !app.changes_focused {
+            if let Some(error) = &app.changes(pane).error {
+                spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
+            } else {
+                spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
+            }
+            spans.push(Span::raw(match app.changes_mode {
+                Some(ChangesMode::Both) => " · c tree",
+                Some(ChangesMode::Tree) => " · c to hide",
+                None => "",
+            }));
+            frame.render_widget(
+                Paragraph::new(Line::from(spans)).style(Style::default().bg(PANE_STATUS_BACKGROUND)),
+                status,
+            );
+        } else {
             frame
                 .buffer_mut()
                 .set_style(outer, Style::default().add_modifier(Modifier::DIM));
         }
     }
+    if changes_layout == ChangesLayout::SideBySide {
+        render_changes_divider(frame, &changes_panes, app);
+    }
     if let Some((outer, area)) = commit_pane {
         frame.render_widget(Clear, outer);
         let max_offset = if let Some(message) = commit_message {
@@ -425,18 +595,18 @@ pub(crate) fn draw(
         "{} commits{status} · ↑↓/jk move · h/l pan",
         app.rows.len()
     ))];
-    if app.changes_visible() && changes.is_some_and(Changes::is_visible) {
+    if app.tree_changes_visible || app.worktree_changes_visible {
         footer_spans.push(match app.focus_feedback.take() {
             Some(destination) => Span::raw(format!(" · Tab → {destination}")),
             None => Span::raw(" · Tab switch"),
         });
     }
-    if app.changes_focused {
+    if app.changes_focus.is_some() {
         footer_spans.push(Span::raw(" · q/Esc history"));
     }
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
     footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
-    footer_spans.extend([Span::raw(" · "), toggle("c changes", app.show_changes)]);
+    footer_spans.extend([Span::raw(" · "), toggle("c changes", app.changes_mode.is_some())]);
     if app.has_hidden_filter {
         footer_spans.extend([
             Span::raw(" · "),
@@ -493,20 +663,41 @@ pub(crate) fn draw(
             Span::styled("●", color(Color::Green)),
         ]);
     }
-    if !app.changes_focused {
+    if app.changes_focus.is_none() {
         if app.state == State::Loading {
             footer_spans.push(Span::raw(" · Esc cancel"));
         }
         footer_spans.push(Span::raw(" · q quit"));
     }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
-    if app.changes_focused {
-        frame
-            .buffer_mut()
-            .set_style(body, Style::default().add_modifier(Modifier::DIM));
-        if let Some(area) = selection_info_area {
-            frame.render_widget(Paragraph::new(selection_info), area);
-        }
+}
+
+fn render_changes_divider(frame: &mut Frame<'_>, panes: &[ChangesPaneArea], app: &App) {
+    let Some(tree) = panes.iter().find(|pane| pane.pane == ChangePane::Tree) else {
+        return;
+    };
+    let Some(worktree) = panes.iter().find(|pane| pane.pane == ChangePane::Worktree) else {
+        return;
+    };
+    let x = worktree.outer.x;
+    let top = tree.outer.y.min(worktree.outer.y);
+    let bottom = tree.outer.bottom().max(worktree.outer.bottom());
+    let style = if app.changes_focus.is_none() {
+        Style::default().add_modifier(Modifier::DIM)
+    } else {
+        Style::default()
+    };
+    for y in top..bottom {
+        let symbol = if tree.outer.y == worktree.outer.y && y == tree.outer.y {
+            "┬"
+        } else if y == tree.outer.y {
+            if tree.outer.y < worktree.outer.y { "┐" } else { "┤" }
+        } else if y == worktree.outer.y {
+            if worktree.outer.y < tree.outer.y { "┌" } else { "├" }
+        } else {
+            "│"
+        };
+        frame.buffer_mut()[(x, y)].set_symbol(symbol).set_style(style);
     }
 }
 
@@ -560,47 +751,14 @@ fn push_selection_span(spans: &mut Vec<Span<'static>>, span: Span<'static>) {
     spans.push(span);
 }
 
-fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, app: &mut App) {
-    if !changes.is_visible() || area.height == 0 {
-        app.set_changes_bounds(0, 0, area.width as usize, 0);
+fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, pane: ChangePane, app: &mut App) {
+    if area.height == 0 {
+        app.set_changes_bounds(pane, 0, 0, area.width as usize, 0);
         return;
     }
-    let mut summary = Vec::new();
-    for kind in [
-        ChangeKind::Added,
-        ChangeKind::Modified,
-        ChangeKind::Deleted,
-        ChangeKind::Renamed,
-        ChangeKind::Copied,
-        ChangeKind::TypeChanged,
-    ] {
-        let count = changes.paths.iter().filter(|change| change.kind == kind).count();
-        if count == 0 {
-            continue;
-        }
-        if !summary.is_empty() {
-            summary.push(Span::raw("  "));
-        }
-        summary.push(Span::styled(
-            format!("{} = {count}", kind.letter()),
-            color(change_color(kind)),
-        ));
-    }
-    if !summary.is_empty() {
-        summary.push(Span::raw(" · "));
-    }
-    summary.extend([
-        Span::raw(format!("{} files changed · ", changes.paths.len())),
-        Span::styled(format!("+{}", changes.lines_added), color(Color::Green)),
-        Span::raw(" "),
-        Span::styled(format!("-{}", changes.lines_removed), color(Color::Red)),
-    ]);
-    frame.render_widget(
-        Paragraph::new(Line::from(summary)),
-        Rect::new(area.x, area.y, area.width, 1),
-    );
-
-    let path_capacity = usize::from(area.height.saturating_sub(1));
+    let focused = app.changes_focus == Some(pane);
+    let selected_index = app.changes(pane).selected.min(changes.paths.len().saturating_sub(1));
+    let path_capacity = usize::from(area.height);
     let overflow = changes.paths.len() > 1 && changes.paths.len() > path_capacity;
     let visible_paths = if overflow {
         path_capacity.saturating_sub(1)
@@ -612,14 +770,14 @@ fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, app: &mu
         .iter()
         .enumerate()
         .map(|(index, change)| {
-            let selected = app.changes_focused && index == app.changes_selected;
+            let selected = focused && index == selected_index;
             let path_style = if selected {
                 Style::default().add_modifier(Modifier::REVERSED)
             } else {
                 Style::default()
             };
             let mut spans = vec![
-                Span::styled(change.kind.letter().to_string(), color(change_color(change.kind))),
+                Span::styled(change.kind.letter().to_string(), color(path_change_color(change))),
                 Span::raw(" "),
             ];
             if let Some(source) = &change.source {
@@ -648,28 +806,29 @@ fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, app: &mu
         .max()
         .unwrap_or_default()
         .saturating_sub(area.width as usize);
-    app.set_changes_bounds(visible_paths, changes.paths.len(), area.width as usize, horizontal_max);
+    app.set_changes_bounds(
+        pane,
+        visible_paths,
+        changes.paths.len(),
+        area.width as usize,
+        horizontal_max,
+    );
+    let offset = app.changes(pane).offset;
+    let horizontal_offset = app.changes(pane).horizontal_offset;
     let path_area = Rect::new(
         area.x,
-        area.y.saturating_add(1),
+        area.y,
         area.width,
         u16::try_from(visible_paths).unwrap_or(u16::MAX),
     );
     frame.render_widget(
         Paragraph::new(Text::from(
-            lines
-                .into_iter()
-                .skip(app.changes_offset)
-                .take(visible_paths)
-                .collect::<Vec<_>>(),
+            lines.into_iter().skip(offset).take(visible_paths).collect::<Vec<_>>(),
         ))
-        .scroll((0, u16::try_from(app.changes_horizontal_offset).unwrap_or(u16::MAX))),
+        .scroll((0, u16::try_from(horizontal_offset).unwrap_or(u16::MAX))),
         path_area,
     );
-    let hidden = changes
-        .paths
-        .len()
-        .saturating_sub(app.changes_offset.saturating_add(visible_paths));
+    let hidden = changes.paths.len().saturating_sub(offset.saturating_add(visible_paths));
     if overflow && hidden > 0 {
         frame.render_widget(
             Paragraph::new(Line::styled(
@@ -693,9 +852,98 @@ fn change_color(kind: ChangeKind) -> Color {
         ChangeKind::Deleted => Color::Red,
         ChangeKind::Renamed | ChangeKind::Copied => Color::Cyan,
         ChangeKind::TypeChanged => Color::Magenta,
+        ChangeKind::Unmerged => Color::Red,
     }
 }
 
+fn path_change_color(change: &crate::app::PathChange) -> Color {
+    match change.group {
+        ChangeGroup::Tree => change_color(change.kind),
+        ChangeGroup::Staged => Color::Green,
+        ChangeGroup::Unstaged => Color::Red,
+    }
+}
+
+fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'static> {
+    let mut spans = match pane {
+        ChangePane::Tree => {
+            let id = app
+                .selected
+                .and_then(|index| app.rows.get(index))
+                .map_or_else(|| "-------".into(), |row| row.id.to_hex_with_len(7).to_string());
+            vec![Span::raw(format!("─ Tree {id} ── "))]
+        }
+        ChangePane::Worktree => vec![Span::raw("─ Worktree ── ")],
+    };
+    if pane == ChangePane::Worktree && changes.paths.is_empty() {
+        spans.extend([
+            Span::styled("+0", color(Color::Green)),
+            Span::raw(" "),
+            Span::styled("-0", color(Color::Red)),
+            Span::raw(" "),
+        ]);
+        return Line::from(spans);
+    }
+    let counts: Vec<_> = match pane {
+        ChangePane::Tree => {
+            let mut counts = Vec::new();
+            for kind in [
+                ChangeKind::Added,
+                ChangeKind::Modified,
+                ChangeKind::Deleted,
+                ChangeKind::Renamed,
+                ChangeKind::Copied,
+                ChangeKind::TypeChanged,
+            ] {
+                let count = changes.paths.iter().filter(|change| change.kind == kind).count();
+                if count == 0 {
+                    continue;
+                }
+                counts.push((kind.letter().to_string(), count, change_color(kind)));
+            }
+            counts
+        }
+        ChangePane::Worktree => {
+            let staged = changes
+                .paths
+                .iter()
+                .filter(|change| change.group == ChangeGroup::Staged)
+                .count();
+            let unstaged = changes.paths.len().saturating_sub(staged);
+            [
+                ("S".to_owned(), staged, Color::Green),
+                ("U".to_owned(), unstaged, Color::Red),
+            ]
+            .into_iter()
+            .filter(|(_, count, _)| *count > 0)
+            .collect()
+        }
+    };
+    let has_counts = !counts.is_empty();
+    let show_total = counts.len() != 1 || counts[0].1 != changes.paths.len();
+    for (index, (label, count, count_color)) in counts.into_iter().enumerate() {
+        if index > 0 {
+            spans.push(Span::raw(" + "));
+        }
+        spans.push(Span::styled(format!("{label} {count}"), color(count_color)));
+    }
+    if show_total {
+        spans.push(Span::raw(format!(
+            "{}= {}",
+            if has_counts { " " } else { "" },
+            changes.paths.len()
+        )));
+    }
+    spans.extend([
+        Span::raw(" · "),
+        Span::styled(format!("+{}", changes.lines_added), color(Color::Green)),
+        Span::raw(" "),
+        Span::styled(format!("-{}", changes.lines_removed), color(Color::Red)),
+        Span::raw(" "),
+    ]);
+    Line::from(spans)
+}
+
 fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, notes: &[BString], offset: usize) -> usize {
     let parsed = gix::objs::commit::MessageRef::from_bytes(message);
     let mut body_message = BString::default();
@@ -1163,6 +1411,7 @@ mod tests {
         let changes = Changes {
             paths: vec![crate::app::PathChange {
                 kind: ChangeKind::Modified,
+                group: ChangeGroup::Tree,
                 source: None,
                 path: "file".into(),
                 lines: Some((3, 4)),
@@ -1171,7 +1420,7 @@ mod tests {
             lines_removed: 4,
             ..Changes::default()
         };
-        app.changes_focused = true;
+        app.changes_focus = Some(ChangePane::Tree);
         let mut terminal = Terminal::new(TestBackend::new(38, 7))?;
 
         terminal.draw(|frame| {
@@ -1895,70 +2144,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn changing_the_changes_height_keeps_history_alignment_stable() -> Result<(), Box<dyn std::error::Error>> {
-        let mut app = App::new(11);
-        app.extend_commits(
-            (1..=8)
-                .map(|n| Commit {
-                    id: gix::ObjectId::Sha1([n; 20]),
-                    parent_ids: Default::default(),
-                    committer_time: gix::date::Time::default(),
-                    author: author(b"author", b"author@example.com"),
-                    attributions: 0..0,
-                    title: format!("subject {n}").into(),
-                    metadata_loaded: true,
-                    has_agent_marker: false,
-                    signature: SignatureState::Unsigned,
-                })
-                .collect::<Vec<_>>(),
-        );
-        complete(&mut app);
-        app.set_lane(6, "●──────── ");
-        let path = crate::app::PathChange {
-            kind: ChangeKind::Modified,
-            source: None,
-            path: "path".into(),
-            lines: None,
-        };
-        let changes = |len| Changes {
-            paths: vec![path.clone(); len],
-            ..Changes::default()
-        };
-        let mut terminal = Terminal::new(TestBackend::new(80, 12))?;
-
-        terminal.draw(|frame| {
-            super::draw(
-                frame,
-                &mut app,
-                &Decorations::new(),
-                &gix::mailmap::Snapshot::default(),
-                None,
-                Some(&changes(1)),
-            );
-        })?;
-        let short = rendered_line(&terminal, 0)
-            .find("0101010")
-            .expect("metadata is visible with a short changes pane");
-
-        terminal.draw(|frame| {
-            super::draw(
-                frame,
-                &mut app,
-                &Decorations::new(),
-                &gix::mailmap::Snapshot::default(),
-                None,
-                Some(&changes(8)),
-            );
-        })?;
-        assert_eq!(
-            rendered_line(&terminal, 0).find("0101010"),
-            Some(short),
-            "changes pane height does not move aligned history metadata"
-        );
-        Ok(())
-    }
-
     #[test]
     fn pages_overflowing_commit_messages_and_hides_the_status_when_they_fit() -> Result<(), Box<dyn std::error::Error>>
     {
@@ -2038,6 +2223,87 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn changing_the_changes_height_keeps_history_alignment_stable() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(11);
+        app.extend_commits(
+            (1..=10)
+                .map(|n| Commit {
+                    id: gix::ObjectId::Sha1([n; 20]),
+                    parent_ids: Default::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: format!("subject {n}").into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.selected = Some(7);
+        app.ensure_visible();
+        let selection = app.selected;
+        app.set_lane(6, "●──────── ");
+        let path = crate::app::PathChange {
+            kind: ChangeKind::Modified,
+            group: ChangeGroup::Tree,
+            source: None,
+            path: "path".into(),
+            lines: None,
+        };
+        let changes = |len| Changes {
+            paths: vec![path.clone(); len],
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(80, 12))?;
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes(1)),
+            );
+        })?;
+        let short = rendered_line(&terminal, 0)
+            .find("0101010")
+            .expect("metadata is visible with a short changes pane");
+        assert_eq!((app.selected, app.offset), (selection, 0));
+
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes(8)),
+            );
+        })?;
+        assert_eq!(
+            rendered_line(&terminal, 0).find("0404040"),
+            Some(short),
+            "changes pane height does not move aligned history metadata"
+        );
+        assert_eq!(
+            (app.selected, app.offset),
+            (selection, 3),
+            "the selected commit stays immediately above the taller changes pane"
+        );
+
+        app.update(Action::MoveDown);
+        assert_eq!(
+            (app.selected, app.offset),
+            (Some(8), 4),
+            "moving down advances the commit and scrolls history at the pane boundary"
+        );
+        Ok(())
+    }
+
     #[test]
     fn shows_changed_paths_in_a_bottom_pane_below_the_summary() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(6);
@@ -2073,36 +2339,42 @@ mod tests {
             paths: vec![
                 crate::app::PathChange {
                     kind: ChangeKind::Added,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: "added".into(),
                     lines: Some((10, 0)),
                 },
                 crate::app::PathChange {
                     kind: ChangeKind::Modified,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: "modified".into(),
                     lines: Some((5, 2)),
                 },
                 crate::app::PathChange {
                     kind: ChangeKind::Deleted,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: "deleted".into(),
                     lines: Some((0, 7)),
                 },
                 crate::app::PathChange {
                     kind: ChangeKind::Renamed,
+                    group: ChangeGroup::Tree,
                     source: Some("old".into()),
                     path: "new".into(),
                     lines: Some((3, 3)),
                 },
                 crate::app::PathChange {
                     kind: ChangeKind::Copied,
+                    group: ChangeGroup::Tree,
                     source: Some("source".into()),
                     path: "copy".into(),
                     lines: Some((0, 0)),
                 },
                 crate::app::PathChange {
                     kind: ChangeKind::TypeChanged,
+                    group: ChangeGroup::Tree,
                     source: None,
                     path: format!("{}tail", "x".repeat(130)).into(),
                     lines: Some((24, 5)),
@@ -2126,12 +2398,12 @@ mod tests {
         })?;
 
         assert_eq!(
-            terminal.backend().buffer()[(20, 7)].symbol(),
+            terminal.backend().buffer()[(119, 7)].symbol(),
             "─",
             "the changes pane starts at the screen's halfway point"
         );
         assert!(
-            terminal.backend().buffer()[(20, 7)].modifier.contains(Modifier::DIM),
+            terminal.backend().buffer()[(119, 7)].modifier.contains(Modifier::DIM),
             "the inactive changes border is dimmed"
         );
         assert!(
@@ -2139,43 +2411,53 @@ mod tests {
                 && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
             "the focused history and its status use their normal intensity"
         );
-        let summary = rendered_line(&terminal, 8);
+        let summary = rendered_line(&terminal, 7);
+        assert_eq!(
+            terminal.backend().buffer()[(0, 7)].symbol(),
+            "─",
+            "the tree title border reaches the left edge"
+        );
         assert!(
-            summary.contains("A = 1  M = 1  D = 1  R = 1  C = 1  T = 1 · 6 files changed · +42 -17"),
-            "the pane starts with nonzero status and line aggregates"
+            summary.contains("Tree 0101010 ── A 1 + M 1 + D 1 + R 1 + C 1 + T 1 = 6 · +42 -17"),
+            "the top border contains the tree identity and aggregates"
         );
-        let added_x = summary.find("A = 1").expect("added aggregate is visible") as u16;
-        let deleted_x = summary.find("D = 1").expect("deleted aggregate is visible") as u16;
-        assert_eq!(terminal.backend().buffer()[(added_x, 8)].fg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(deleted_x, 8)].fg, Color::Red);
+        let position = |needle| {
+            summary[..summary.find(needle).expect("aggregate is visible")]
+                .chars()
+                .count() as u16
+        };
+        let added_x = position("A 1");
+        let deleted_x = position("D 1");
+        assert_eq!(terminal.backend().buffer()[(added_x, 7)].fg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(deleted_x, 7)].fg, Color::Red);
         assert!(
-            terminal.backend().buffer()[(added_x, 8)]
+            terminal.backend().buffer()[(added_x, 7)]
                 .modifier
                 .contains(Modifier::DIM),
             "the inactive summary is dimmed without losing its colors"
         );
         assert!(
-            rendered_line(&terminal, 9).contains("A added"),
-            "changed paths follow the summary in diff order"
+            rendered_line(&terminal, 8).contains("A added"),
+            "changed paths follow the summary border in diff order"
         );
-        let inactive_path = rendered_line(&terminal, 9);
+        let inactive_path = rendered_line(&terminal, 8);
         let inactive_x = inactive_path.find("A added").expect("changed path is visible") as u16;
         assert!(
-            terminal.backend().buffer()[(inactive_x, 9)]
+            terminal.backend().buffer()[(inactive_x, 8)]
                 .modifier
                 .contains(Modifier::DIM)
-                && terminal.backend().buffer()[(inactive_x + 2, 9)]
+                && terminal.backend().buffer()[(inactive_x + 2, 8)]
                     .modifier
                     .contains(Modifier::DIM),
             "the inactive change kind and path are dimmed"
         );
         assert!(
-            !rendered_line(&terminal, 9).contains("+10"),
+            !rendered_line(&terminal, 8).contains("+10"),
             "inactive panes do not display a path selection"
         );
         assert!(
-            rendered_line(&terminal, 13).contains("… 2 lines not shown"),
-            "the capped pane reports paths that do not fit"
+            rendered_line(&terminal, 13).contains("T "),
+            "reclaiming the summary row lets all paths fit"
         );
         assert!(
             !rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"),
@@ -2200,11 +2482,11 @@ mod tests {
             );
         })?;
         assert!(
-            !rendered_line(&terminal, 8).contains("files changed"),
+            !rendered_line(&terminal, 7).contains("files changed"),
             "repeated history navigation temporarily hides the changes pane"
         );
         assert!(
-            app.show_changes && !footer_is_dim(&terminal, "c changes"),
+            app.changes_mode.is_some() && !footer_is_dim(&terminal, "c changes"),
             "temporary suppression leaves the persistent changes setting enabled"
         );
         app.changes_suppressed = false;
@@ -2222,7 +2504,7 @@ mod tests {
             );
         })?;
         assert!(
-            !terminal.backend().buffer()[(20, 7)].modifier.contains(Modifier::DIM),
+            !terminal.backend().buffer()[(119, 7)].modifier.contains(Modifier::DIM),
             "the focused changes border uses its normal style"
         );
         assert!(
@@ -2239,7 +2521,7 @@ mod tests {
                 && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
             "the inactive history is dimmed without dimming the main status"
         );
-        assert!(rendered_line(&terminal, 15).contains("Tab → changes"));
+        assert!(rendered_line(&terminal, 15).contains("Tab → tree changes"));
         assert!(rendered_line(&terminal, 15).contains("q/Esc history"));
         terminal.draw(|frame| {
             super::draw(
@@ -2256,51 +2538,51 @@ mod tests {
             "focus feedback lasts for one redraw"
         );
         assert!(
-            !terminal.backend().buffer()[(added_x, 8)]
+            !terminal.backend().buffer()[(added_x, 7)]
                 .modifier
                 .contains(Modifier::DIM)
                 && !terminal.backend().buffer()[(2, 14)].modifier.contains(Modifier::DIM),
             "the focused summary and status use their normal intensity"
         );
-        let selected = rendered_line(&terminal, 10);
+        let selected = rendered_line(&terminal, 9);
         assert!(selected.contains("M modified +5 -2"));
         let path_x = selected.find("modified").expect("selected path is visible") as u16;
         let kind_x = selected.find("M modified").expect("selected kind is visible") as u16;
         let added_x = selected.find("+5").expect("selected additions are visible") as u16;
         let removed_x = selected.find("-2").expect("selected removals are visible") as u16;
         assert!(
-            !terminal.backend().buffer()[(kind_x, 10)]
+            !terminal.backend().buffer()[(kind_x, 9)]
                 .modifier
                 .contains(Modifier::DIM)
-                && !terminal.backend().buffer()[(path_x, 10)]
+                && !terminal.backend().buffer()[(path_x, 9)]
                     .modifier
                     .contains(Modifier::DIM),
             "focused paths use their normal intensity"
         );
         assert!(
-            terminal.backend().buffer()[(path_x, 10)]
+            terminal.backend().buffer()[(path_x, 9)]
                 .modifier
                 .contains(Modifier::REVERSED),
             "the selected filepath is inverted"
         );
-        assert_eq!(terminal.backend().buffer()[(added_x, 10)].fg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(removed_x, 10)].fg, Color::Red);
+        assert_eq!(terminal.backend().buffer()[(added_x, 9)].fg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(removed_x, 9)].fg, Color::Red);
         assert!(
-            !terminal.backend().buffer()[(added_x, 10)]
+            !terminal.backend().buffer()[(added_x, 9)]
                 .modifier
                 .contains(Modifier::REVERSED),
             "the diff-line suffix keeps its normal background"
         );
         assert!(
-            !rendered_line(&terminal, 9).contains("+10"),
+            !rendered_line(&terminal, 8).contains("+10"),
             "only the selected path displays its line counts"
         );
-        assert!(rendered_line(&terminal, 13).contains("… 2 lines not shown"));
+        assert!(rendered_line(&terminal, 13).contains("T "));
         assert!(rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"));
 
         assert!(
-            rendered_line(&terminal, 14).contains("Enter diff · c to hide"),
-            "the visible changes pane advertises how to hide it"
+            rendered_line(&terminal, 14).contains("Enter diff · c tree"),
+            "the changes pane advertises the next cycle mode"
         );
 
         app.update(Action::Last);
@@ -2315,9 +2597,9 @@ mod tests {
                 Some(&changes),
             );
         })?;
-        assert_eq!(app.changes_horizontal_offset, 20);
+        assert_eq!(app.tree_changes.horizontal_offset, 20);
         assert!(
-            rendered_line(&terminal, 12).contains("tail"),
+            rendered_line(&terminal, 13).contains("tail"),
             "h/l pans long path rows while the summary remains fixed"
         );
         assert!(
@@ -2337,8 +2619,8 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&short_terminal, 5).contains("… 1 line not shown"),
-            "the overflow count follows the selected final path when no path row fits"
+            !rendered_line(&short_terminal, 5).contains("not shown"),
+            "the overflow count disappears once the selected final path is visible"
         );
 
         let mut merge_changes = changes.clone();
@@ -2358,12 +2640,12 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 8).starts_with("  A = 1"),
-            "parent context no longer crowds the aggregate summary"
+            rendered_line(&terminal, 7).contains("Tree 0101010 ── A 1"),
+            "parent context no longer crowds the aggregate border"
         );
         assert!(
             rendered_line(&terminal, 14)
-                .contains("vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · c to hide"),
+                .contains("vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · c tree"),
             "merge diffs keep parent controls alongside navigation"
         );
         let parent = rendered_line(&terminal, 1);
@@ -2400,6 +2682,188 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn summarizes_staged_and_unstaged_changes_in_the_top_border() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.changes_mode = Some(ChangesMode::Both);
+        let changes = Changes {
+            paths: vec![
+                crate::app::PathChange {
+                    kind: ChangeKind::Added,
+                    group: ChangeGroup::Staged,
+                    source: None,
+                    path: "same".into(),
+                    lines: Some((1, 0)),
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Modified,
+                    group: ChangeGroup::Unstaged,
+                    source: None,
+                    path: "same".into(),
+                    lines: Some((2, 1)),
+                },
+            ],
+            lines_added: 3,
+            lines_removed: 1,
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&changes),
+            );
+        })?;
+
+        let (header_y, header) = (0..8)
+            .map(|y| (y, rendered_line(&terminal, y)))
+            .find(|(_, line)| line.contains("Worktree"))
+            .expect("the worktree border is visible");
+        assert!(
+            header.contains("Worktree ── S 1 + U 1 = 2 · +3 -1"),
+            "the border distinguishes staged and unstaged rows: {header:?}"
+        );
+        let staged_y = header_y + 1;
+        let unstaged_y = header_y + 2;
+        let staged_x = rendered_line(&terminal, staged_y).find('A').expect("staged letter") as u16;
+        let unstaged_x = rendered_line(&terminal, unstaged_y).find('M').expect("unstaged letter") as u16;
+        assert_eq!(terminal.backend().buffer()[(staged_x, staged_y)].fg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(unstaged_x, unstaged_y)].fg, Color::Red);
+
+        let modified = Changes {
+            paths: (0..12)
+                .map(|index| crate::app::PathChange {
+                    kind: ChangeKind::Modified,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: format!("file-{index}").into(),
+                    lines: Some((0, 0)),
+                })
+                .collect(),
+            ..Changes::default()
+        };
+        let summary = changes_summary(ChangePane::Tree, &app, &modified)
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+        assert!(summary.contains("M 12 · +0 -0"));
+        assert!(!summary.contains("= 12"), "a single term already expresses the total");
+
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&Changes::default()),
+            );
+        })?;
+        assert!(
+            (0..8).any(|y| rendered_line(&terminal, y).contains("Worktree ── +0 -0")),
+            "an enabled clean worktree remains visible as an empty block"
+        );
+        assert!(
+            !(0..8).any(|y| rendered_line(&terminal, y).contains("= 0")),
+            "a clean worktree has no empty aggregate"
+        );
+        assert!(!app.worktree_changes_visible, "an empty block is not focusable");
+        Ok(())
+    }
+
+    #[test]
+    fn lays_out_tree_and_worktree_changes_by_available_width() -> Result<(), Box<dyn std::error::Error>> {
+        let (layout, panes, height) = changes_pane_areas(Rect::new(0, 0, 120, 20), 10, Some((5, 30)), Some((3, 25)));
+        assert_eq!(layout, ChangesLayout::SideBySide);
+        assert_eq!(height, 5);
+        assert_eq!(panes[0].outer, Rect::new(0, 15, 60, 5));
+        assert_eq!(panes[1].outer, Rect::new(60, 17, 60, 3));
+
+        let (layout, panes, height) = changes_pane_areas(Rect::new(0, 0, 60, 20), 10, Some((8, 31)), Some((3, 31)));
+        assert_eq!(layout, ChangesLayout::Stacked);
+        assert_eq!(height, 10);
+        assert_eq!(
+            panes[0],
+            ChangesPaneArea {
+                pane: ChangePane::Worktree,
+                outer: Rect::new(0, 10, 60, 3),
+            }
+        );
+        assert_eq!(
+            panes[1],
+            ChangesPaneArea {
+                pane: ChangePane::Tree,
+                outer: Rect::new(0, 13, 60, 7),
+            }
+        );
+
+        let (_, panes, height) = changes_pane_areas(Rect::new(0, 0, 120, 20), 10, None, Some((3, 25)));
+        assert_eq!(height, 3);
+        assert_eq!(panes[0].outer, Rect::new(0, 17, 120, 3));
+
+        let mut app = App::new(1);
+        app.changes_mode = Some(ChangesMode::Both);
+        let path = |group, path: &'static str| Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group,
+                source: None,
+                path: path.into(),
+                lines: Some((1, 1)),
+            }],
+            lines_added: 1,
+            lines_removed: 1,
+            ..Changes::default()
+        };
+        let mut tree = path(ChangeGroup::Tree, "tree-file");
+        tree.paths.push(crate::app::PathChange {
+            kind: ChangeKind::Added,
+            group: ChangeGroup::Tree,
+            source: None,
+            path: "tree-file-2".into(),
+            lines: Some((0, 0)),
+        });
+        let worktree = path(ChangeGroup::Staged, "worktree-file");
+        let mut terminal = Terminal::new(TestBackend::new(120, 10))?;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&tree),
+                Some(&worktree),
+            );
+        })?;
+        let halves = |row: String| {
+            let left = row.chars().take(60).collect::<String>();
+            let right = row.chars().skip(60).collect::<String>();
+            (left, right)
+        };
+        let (left, _) = halves(rendered_line(&terminal, 5));
+        assert!(left.contains("Tree"));
+        let (left, right) = halves(rendered_line(&terminal, 6));
+        assert!(left.contains("tree-file"));
+        assert!(right.contains("Worktree"));
+        let (left, right) = halves(rendered_line(&terminal, 7));
+        assert!(left.contains("tree-file-2"));
+        assert!(right.contains("worktree-file"));
+        let buffer = terminal.backend().buffer();
+        assert_eq!(buffer[(60, 5)].symbol(), "┐");
+        assert_eq!(buffer[(60, 6)].symbol(), "├");
+        assert_eq!(buffer[(60, 7)].symbol(), "│");
+        assert_eq!(buffer[(60, 8)].symbol(), "│");
+        Ok(())
+    }
+
     #[test]
     fn aligns_commit_trailers_and_wraps_only_in_the_value_column() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(40, 8))?;

From 5cd3bcaa85fc7fb058a1b5871e9bcb65cf1d80cc Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 5 Aug 2026 14:49:35 +0200
Subject: [PATCH 014/282] feat: navigate tix history with mouse scrolling

Capture terminal mouse input while tix is active and restore it across screen transitions and exit. Map vertical wheel and trackpad events to history movement and horizontal events to the existing pan actions.

Treat vertical scrolling over the history like repeated keyboard navigation: hide the changes blocks, retain the temporary fill repository, and restore both after the existing 75 ms idle window. Keep scrolling within a focused changes block visible, and ignore clicks, drags, and pointer movement.

Apply every scroll event faithfully while rate-limiting redraws to the existing frame interval. This lets fast wheel bursts drain from the terminal queue without rendering and refilling the selected view after every event.
---
 gix-tix/src/lib.rs | 71 +++++++++++++++++++++++++++++++++++++---------
 1 file changed, 57 insertions(+), 14 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 108cfb7ec77..6dbb25eb733 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -28,9 +28,9 @@ use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
     event::{
-        self, DisableFocusChange, EnableFocusChange, Event as TerminalEvent, KeyCode, KeyEvent, KeyEventKind,
-        KeyModifiers, KeyboardEnhancementFlags, ModifierKeyCode, PopKeyboardEnhancementFlags,
-        PushKeyboardEnhancementFlags,
+        self, DisableFocusChange, DisableMouseCapture, EnableFocusChange, EnableMouseCapture, Event as TerminalEvent,
+        KeyCode, KeyEvent, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags, ModifierKeyCode, MouseEventKind,
+        PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
     },
     execute,
     style::{Print, ResetColor},
@@ -416,7 +416,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
 }
 
 fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
-    execute!(backend, EnableFocusChange)?;
+    execute!(backend, EnableFocusChange, EnableMouseCapture)?;
     if enhanced_keyboard {
         execute!(
             backend,
@@ -434,7 +434,7 @@ fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keybo
     if enhanced_keyboard {
         execute!(backend, PopKeyboardEnhancementFlags)?;
     }
-    execute!(backend, DisableFocusChange)
+    execute!(backend, DisableMouseCapture, DisableFocusChange)
 }
 
 fn half_height(terminal_height: u16) -> u16 {
@@ -889,7 +889,8 @@ fn event_loop(
             enhanced_keyboard,
         )?;
         let streaming = matches!(app.state, State::Loading | State::Cancelling | State::Computing)
-            || verification_receiver.is_some();
+            || verification_receiver.is_some()
+            || repeat_deadline.is_some();
         if should_draw(dirty, streaming, last_draw.elapsed()) {
             draw(
                 terminal,
@@ -925,8 +926,19 @@ fn event_loop(
         let Some(terminal_event) = terminal_event else {
             continue;
         };
-        let key = match terminal_event {
-            TerminalEvent::Key(key) => key,
+        let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
+            TerminalEvent::Key(key) => {
+                let action = action(key);
+                let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
+                (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
+            }
+            TerminalEvent::Mouse(mouse) => {
+                let Some(action) = mouse_scroll_action(mouse.kind) else {
+                    continue;
+                };
+                let repeats_history = app.changes_focus.is_none() && repeats_viewport(&action);
+                (Some(action), repeats_history, true, true)
+            }
             TerminalEvent::FocusLost => {
                 focused = false;
                 app.changes_suppressed = false;
@@ -950,18 +962,18 @@ fn event_loop(
         if !focused {
             continue;
         }
-        let action = action(key);
-        let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
+        if repeats_history || throttles_draw {
+            repeat_deadline = Some(Instant::now() + REPEAT_IDLE);
+        }
         if repeats_history {
             fill_repository.retain = true;
-            repeat_deadline = Some(Instant::now() + REPEAT_IDLE);
-        } else if key.kind != KeyEventKind::Repeat {
+        } else if !is_repeat {
             fill_repository.retain = false;
             fill_repository.retained = None;
         }
         if repeats_history && app.changes_mode.is_some() {
             app.changes_suppressed = true;
-        } else if key.kind != KeyEventKind::Repeat && app.changes_suppressed {
+        } else if !is_repeat && app.changes_suppressed {
             app.changes_suppressed = false;
             repeat_deadline = None;
             dirty = true;
@@ -971,7 +983,7 @@ fn event_loop(
             continue;
         };
         dirty = true;
-        urgent = true;
+        urgent |= !throttles_draw;
         let previous_changes_mode = app.changes_mode;
         let toggles_changes = action == Action::ToggleChanges;
         let refreshes_worktree = action == Action::Refresh && app.changes_mode == Some(ChangesMode::Both);
@@ -2380,6 +2392,16 @@ fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>, changes_
     !changes_focused && kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
 }
 
+fn mouse_scroll_action(kind: MouseEventKind) -> Option<Action> {
+    match kind {
+        MouseEventKind::ScrollUp => Some(Action::MoveUp),
+        MouseEventKind::ScrollDown => Some(Action::MoveDown),
+        MouseEventKind::ScrollLeft => Some(Action::ScrollLeft),
+        MouseEventKind::ScrollRight => Some(Action::ScrollRight),
+        _ => None,
+    }
+}
+
 #[cfg(test)]
 fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::open::Error> {
     gix::open_opts(path.as_ref(), gix::open::Options::isolated())
@@ -3024,6 +3046,27 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn maps_continuous_mouse_scrolling_to_navigation() {
+        assert_eq!(mouse_scroll_action(MouseEventKind::ScrollUp), Some(Action::MoveUp));
+        assert_eq!(mouse_scroll_action(MouseEventKind::ScrollDown), Some(Action::MoveDown));
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::ScrollLeft),
+            Some(Action::ScrollLeft)
+        );
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::ScrollRight),
+            Some(Action::ScrollRight)
+        );
+        assert_eq!(mouse_scroll_action(MouseEventKind::Moved), None);
+        assert!(repeats_viewport(
+            &mouse_scroll_action(MouseEventKind::ScrollDown).expect("vertical scrolling has an action")
+        ));
+        assert!(!repeats_viewport(
+            &mouse_scroll_action(MouseEventKind::ScrollRight).expect("horizontal scrolling has an action")
+        ));
+    }
+
     #[test]
     fn prepares_a_reduced_selection_after_leaving_the_alternate_screen() {
         let mut app = App::new(1);

From efac1bb074a4652967bd80ef252b9fb9db6b9077 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 5 Aug 2026 15:15:49 +0200
Subject: [PATCH 015/282] feat: show the selected history row in tix

Keep the live commit count in the history status bar while traversal, cancellation, and lane computation are active. Once the completed graph is displayed, replace it with a reverse row number for the current selection.

Number displayed rows from the bottom so the oldest row is #1 and the top-most row is the total number of commits. Retain the commit count for empty histories where no row can be selected.
---
 gix-tix/src/ui.rs | 49 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 45 insertions(+), 4 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 08618812700..26b8d3793b1 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -592,8 +592,8 @@ pub(crate) fn draw_with_worktree(
         State::Cancelled => " · cancelled",
     };
     let mut footer_spans = vec![Span::raw(format!(
-        "{} commits{status} · ↑↓/jk move · h/l pan",
-        app.rows.len()
+        "{}{status} · ↑↓/jk move · h/l pan",
+        history_position(app)
     ))];
     if app.tree_changes_visible || app.worktree_changes_visible {
         footer_spans.push(match app.focus_feedback.take() {
@@ -672,6 +672,13 @@ pub(crate) fn draw_with_worktree(
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
 }
 
+fn history_position(app: &App) -> String {
+    match (app.state, app.selected) {
+        (State::Complete, Some(selected)) => format!("#{}", app.rows.len().saturating_sub(selected)),
+        _ => format!("{} commits", app.rows.len()),
+    }
+}
+
 fn render_changes_divider(frame: &mut Frame<'_>, panes: &[ChangesPaneArea], app: &App) {
     let Some(tree) = panes.iter().find(|pane| pane.pane == ChangePane::Tree) else {
         return;
@@ -1392,6 +1399,40 @@ mod tests {
         app.finish_lane_computation(rows, lanes, lane_time);
     }
 
+    #[test]
+    fn counts_commits_until_the_graph_is_complete_then_tracks_the_selected_row() {
+        let mut app = App::new(3);
+        app.extend_commits(
+            (1..=3)
+                .map(|byte| Commit {
+                    id: gix::ObjectId::Sha1([byte; 20]),
+                    parent_ids: Default::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: "subject".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        assert_eq!(history_position(&app), "3 commits");
+
+        let rows = app
+            .start_lane_computation()
+            .expect("a loading app starts lane computation");
+        assert_eq!(history_position(&app), "3 commits");
+        let (rows, lanes, lane_time) = crate::app::compute_lanes(rows);
+        app.finish_lane_computation(rows, lanes, lane_time);
+
+        assert_eq!(history_position(&app), "#3");
+        app.update(Action::MoveDown);
+        assert_eq!(history_position(&app), "#2");
+        app.update(Action::MoveDown);
+        assert_eq!(history_position(&app), "#1");
+    }
+
     #[test]
     fn renders_selection_info_beside_the_right_marker_without_dimming_it() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);
@@ -1742,7 +1783,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "1 commits · ↑↓/jk move · h/l pan · [ align · o commit · c changes · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
+        let footer_text = "#1 · ↑↓/jk move · h/l pan · [ align · o commit · c changes · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -1794,7 +1835,7 @@ mod tests {
             rendered_line(&inline_terminal, 2).trim().is_empty(),
             "inline mode separates the commits from the status line"
         );
-        assert!(rendered_line(&inline_terminal, 3).starts_with("1 commits"));
+        assert!(rendered_line(&inline_terminal, 3).starts_with("#1"));
         app.inline = false;
 
         let row = terminal.backend().buffer();

From 12ab5e9dc5c7863c48791ff8c840e04364cd4592 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 10 Aug 2026 14:04:25 +0200
Subject: [PATCH 016/282] fix: keep tix open after its worktree is removed

A deleted linked worktree invalidates the per-worktree Git directory watched by tix, even on systems where the process current directory still resolves. Normalize the common repository path lexically at startup so it no longer traverses the removable .git/worktrees/<name> directory.

Recover through the common repository both when a running view observes removal and when the worktree is already gone between repository discovery and the initial history metadata open. In the startup case, replace the stale traversal repository before any frame is retained, so the view starts directly from the common repository without attempting an animation from unavailable state.

Move into the common directory and reopen it with core.bare enabled, then restart reference watching there so history remains live. Drop worktree-derived state during runtime recovery and keep the changes view limited to tree changes. Temporary repositories and diff workers retain the bare mode, and the line-diff pool avoids creating worktree resources even when gix still retains an inferred main-worktree path internally.

Show successful recovery in the main status line until the next user action. If changing into or opening the common repository fails, restore the terminal and return the contextual error instead of silently quitting.
---
 gix-tix/src/app.rs |  35 +++++-
 gix-tix/src/lib.rs | 282 +++++++++++++++++++++++++++++++++++++++------
 gix-tix/src/ui.rs  |  12 ++
 3 files changed, 291 insertions(+), 38 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index df55b9edd68..c59c6950206 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -326,6 +326,7 @@ pub(crate) struct App {
     pub align_metadata: bool,
     pub show_commit: bool,
     pub changes_mode: Option<ChangesMode>,
+    worktree_changes_available: bool,
     pub(crate) changes_suppressed: bool,
     pub(crate) changes_focus: Option<ChangePane>,
     pub(crate) changes_layout: ChangesLayout,
@@ -345,6 +346,7 @@ pub(crate) struct App {
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
+    pub(crate) notice: Option<String>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
     horizontal_page: usize,
@@ -387,6 +389,7 @@ impl App {
             align_metadata: true,
             show_commit: false,
             changes_mode: Some(ChangesMode::Both),
+            worktree_changes_available: true,
             changes_suppressed: false,
             changes_focus: None,
             changes_layout: ChangesLayout::SideBySide,
@@ -406,6 +409,7 @@ impl App {
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
+            notice: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
             horizontal_page: 1,
@@ -568,6 +572,7 @@ impl App {
     }
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
+        self.notice = None;
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
@@ -677,7 +682,8 @@ impl App {
                 self.changes_mode = match self.changes_mode {
                     Some(ChangesMode::Both) => Some(ChangesMode::Tree),
                     Some(ChangesMode::Tree) => None,
-                    None => Some(ChangesMode::Both),
+                    None if self.worktree_changes_available => Some(ChangesMode::Both),
+                    None => Some(ChangesMode::Tree),
                 };
                 self.reset_changes_view();
                 self.changes_parent = 0;
@@ -987,6 +993,18 @@ impl App {
         self.focus_feedback = None;
     }
 
+    pub(crate) fn set_worktree_changes_available(&mut self, available: bool) {
+        self.worktree_changes_available = available;
+        if !available {
+            if self.changes_mode == Some(ChangesMode::Both) {
+                self.changes_mode = Some(ChangesMode::Tree);
+            }
+            if self.changes_focus == Some(ChangePane::Worktree) {
+                self.focus_history();
+            }
+        }
+    }
+
     pub(crate) fn changes_visible(&self) -> bool {
         self.changes_mode.is_some() && !self.changes_suppressed
     }
@@ -2184,6 +2202,21 @@ mod tests {
         assert_eq!(app.changes_mode, Some(ChangesMode::Both));
     }
 
+    #[test]
+    fn bare_repositories_cycle_only_tree_and_hidden_changes() {
+        let mut app = App::new(1);
+        app.changes_focus = Some(ChangePane::Worktree);
+
+        app.set_worktree_changes_available(false);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Tree));
+        assert_eq!(app.changes_focus, None, "a hidden worktree pane cannot retain focus");
+
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_mode, None);
+        app.update(Action::ToggleChanges);
+        assert_eq!(app.changes_mode, Some(ChangesMode::Tree));
+    }
+
     #[test]
     fn cycles_changes_focus_in_visual_order_and_keeps_navigation_independent() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 6dbb25eb733..659a0f647ec 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -52,8 +52,9 @@ const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 
-struct FillRepository<'a> {
-    path: &'a Path,
+struct FillRepository {
+    path: PathBuf,
+    bare: bool,
     retained: Option<gix::Repository>,
     retain: bool,
 }
@@ -206,8 +207,8 @@ fn line_counts_for_change(
 }
 
 impl LineDiffPool {
-    fn new(repository_path: &Path, parallelism: usize) -> Result<Self> {
-        let repository = gix::open(repository_path)
+    fn new(repository_path: &Path, bare: bool, parallelism: usize) -> Result<Self> {
+        let repository = open_repository(repository_path, bare, false)
             .context("could not open repository for parallel line diffs")?
             .into_sync();
         let mut worker_state = Vec::with_capacity(parallelism);
@@ -217,8 +218,11 @@ impl LineDiffPool {
             let tree_cache = repository
                 .diff_resource_cache_for_tree_diff()
                 .context("could not initialize parallel line diffs")?;
-            let worktree_cache = worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)
-                .context("could not initialize parallel worktree line diffs")?;
+            let worktree_cache = if bare {
+                None
+            } else {
+                worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)?
+            };
             worker_state.push((repository, tree_cache, worktree_cache));
         }
 
@@ -299,10 +303,11 @@ fn sync_line_diff_pool(
     pool: &mut Option<LineDiffPool>,
     visible: bool,
     repository_path: &Path,
+    bare: bool,
     parallelism: usize,
 ) -> Result<()> {
     if visible && pool.is_none() {
-        *pool = Some(LineDiffPool::new(repository_path, parallelism.max(1))?);
+        *pool = Some(LineDiffPool::new(repository_path, bare, parallelism.max(1))?);
     } else if !visible {
         *pool = None;
     }
@@ -585,7 +590,7 @@ fn sync_screen(
 
 fn event_loop(
     terminal: &mut ratatui::DefaultTerminal,
-    repository: gix::ThreadSafeRepository,
+    mut repository: gix::ThreadSafeRepository,
     revisions: Vec<OsString>,
     options: Options,
     started_inline: bool,
@@ -596,18 +601,25 @@ fn event_loop(
         hide,
         screen,
     } = options;
-    let repository_path = repository.git_dir().to_owned();
-    let common_dir = repository.common_dir.clone().unwrap_or_else(|| repository_path.clone());
-    let mut view_repository = gix::open(&repository_path).context("could not open repository for history view")?;
+    let mut repository_path = repository.git_dir().to_owned();
+    let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
+    let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
+    let mut repository_is_bare = view_repository.workdir().is_none();
+    if recovered_at_startup {
+        repository = view_repository.into_sync();
+        repository_is_bare = true;
+        view_repository = open_repository(&repository_path, true, false)
+            .context("could not reopen common repository for history metadata")?;
+    }
     view_repository.object_cache_size(None);
-    let mailmap = view_repository.open_mailmap();
+    let mut mailmap = view_repository.open_mailmap();
     let mut notes = view_repository
         .notes()
         .map_err(gix::Exn::into_error)
         .context("could not open Git notes")?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
     let mut ref_snapshot = history::snapshot(&view_repository, &revisions, &hide)?;
-    let (mut ref_watcher, ref_events) = start_ref_watcher(&repository_path, &common_dir);
+    let (mut ref_watcher, mut ref_events) = start_ref_watcher(&repository_path, &common_dir);
     let (cancelled, receiver) = start_history(
         repository,
         &revisions,
@@ -616,6 +628,9 @@ fn event_loop(
     );
 
     let mut app = App::new(1);
+    if recovered_at_startup {
+        app.notice = Some("worktree removed; using the common repository without worktree changes".into());
+    }
     app.manual_refresh = ref_watcher.is_none();
     let mut lane_receiver = None;
     let mut refresh_receiver: Option<mpsc::Receiver<Result<history::Refresh>>> = None;
@@ -631,16 +646,19 @@ fn event_loop(
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
     let mut line_diff_pool = None;
     let mut fill_repository = FillRepository {
-        path: &repository_path,
+        path: repository_path.clone(),
+        bare: repository_is_bare,
         retained: None,
         retain: false,
     };
     configure_initial_screen(&mut app, started_inline);
+    app.set_worktree_changes_available(!repository_is_bare);
     app.configure_hidden_filter(!hide.is_empty());
     sync_line_diff_pool(
         &mut line_diff_pool,
         app.changes_mode.is_some(),
         &repository_path,
+        repository_is_bare,
         line_diff_parallelism,
     )?;
     let mut decorations = Decorations::new();
@@ -774,8 +792,46 @@ fn event_loop(
             && lane_receiver.is_none()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
-            let repository = gix::open_opts(&repository_path, gix::open::Options::isolated())
-                .context("could not inspect changed references")?;
+            let repository = match open_repository(&repository_path, repository_is_bare, true) {
+                Ok(repository) => repository,
+                Err(_err) if worktree_repository_is_gone(&repository_path) => {
+                    let mut recovered = recover_common_repository(&common_dir)
+                        .context("could not recover after the worktree repository disappeared")?;
+                    recovered.object_cache_size(None);
+                    repository_path.clone_from(&common_dir);
+                    repository_is_bare = true;
+                    mailmap = recovered.open_mailmap();
+                    notes = recovered
+                        .notes()
+                        .map_err(gix::Exn::into_error)
+                        .context("could not reopen Git notes after worktree removal")?;
+                    view_repository = recovered;
+                    fill_repository.path.clone_from(&repository_path);
+                    fill_repository.bare = true;
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    app.set_worktree_changes_available(false);
+                    worktree_watcher = None;
+                    worktree_refresh_deadline = None;
+                    worktree_changes = None;
+                    line_diff_pool = None;
+                    sync_line_diff_pool(
+                        &mut line_diff_pool,
+                        app.changes_mode.is_some(),
+                        &repository_path,
+                        true,
+                        line_diff_parallelism,
+                    )?;
+                    let (watcher, events) = start_ref_watcher(&repository_path, &repository_path);
+                    ref_watcher = watcher;
+                    ref_events = events;
+                    app.manual_refresh = ref_watcher.is_none();
+                    app.notice = Some("worktree removed; using the common repository without worktree changes".into());
+                    open_repository(&repository_path, true, true)
+                        .context("could not inspect common repository references")?
+                }
+                Err(err) => return Err(err).context("could not inspect changed references"),
+            };
             let next = history::snapshot(&repository, &revisions, &hide)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed;
@@ -790,6 +846,7 @@ fn event_loop(
                 };
                 refresh_receiver = Some(start_history_refresh(
                     repository_path.clone(),
+                    repository_is_bare,
                     revisions.clone(),
                     hidden,
                     app.known_ids(),
@@ -996,6 +1053,7 @@ fn event_loop(
                 &mut line_diff_pool,
                 app.changes_mode.is_some(),
                 &repository_path,
+                repository_is_bare,
                 line_diff_parallelism,
             )?;
             if app.changes_mode == Some(ChangesMode::Both) {
@@ -1022,7 +1080,7 @@ fn event_loop(
                 }
                 Effect::Reload(show_hidden) => {
                     app.show_hidden = show_hidden;
-                    notes = open_notes(&repository_path)?;
+                    notes = open_notes(&repository_path, repository_is_bare)?;
                     refresh_pending = true;
                     refresh_expand_hidden = true;
                 }
@@ -1034,7 +1092,9 @@ fn event_loop(
                     let result = changes
                         .and_then(|changes| changes.diffs.get(index).zip(changes.paths.get(index)))
                         .context("selected path no longer has diff resources")
-                        .and_then(|(change, path)| prepare_file_diff(&repository_path, change, path))
+                        .and_then(|(change, path)| {
+                            prepare_file_diff(&repository_path, repository_is_bare, change, path)
+                        })
                         .and_then(|diff| match diff {
                             FileDiff::External(command) => {
                                 run_external_diff(terminal, command, enhanced_keyboard).map(|()| false)
@@ -1051,7 +1111,11 @@ fn event_loop(
                     }
                 }
                 Effect::VerifySignatures(ids) => {
-                    verification_receiver = Some(start_signature_verification(repository_path.clone(), ids));
+                    verification_receiver = Some(start_signature_verification(
+                        repository_path.clone(),
+                        repository_is_bare,
+                        ids,
+                    ));
                 }
                 Effect::Quit => return Ok(None),
             }
@@ -1070,11 +1134,17 @@ fn event_loop(
     let restore = inline_terminal
         .map(|inline| leave_alternate_screen(terminal, inline, enhanced_keyboard))
         .transpose();
-    let outcome = result?;
     restore.context("could not restore the inline terminal")?;
+    let outcome = result?;
     if outcome.is_none() && started_inline {
         prepare_inline_exit(&mut app);
-        sync_line_diff_pool(&mut line_diff_pool, false, &repository_path, line_diff_parallelism)?;
+        sync_line_diff_pool(
+            &mut line_diff_pool,
+            false,
+            &repository_path,
+            repository_is_bare,
+            line_diff_parallelism,
+        )?;
         draw(
             terminal,
             &mut app,
@@ -1115,11 +1185,12 @@ type SignatureVerification = (gix::ObjectId, bool);
 
 fn start_signature_verification(
     repository_path: PathBuf,
+    bare: bool,
     ids: Vec<gix::ObjectId>,
 ) -> mpsc::Receiver<Vec<SignatureVerification>> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
-        let results = match gix::open(repository_path) {
+        let results = match open_repository(&repository_path, bare, false) {
             Ok(mut repository) => {
                 repository.object_cache_size(None);
                 ids.into_iter()
@@ -1178,6 +1249,7 @@ fn start_history(
 
 fn start_history_refresh(
     repository_path: PathBuf,
+    bare: bool,
     revisions: Vec<OsString>,
     hidden_revisions: Vec<OsString>,
     known: std::collections::HashSet<gix::ObjectId>,
@@ -1186,7 +1258,7 @@ fn start_history_refresh(
 ) -> mpsc::Receiver<Result<history::Refresh>> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
-        let result = gix::open_opts(repository_path, gix::open::Options::isolated())
+        let result = open_repository(&repository_path, bare, true)
             .context("could not reopen repository for history refresh")
             .and_then(|mut repository| {
                 repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
@@ -1335,7 +1407,7 @@ fn draw(
     decorations: &Decorations,
     mailmap: &gix::mailmap::Snapshot,
     authors: &SharedAuthors,
-    fill_repository: &mut FillRepository<'_>,
+    fill_repository: &mut FillRepository,
     notes: &mut gix::note::Platform,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     tree_changes: &mut Option<(gix::ObjectId, usize, Changes)>,
@@ -1429,10 +1501,10 @@ fn draw(
         let repository = if fill_repository.retain {
             match &mut fill_repository.retained {
                 Some(repository) => repository,
-                slot @ None => slot.insert(open_fill_repository(fill_repository.path)?),
+                slot @ None => slot.insert(open_fill_repository(&fill_repository.path, fill_repository.bare)?),
             }
         } else {
-            one_shot_repository.insert(open_fill_repository(fill_repository.path)?)
+            one_shot_repository.insert(open_fill_repository(&fill_repository.path, fill_repository.bare)?)
         };
         for index in start..end {
             if app.rows[index].metadata_loaded {
@@ -1510,14 +1582,66 @@ fn draw(
     Ok(())
 }
 
-fn open_fill_repository(repository_path: &Path) -> Result<gix::Repository> {
-    let mut repository = gix::open(repository_path).context("could not open repository for history view")?;
+fn open_repository(repository_path: &Path, bare: bool, isolated: bool) -> Result<gix::Repository> {
+    let options = if isolated {
+        gix::open::Options::isolated()
+    } else {
+        gix::open::Options::default()
+    }
+    .open_path_as_is(bare);
+    let options = if bare {
+        options.cli_overrides(["core.bare=true"])
+    } else {
+        options
+    };
+    Ok(gix::open_opts(repository_path, options)?)
+}
+
+fn open_history_repository(repository_path: &mut PathBuf, common_dir: &Path) -> Result<(gix::Repository, bool)> {
+    match gix::open(&*repository_path) {
+        Ok(repository) => Ok((repository, false)),
+        Err(_err) if worktree_repository_is_gone(repository_path) => {
+            let repository = recover_common_repository(common_dir)
+                .context("could not recover before history traversal after the worktree repository disappeared")?;
+            common_dir.clone_into(repository_path);
+            Ok((repository, true))
+        }
+        Err(err) => Err(err).context("could not open repository for history view"),
+    }
+}
+
+fn recover_common_repository(common_dir: &Path) -> Result<gix::Repository> {
+    std::env::set_current_dir(common_dir).with_context(|| {
+        format!(
+            "could not change directory to common repository at {}",
+            common_dir.display()
+        )
+    })?;
+    open_repository(common_dir, true, false)
+        .with_context(|| format!("could not open common repository at {} as bare", common_dir.display()))
+}
+
+fn normalize_common_dir(common_dir: PathBuf) -> Result<PathBuf> {
+    let current_dir = std::env::current_dir().context("could not obtain current directory")?;
+    gix::path::normalize(common_dir.into(), &current_dir)
+        .map(Into::into)
+        .context("common repository path could not be normalized")
+}
+
+fn worktree_repository_is_gone(repository_path: &Path) -> bool {
+    !repository_path.is_dir() || std::env::current_dir().is_err()
+}
+
+fn open_fill_repository(repository_path: &Path, bare: bool) -> Result<gix::Repository> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository for history view")?;
     repository.object_cache_size(None);
     Ok(repository)
 }
 
-fn open_notes(repository_path: &Path) -> Result<gix::note::Platform> {
-    let mut repository = gix::open(repository_path).context("could not open repository for Git notes")?;
+fn open_notes(repository_path: &Path, bare: bool) -> Result<gix::note::Platform> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository for Git notes")?;
     repository.object_cache_size(None);
     repository
         .notes()
@@ -1525,8 +1649,9 @@ fn open_notes(repository_path: &Path) -> Result<gix::note::Platform> {
         .context("could not open Git notes")
 }
 
-fn prepare_file_diff(repository_path: &Path, change: &FileChange, path: &PathChange) -> Result<FileDiff> {
-    let mut repository = gix::open(repository_path).context("could not open repository for file diff")?;
+fn prepare_file_diff(repository_path: &Path, bare: bool, change: &FileChange, path: &PathChange) -> Result<FileDiff> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository for file diff")?;
     repository.object_cache_size(OBJECT_CACHE_SIZE);
     prepare_file_diff_with_repository(&repository, change, path)
 }
@@ -2513,15 +2638,15 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
         let repository = gix::open_opts(&fixture, gix::open::Options::isolated())?;
         let mut line_diff_pool = None;
-        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, 2)?;
+        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, false, 2)?;
         assert_eq!(
             line_diff_pool.as_ref().map(|pool| pool.workers.len()),
             Some(2),
             "showing changes creates the requested worker pool"
         );
-        sync_line_diff_pool(&mut line_diff_pool, false, &fixture, 2)?;
+        sync_line_diff_pool(&mut line_diff_pool, false, &fixture, false, 2)?;
         assert!(line_diff_pool.is_none(), "hiding changes destroys the worker pool");
-        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, 2)?;
+        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, false, 2)?;
         let line_diff_pool = line_diff_pool
             .as_mut()
             .expect("showing changes recreates the worker pool");
@@ -2680,6 +2805,89 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn configures_a_common_repository_as_bare_for_tree_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let git_dir = open_test_repository(&fixture)?.git_dir().to_owned();
+        let repository = open_repository(&git_dir, true, false)?;
+
+        assert_eq!(
+            repository.config_snapshot().boolean("core.bare"),
+            Some(true),
+            "repository configuration suppresses worktree operations"
+        );
+        assert!(
+            LineDiffPool::new(&git_dir, true, 1).is_ok(),
+            "tree changes remain available without a worktree"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn detects_a_removed_per_worktree_repository_even_if_the_current_directory_resolves() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        assert!(
+            std::env::current_dir().is_ok(),
+            "the process directory remains available"
+        );
+        let missing = fixture.join("missing-worktree-git-dir");
+        assert!(worktree_repository_is_gone(&missing));
+        let Err(err) = recover_common_repository(&missing) else {
+            panic!("a missing common repository cannot be recovered")
+        };
+        assert!(
+            format!("{err:#}").contains("could not change directory to common repository"),
+            "recovery failures retain actionable context"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn normalizes_a_common_directory_through_a_missing_per_worktree_directory() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let git_dir = open_test_repository(&fixture)?.git_dir().to_owned();
+        let indirect = git_dir.join("worktrees/missing/../..");
+        assert!(
+            !git_dir.join("worktrees/missing").exists(),
+            "the intermediate path is absent"
+        );
+        assert_eq!(normalize_common_dir(indirect)?, git_dir);
+        Ok(())
+    }
+
+    #[test]
+    fn opens_the_common_repository_when_the_initial_worktree_is_already_gone() -> gix_testtools::Result {
+        const COMMON_DIR: &str = "GIX_TIX_TEST_REMOVED_WORKTREE_COMMON_DIR";
+        if let Some(git_dir) = std::env::var_os(COMMON_DIR).map(PathBuf::from) {
+            let mut stale_git_dir = git_dir.join("worktrees/deleted");
+            let (repository, recovered) = open_history_repository(&mut stale_git_dir, &git_dir)?;
+
+            assert!(
+                recovered,
+                "a missing per-worktree repository uses the common repository"
+            );
+            assert_eq!(stale_git_dir, git_dir, "future opens use the surviving repository");
+            assert_eq!(
+                repository.config_snapshot().boolean("core.bare"),
+                Some(true),
+                "recovery configures the common repository as bare"
+            );
+            return Ok(());
+        }
+
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let git_dir = open_test_repository(&fixture)?.git_dir().canonicalize()?;
+        let status = Command::new(std::env::current_exe()?)
+            .env(COMMON_DIR, git_dir)
+            .args([
+                "--exact",
+                "tests::opens_the_common_repository_when_the_initial_worktree_is_already_gone",
+            ])
+            .status()?;
+        assert!(status.success(), "the isolated recovery process completes successfully");
+        Ok(())
+    }
+
     #[test]
     fn loads_staged_and_unstaged_worktree_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -2711,8 +2919,8 @@ mod tests {
         std::fs::write(path.join(".git/info/exclude"), "ignored\n")?;
         std::fs::write(path.join("ignored"), "ignored\n")?;
 
-        let repository = gix::open(path)?;
-        let mut line_diff_pool = LineDiffPool::new(path, 2)?;
+        let repository = open_test_repository(path)?;
+        let mut line_diff_pool = LineDiffPool::new(path, false, 2)?;
         let changes = load_worktree_changes(&repository, &mut line_diff_pool)?;
         let rows: Vec<_> = changes
             .paths
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 26b8d3793b1..f7ae0822533 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -669,6 +669,9 @@ pub(crate) fn draw_with_worktree(
         }
         footer_spans.push(Span::raw(" · q quit"));
     }
+    if let Some(notice) = &app.notice {
+        footer_spans = vec![Span::raw(notice)];
+    }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
 }
 
@@ -1853,7 +1856,16 @@ mod tests {
             "completed work cannot be cancelled"
         );
 
+        app.notice = Some("worktree removed; using common repository".into());
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
+        assert_eq!(
+            rendered_line(&terminal, 1).trim(),
+            "worktree removed; using common repository",
+            "recovery information replaces the status until the next action"
+        );
+
         app.update(Action::ToggleMailmap);
+        assert!(app.notice.is_none(), "the next action restores the normal status");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains(" author subject"),

From fc26cee6dd82c32aedcd081d9904f2359ad033b0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 6 Aug 2026 07:00:32 +0200
Subject: [PATCH 017/282] feat: coordinate tix overlay pane layout

Lay out the commit message and change blocks within a shared overlay region so
they no longer paint over each other. Reserve the commit message width first
and let tree and worktree changes adapt within the remaining space.

Delineate the commit message with a left border and move its title onto the
first pane row while retaining its padding and scrolling status.
---
 gix-tix/src/ui.rs | 90 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 68 insertions(+), 22 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index f7ae0822533..fc4b4a6f88d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -207,9 +207,20 @@ pub(crate) fn draw_with_worktree(
         app.changes_visible() && app.changes_mode == Some(ChangesMode::Both) && worktree_changes.is_some();
     let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
     let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
+    let commit_pane = app.show_commit.then(|| {
+        let width = 80.min(full_body.width / 2);
+        let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
+        body.width = body.width.min(commits.width);
+        let mut content = message.inner(Margin {
+            horizontal: 2,
+            vertical: 0,
+        });
+        content.height = content.height.saturating_sub(1);
+        (message, content)
+    });
     let pane_height = |changes: &Changes| u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(2);
     let (changes_layout, changes_panes, _) = changes_pane_areas(
-        full_body,
+        body,
         frame.area().height / 2,
         tree_visible.then(|| {
             (
@@ -236,18 +247,6 @@ pub(crate) fn draw_with_worktree(
                 && worktree_changes.is_some_and(Changes::is_visible),
         );
     }
-    let commit_pane = app.show_commit.then(|| {
-        let width = 80.min(full_body.width / 2);
-        let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
-        body.width = body.width.min(commits.width);
-        (
-            message,
-            message.inner(Margin {
-                horizontal: 2,
-                vertical: 1,
-            }),
-        )
-    });
     app.viewport_rows = changes_panes
         .iter()
         .map(|pane| pane.outer.y.saturating_sub(body.y))
@@ -559,6 +558,7 @@ pub(crate) fn draw_with_worktree(
     }
     if let Some((outer, area)) = commit_pane {
         frame.render_widget(Clear, outer);
+        frame.render_widget(Block::new().borders(Borders::LEFT), outer);
         let max_offset = if let Some(message) = commit_message {
             let notes = app
                 .selected
@@ -2155,14 +2155,19 @@ mod tests {
             );
         })?;
         assert_eq!(
-            terminal.backend().buffer()[(62, 1)].symbol(),
+            terminal.backend().buffer()[(62, 0)].symbol(),
             "s",
-            "the pane is capped at half width with two columns of horizontal margin"
+            "the title starts on the first pane row after two columns of horizontal margin"
         );
         assert_eq!(
-            terminal.backend().buffer()[(62, 3)].symbol(),
+            terminal.backend().buffer()[(60, 0)].symbol(),
+            "│",
+            "the pane has a left border"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(62, 2)].symbol(),
             "b",
-            "vertical margin leaves the full commit body intact"
+            "the commit body remains separated from its title"
         );
         assert!(
             !footer_is_dim(&terminal, "o commit"),
@@ -2190,7 +2195,7 @@ mod tests {
             );
         })?;
         assert_eq!(
-            wide_terminal.backend().buffer()[(122, 1)].symbol(),
+            wide_terminal.backend().buffer()[(122, 0)].symbol(),
             "s",
             "the pane remains eighty columns wide on a wide screen"
         );
@@ -2717,21 +2722,62 @@ mod tests {
         );
 
         app.update(Action::ToggleCommit);
+        let worktree_changes = Changes::default();
         terminal.draw(|frame| {
-            super::draw(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
                 &gix::mailmap::Snapshot::default(),
                 Some(b"subject".as_bstr()),
                 Some(&changes),
+                Some(&worktree_changes),
             );
         })?;
         assert_eq!(
-            terminal.backend().buffer()[(62, 7)].symbol(),
-            " ",
-            "the right commit pane is rendered over the bottom changes pane"
+            app.changes_layout,
+            ChangesLayout::Stacked,
+            "both change blocks adapt to the width left by the commit pane"
+        );
+        assert!(
+            rendered_line(&terminal, 7)
+                .chars()
+                .take(60)
+                .collect::<String>()
+                .contains("Worktree")
+        );
+        assert!(
+            rendered_line(&terminal, 9)
+                .chars()
+                .take(60)
+                .collect::<String>()
+                .contains("Tree")
+        );
+        assert_eq!(terminal.backend().buffer()[(60, 7)].symbol(), "│");
+        assert_eq!(
+            app.viewport_rows, 7,
+            "history remains bounded above the highest overlay"
+        );
+        assert!(rendered_line(&terminal, 0).starts_with('>'));
+
+        let mut wide_terminal = Terminal::new(TestBackend::new(240, 16))?;
+        wide_terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(b"subject".as_bstr()),
+                Some(&changes),
+                Some(&worktree_changes),
+            );
+        })?;
+        assert_eq!(
+            app.changes_layout,
+            ChangesLayout::SideBySide,
+            "sufficient remaining width still permits side-by-side changes"
         );
+        assert_eq!(wide_terminal.backend().buffer()[(160, 7)].symbol(), "│");
         Ok(())
     }
 

From c8d9e61ab1e9b13bd32d5fe767ed09b25802026d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 6 Aug 2026 15:32:34 +0200
Subject: [PATCH 018/282] fix: select the newest tix row after watched refs
 change

Filesystem-driven reference updates can insert or replace traversal tips, so a
preserved selection may leave the refreshed view positioned in stale context.
Track the refresh origin through asynchronous traversal and lane computation,
then select the first selectable row only for watched-reference refreshes.
Manual and visibility reloads continue preserving their selection.
---
 gix-tix/src/app.rs | 39 +++++++++++++++++++++++++++++++++++----
 gix-tix/src/lib.rs | 19 +++++++++++++++++--
 2 files changed, 52 insertions(+), 6 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index c59c6950206..a6b0de357ba 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -353,6 +353,7 @@ pub(crate) struct App {
     horizontal_max: usize,
     follow_tail: bool,
     reload_selection: Option<ObjectId>,
+    select_top_after_refresh: bool,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
     pub(crate) manual_refresh: bool,
@@ -416,6 +417,7 @@ impl App {
             horizontal_max: 0,
             follow_tail: false,
             reload_selection: None,
+            select_top_after_refresh: false,
             signature_failures: 0,
             signature_verification_running: false,
             manual_refresh: false,
@@ -826,6 +828,7 @@ impl App {
         commits: LoadedCommits,
         view_tips: &[ObjectId],
         hidden_tips: &[ObjectId],
+        select_top: bool,
     ) -> Option<Vec<CommitRow>> {
         drop(self.store_commits(commits));
 
@@ -849,6 +852,7 @@ impl App {
             .filter_map(|id| self.all_rows.get(id).cloned())
             .collect();
         self.pending_hidden_rows = Some(boundary);
+        self.select_top_after_refresh = select_top;
         self.state = State::Computing;
         self.follow_tail = false;
         Some(rows)
@@ -872,7 +876,9 @@ impl App {
         if self.state != State::Computing {
             return;
         }
-        let selected = self.selected.map(|index| self.rows[index].id);
+        let selected = (!std::mem::take(&mut self.select_top_after_refresh))
+            .then(|| self.selected.map(|index| self.rows[index].id))
+            .flatten();
         let metadata: HashMap<_, _> = if rows.iter().any(|row| !row.metadata_loaded) {
             self.rows
                 .iter()
@@ -924,6 +930,7 @@ impl App {
     #[cfg(test)]
     pub(crate) fn reload(&mut self, show_hidden: bool) {
         self.reload_selection = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        self.select_top_after_refresh = false;
         self.rows = Vec::new();
         self.all_rows.clear();
         self.all_order.clear();
@@ -1717,7 +1724,7 @@ mod tests {
         complete(&mut app);
 
         let rows = app
-            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[])
+            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[], false)
             .expect("a refresh computes lanes");
         assert_eq!(
             app.rows.len(),
@@ -1730,16 +1737,21 @@ mod tests {
             app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
             [id(4), id(3), id(2), id(1)]
         );
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(3)),
+            "ordinary refreshes preserve the selected commit"
+        );
 
         let rows = app
-            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(2)], &[])
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(2)], &[], false)
             .expect("a rewind reprojects cached topology");
         let (rows, graph, time) = compute_lanes(rows);
         app.finish_lane_computation(rows, graph, time);
         assert_eq!(app.rows.iter().map(|row| row.id).collect::<Vec<_>>(), [id(2), id(1)]);
 
         let rows = app
-            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(4)], &[])
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(4)], &[], false)
             .expect("a fast-forward to retained commits needs no new objects");
         let (rows, graph, time) = compute_lanes(rows);
         app.finish_lane_computation(rows, graph, time);
@@ -1749,6 +1761,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn filesystem_refresh_selects_the_first_selectable_row() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        app.update(Action::MoveDown);
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[], true)
+            .expect("a filesystem refresh computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(app.selected, app.first_selectable());
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+    }
+
     #[test]
     fn counts_distinct_visible_ancestry_only_when_it_reaches_hidden_history() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 659a0f647ec..c332c6bcc46 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -635,6 +635,8 @@ fn event_loop(
     let mut lane_receiver = None;
     let mut refresh_receiver: Option<mpsc::Receiver<Result<history::Refresh>>> = None;
     let mut refresh_pending = false;
+    let mut refresh_from_filesystem = false;
+    let mut refresh_select_top = false;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
@@ -712,7 +714,13 @@ fn event_loop(
         }
         while let Ok(event) = ref_events.try_recv() {
             match event {
-                Ok(event) if !matches!(event.kind, notify::EventKind::Access(_)) => refresh_pending = true,
+                Ok(event) if !matches!(event.kind, notify::EventKind::Access(_)) => {
+                    refresh_pending = true;
+                    refresh_from_filesystem = true;
+                    if refresh_receiver.is_some() {
+                        refresh_select_top = true;
+                    }
+                }
                 Ok(_) => {}
                 Err(_) => {
                     ref_watcher = None;
@@ -777,7 +785,12 @@ fn event_loop(
                     } else {
                         result.refs.hidden_tips.as_slice()
                     };
-                    if let Some(rows) = app.start_refresh(result.commits, &result.refs.view_tips, hidden_tips) {
+                    if let Some(rows) = app.start_refresh(
+                        result.commits,
+                        &result.refs.view_tips,
+                        hidden_tips,
+                        std::mem::take(&mut refresh_select_top),
+                    ) {
                         lane_receiver = Some(start_lane_worker(rows));
                     }
                     refresh_receiver = None;
@@ -835,6 +848,7 @@ fn event_loop(
             let next = history::snapshot(&repository, &revisions, &hide)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed;
+            let select_top = std::mem::take(&mut refresh_from_filesystem);
             ref_snapshot = next;
             refresh_pending = false;
             if tips_changed || refresh_expand_hidden {
@@ -853,6 +867,7 @@ fn event_loop(
                     expand,
                     gix::features::threading::OwnShared::clone(&authors),
                 ));
+                refresh_select_top = select_top;
                 refresh_expand_hidden = false;
                 app.state = State::Loading;
             } else {

From b50f1dd20d2491da3a1defd9623fe4a430eadfb0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 6 Aug 2026 15:44:48 +0200
Subject: [PATCH 019/282] feat: group tix history display shortcuts

Collapse history presentation controls behind a `v view` prefix to keep the
main status concise. Expand date, actor, mailmap, trailer, reference, and hidden
history controls on demand while leaving alignment and overlay panes direct.

Keep the display group open for consecutive presentation changes and collapse
it after navigation or any other recognized command.
---
 gix-tix/src/app.rs | 45 ++++++++++++++++++++++++++
 gix-tix/src/lib.rs | 73 +++++++++++++++++++++++-------------------
 gix-tix/src/ui.rs  | 80 ++++++++++++++++++++++------------------------
 3 files changed, 124 insertions(+), 74 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index a6b0de357ba..3a966524de8 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -271,6 +271,7 @@ pub(crate) enum Action {
     ToggleRefs,
     Refresh,
     ToggleHidden,
+    ToggleHistoryDisplay,
     ToggleAlign,
     ToggleCommit,
     ToggleChanges,
@@ -347,6 +348,7 @@ pub(crate) struct App {
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
     pub(crate) notice: Option<String>,
+    pub(crate) history_display_expanded: bool,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
     horizontal_page: usize,
@@ -411,6 +413,7 @@ impl App {
             copy_feedback: None,
             focus_feedback: None,
             notice: None,
+            history_display_expanded: false,
             estimated_lane_width: 0,
             horizontal_offset: 0,
             horizontal_page: 1,
@@ -575,6 +578,19 @@ impl App {
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         self.notice = None;
+        if !matches!(
+            &action,
+            Action::ToggleHistoryDisplay
+                | Action::ToggleDate
+                | Action::ToggleEmail
+                | Action::ToggleName
+                | Action::ToggleTrailers
+                | Action::ToggleMailmap
+                | Action::ToggleRefs
+                | Action::ToggleHidden
+        ) {
+            self.history_display_expanded = false;
+        }
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
@@ -659,6 +675,7 @@ impl App {
             }
             Action::ToggleTrailers => self.show_trailers = !self.show_trailers,
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
+            Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
             Action::ToggleRefs => {
                 self.ref_mode = match self.ref_mode {
                     RefMode::All => RefMode::Default,
@@ -2216,6 +2233,34 @@ mod tests {
         assert!(app.align_metadata);
     }
 
+    #[test]
+    fn history_display_group_stays_open_only_for_grouped_actions() {
+        let mut app = App::new(1);
+
+        app.update(Action::ToggleHistoryDisplay);
+        assert!(app.history_display_expanded);
+        app.update(Action::ToggleDate);
+        app.update(Action::ToggleEmail);
+        assert!(
+            app.history_display_expanded,
+            "grouped display changes keep the group open"
+        );
+
+        app.update(Action::MoveDown);
+        assert!(!app.history_display_expanded, "navigation collapses the group");
+
+        app.update(Action::ToggleHistoryDisplay);
+        app.update(Action::ToggleAlign);
+        assert!(
+            !app.history_display_expanded,
+            "direct display commands also collapse the group"
+        );
+
+        app.update(Action::ToggleHistoryDisplay);
+        app.update(Action::ToggleHistoryDisplay);
+        assert!(!app.history_display_expanded, "the prefix key toggles the group");
+    }
+
     #[test]
     fn cycles_both_tree_and_hidden_changes() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c332c6bcc46..ed112f78129 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1000,7 +1000,7 @@ fn event_loop(
         };
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
-                let action = action(key);
+                let action = action_with_history_display(key, app.history_display_expanded);
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
@@ -2463,6 +2463,10 @@ fn poll_timeout(
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
+    action_with_history_display(key, false)
+}
+
+fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) -> Option<Action> {
     if key.kind == KeyEventKind::Release
         && !matches!(
             key.code,
@@ -2484,6 +2488,7 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
         KeyCode::Down | KeyCode::Char('j') => Some(Action::MoveDown),
+        KeyCode::Char('h') if history_display_expanded => Some(Action::ToggleHidden),
         KeyCode::Char('h') => Some(Action::ScrollLeft),
         KeyCode::Char('l') => Some(Action::ScrollRight),
         KeyCode::Char('b') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::PageUp),
@@ -2495,16 +2500,16 @@ fn action(key: KeyEvent) -> Option<Action> {
         KeyCode::Char('g') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Last),
         KeyCode::Home | KeyCode::Char('g') => Some(Action::First),
         KeyCode::End | KeyCode::Char('G') => Some(Action::Last),
-        KeyCode::Char('d') => Some(Action::ToggleDate),
-        KeyCode::Char('e') => Some(Action::ToggleEmail),
-        KeyCode::Char('n') => Some(Action::ToggleName),
-        KeyCode::Char('t') => Some(Action::ToggleTrailers),
-        KeyCode::Char('m') => Some(Action::ToggleMailmap),
+        KeyCode::Char('d') if history_display_expanded => Some(Action::ToggleDate),
+        KeyCode::Char('e') if history_display_expanded => Some(Action::ToggleEmail),
+        KeyCode::Char('n') if history_display_expanded => Some(Action::ToggleName),
+        KeyCode::Char('t') if history_display_expanded => Some(Action::ToggleTrailers),
+        KeyCode::Char('m') if history_display_expanded => Some(Action::ToggleMailmap),
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
-        KeyCode::Char('r') => Some(Action::ToggleRefs),
+        KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
-        KeyCode::Char('v') => Some(Action::ToggleHidden),
+        KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']' | 'o') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
@@ -3146,30 +3151,12 @@ mod tests {
             Some(Action::Last),
             "terminals that report shifted letters in lowercase still map Shift-G to the first commit"
         );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)),
-            Some(Action::ToggleDate)
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
-            Some(Action::ToggleEmail)
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
-            Some(Action::ToggleName)
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)),
-            Some(Action::ToggleTrailers)
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)),
-            Some(Action::ToggleMailmap)
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
-            Some(Action::ToggleRefs)
-        );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
@@ -3182,7 +3169,27 @@ mod tests {
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE)),
-            Some(Action::ToggleHidden)
+            Some(Action::ToggleHistoryDisplay)
+        );
+        for (key, expected) in [
+            ('d', Action::ToggleDate),
+            ('e', Action::ToggleEmail),
+            ('n', Action::ToggleName),
+            ('t', Action::ToggleTrailers),
+            ('m', Action::ToggleMailmap),
+            ('r', Action::ToggleRefs),
+            ('h', Action::ToggleHidden),
+        ] {
+            assert_eq!(
+                action_with_history_display(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), true),
+                Some(expected),
+                "{key} is available after the view prefix"
+            );
+        }
+        assert_eq!(
+            action_with_history_display(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE), true),
+            Some(Action::ToggleHistoryDisplay),
+            "v closes the view shortcut group"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index fc4b4a6f88d..025b1fefde4 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -607,43 +607,45 @@ pub(crate) fn draw_with_worktree(
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
     footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
     footer_spans.extend([Span::raw(" · "), toggle("c changes", app.changes_mode.is_some())]);
-    if app.has_hidden_filter {
-        footer_spans.extend([
-            Span::raw(" · "),
-            toggle(
-                if app.show_hidden {
-                    "v hide hidden"
-                } else {
-                    "v show hidden"
-                },
-                app.show_hidden,
-            ),
-        ]);
-    }
-    footer_spans.extend([Span::raw(" · "), toggle("d date", app.show_committer_date)]);
-    footer_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
-    let (name_label, names_visible) = match app.name_mode {
-        NameMode::All => ("n names", true),
-        NameMode::Author => ("n name", true),
-        NameMode::None => ("n name", false),
-    };
-    footer_spans.extend([Span::raw(" · "), toggle(name_label, names_visible)]);
-    for (label, enabled) in [("m mailmap", app.use_mailmap), ("t trailers", app.show_trailers)] {
-        footer_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
-    }
-    footer_spans.push(Span::raw(" · "));
-    if app.preview_author_copy && app.manual_refresh {
-        footer_spans.push(toggle(
-            "R refresh",
-            matches!(app.state, State::Complete | State::Cancelled),
-        ));
-    } else {
+    if app.history_display_expanded {
+        footer_spans.extend([Span::raw(" · "), toggle("d date", app.show_committer_date)]);
+        footer_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
+        let (name_label, names_visible) = match app.name_mode {
+            NameMode::All => ("n names", true),
+            NameMode::Author => ("n name", true),
+            NameMode::None => ("n name", false),
+        };
+        footer_spans.extend([Span::raw(" · "), toggle(name_label, names_visible)]);
+        for (label, enabled) in [("m mailmap", app.use_mailmap), ("t trailers", app.show_trailers)] {
+            footer_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
+        }
         let ref_label = match app.ref_mode {
             RefMode::All => "r all refs",
             RefMode::Default => "r refs",
             RefMode::None => "r no refs",
         };
-        footer_spans.push(toggle(ref_label, app.ref_mode != RefMode::None));
+        footer_spans.extend([Span::raw(" · "), toggle(ref_label, app.ref_mode != RefMode::None)]);
+        if app.has_hidden_filter {
+            footer_spans.extend([
+                Span::raw(" · "),
+                toggle(
+                    if app.show_hidden {
+                        "h hide hidden"
+                    } else {
+                        "h show hidden"
+                    },
+                    app.show_hidden,
+                ),
+            ]);
+        }
+    } else {
+        footer_spans.push(Span::raw(" · v view"));
+    }
+    if app.preview_author_copy && app.manual_refresh {
+        footer_spans.extend([
+            Span::raw(" · "),
+            toggle("R refresh", matches!(app.state, State::Complete | State::Cancelled)),
+        ]);
     }
     footer_spans.push(Span::raw(if app.preview_author_copy {
         " · Y copy author"
@@ -1612,6 +1614,7 @@ mod tests {
             ],
         });
         app.selected = None;
+        app.history_display_expanded = true;
         let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
 
         let mailmap =
@@ -1786,7 +1789,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · ↑↓/jk move · h/l pan · [ align · o commit · c changes · d date · e emails · n names · m mailmap · t trailers · r refs · y copy · q quit";
+        let footer_text = "#1 · ↑↓/jk move · h/l pan · [ align · o commit · c changes · v view · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -1819,12 +1822,6 @@ mod tests {
         for x in commit..commit + "o commit".len() {
             expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
         }
-        let email = footer_text[..footer_text.find("e emails").expect("the email toggle is present")]
-            .chars()
-            .count();
-        for x in email..email + "e emails".len() {
-            expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
-        }
         terminal.backend().assert_buffer(&expected);
 
         app.inline = true;
@@ -1864,6 +1861,7 @@ mod tests {
             "recovery information replaces the status until the next action"
         );
 
+        app.history_display_expanded = true;
         app.update(Action::ToggleMailmap);
         assert!(app.notice.is_none(), "the next action restores the normal status");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -1929,13 +1927,13 @@ mod tests {
         app.has_hidden_filter = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
-            rendered_line(&terminal, 1).contains("v show hidden"),
+            rendered_line(&terminal, 1).contains("h show hidden"),
             "the footer advertises the configured hidden-history toggle"
         );
         app.show_hidden = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
-            rendered_line(&terminal, 1).contains("v hide hidden"),
+            rendered_line(&terminal, 1).contains("h hide hidden"),
             "the footer reflects the unfiltered view"
         );
 

From 9e09a2bf45a2b9995786ebdbe80cb9e1f01a0bc3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 6 Aug 2026 18:36:48 +0200
Subject: [PATCH 020/282] change: brighten red UI elements and omit zero diff
 counts

Use the terminal bright-red color for deletions, unstaged changes, failed signatures, errors, behind counts, and graph rails so red remains legible against dark backgrounds.

Render insertion and removal counts only when non-zero in history selection information, changes summaries, and selected changed paths. Keep clean worktree blocks visible by their title.
---
 gix-tix/src/ui.rs | 141 ++++++++++++++++++++++++++++++----------------
 1 file changed, 93 insertions(+), 48 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 025b1fefde4..183ecc6a029 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -144,7 +144,7 @@ pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset:
             } else if line.starts_with(b"+") {
                 Style::default().fg(Color::Green)
             } else if line.starts_with(b"-") {
-                Style::default().fg(Color::Red)
+                Style::default().fg(Color::LightRed)
             } else if line.starts_with(b"Binary ") {
                 Style::default().fg(Color::Yellow)
             } else {
@@ -534,7 +534,7 @@ pub(crate) fn draw_with_worktree(
                 ]);
             }
             if let Some(error) = &app.changes(pane).error {
-                spans.push(Span::styled(format!("diff: {error}"), color(Color::Red)));
+                spans.push(Span::styled(format!("diff: {error}"), color(Color::LightRed)));
             } else {
                 spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
             }
@@ -655,7 +655,7 @@ pub(crate) fn draw_with_worktree(
     if app.signature_failures > 0 {
         footer_spans.extend([
             Span::raw(format!(" · s {} ", app.signature_failures)),
-            Span::styled("●", color(Color::Red)),
+            Span::styled("●", color(Color::LightRed)),
         ]);
     } else if has_verifiable_signatures {
         footer_spans.extend([
@@ -716,11 +716,18 @@ fn render_changes_divider(frame: &mut Frame<'_>, panes: &[ChangesPaneArea], app:
 fn selection_info_line(changes: Option<&Changes>, relation: Option<SelectionRelation>) -> Line<'static> {
     let mut spans = Vec::new();
     if let Some(changes) = changes {
-        spans.extend([
-            Span::styled(format!("+{}", changes.lines_added), selection_color(Color::Green)),
-            Span::raw(" "),
-            Span::styled(format!("-{}", changes.lines_removed), selection_color(Color::Red)),
-        ]);
+        if changes.lines_added > 0 {
+            push_selection_span(
+                &mut spans,
+                Span::styled(format!("+{}", changes.lines_added), selection_color(Color::Green)),
+            );
+        }
+        if changes.lines_removed > 0 {
+            push_selection_span(
+                &mut spans,
+                Span::styled(format!("-{}", changes.lines_removed), selection_color(Color::LightRed)),
+            );
+        }
     }
     match relation {
         Some(SelectionRelation::Tracking { ahead, behind }) => {
@@ -734,10 +741,10 @@ fn selection_info_line(changes: Option<&Changes>, relation: Option<SelectionRela
                 if ahead == 0 {
                     push_selection_span(
                         &mut spans,
-                        Span::styled(format!("⇣{behind}"), selection_color(Color::Red)),
+                        Span::styled(format!("⇣{behind}"), selection_color(Color::LightRed)),
                     );
                 } else {
-                    spans.push(Span::styled(format!("⇣{behind}"), selection_color(Color::Red)));
+                    spans.push(Span::styled(format!("⇣{behind}"), selection_color(Color::LightRed)));
                 }
             }
         }
@@ -802,12 +809,18 @@ fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, pane: Ch
                 spans.push(Span::styled(change.path.to_str_lossy(), path_style));
             }
             if selected && let Some((insertions, removals)) = change.lines {
-                spans.extend([
-                    Span::raw(" "),
-                    Span::styled(format!("+{insertions}"), color(Color::Green)),
-                    Span::raw(" "),
-                    Span::styled(format!("-{removals}"), color(Color::Red)),
-                ]);
+                if insertions > 0 {
+                    spans.extend([
+                        Span::raw(" "),
+                        Span::styled(format!("+{insertions}"), color(Color::Green)),
+                    ]);
+                }
+                if removals > 0 {
+                    spans.extend([
+                        Span::raw(" "),
+                        Span::styled(format!("-{removals}"), color(Color::LightRed)),
+                    ]);
+                }
             }
             Line::from(spans)
         })
@@ -861,10 +874,10 @@ fn change_color(kind: ChangeKind) -> Color {
     match kind {
         ChangeKind::Added => Color::Green,
         ChangeKind::Modified => Color::Yellow,
-        ChangeKind::Deleted => Color::Red,
+        ChangeKind::Deleted => Color::LightRed,
         ChangeKind::Renamed | ChangeKind::Copied => Color::Cyan,
         ChangeKind::TypeChanged => Color::Magenta,
-        ChangeKind::Unmerged => Color::Red,
+        ChangeKind::Unmerged => Color::LightRed,
     }
 }
 
@@ -872,7 +885,7 @@ fn path_change_color(change: &crate::app::PathChange) -> Color {
     match change.group {
         ChangeGroup::Tree => change_color(change.kind),
         ChangeGroup::Staged => Color::Green,
-        ChangeGroup::Unstaged => Color::Red,
+        ChangeGroup::Unstaged => Color::LightRed,
     }
 }
 
@@ -887,15 +900,6 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
         }
         ChangePane::Worktree => vec![Span::raw("─ Worktree ── ")],
     };
-    if pane == ChangePane::Worktree && changes.paths.is_empty() {
-        spans.extend([
-            Span::styled("+0", color(Color::Green)),
-            Span::raw(" "),
-            Span::styled("-0", color(Color::Red)),
-            Span::raw(" "),
-        ]);
-        return Line::from(spans);
-    }
     let counts: Vec<_> = match pane {
         ChangePane::Tree => {
             let mut counts = Vec::new();
@@ -924,7 +928,7 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
             let unstaged = changes.paths.len().saturating_sub(staged);
             [
                 ("S".to_owned(), staged, Color::Green),
-                ("U".to_owned(), unstaged, Color::Red),
+                ("U".to_owned(), unstaged, Color::LightRed),
             ]
             .into_iter()
             .filter(|(_, count, _)| *count > 0)
@@ -932,7 +936,7 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
         }
     };
     let has_counts = !counts.is_empty();
-    let show_total = counts.len() != 1 || counts[0].1 != changes.paths.len();
+    let show_total = has_counts && (counts.len() != 1 || counts[0].1 != changes.paths.len());
     for (index, (label, count, count_color)) in counts.into_iter().enumerate() {
         if index > 0 {
             spans.push(Span::raw(" + "));
@@ -946,13 +950,22 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
             changes.paths.len()
         )));
     }
-    spans.extend([
-        Span::raw(" · "),
-        Span::styled(format!("+{}", changes.lines_added), color(Color::Green)),
-        Span::raw(" "),
-        Span::styled(format!("-{}", changes.lines_removed), color(Color::Red)),
-        Span::raw(" "),
-    ]);
+    if changes.lines_added > 0 || changes.lines_removed > 0 {
+        spans.push(Span::raw(" · "));
+        if changes.lines_added > 0 {
+            spans.push(Span::styled(format!("+{}", changes.lines_added), color(Color::Green)));
+        }
+        if changes.lines_removed > 0 {
+            if changes.lines_added > 0 {
+                spans.push(Span::raw(" "));
+            }
+            spans.push(Span::styled(
+                format!("-{}", changes.lines_removed),
+                color(Color::LightRed),
+            ));
+        }
+        spans.push(Span::raw(" "));
+    }
     Line::from(spans)
 }
 
@@ -1352,7 +1365,7 @@ fn signature_color(signature: SignatureState) -> Color {
         SignatureState::Unsigned => Color::Blue,
         SignatureState::Unverified | SignatureState::Verifying => Color::Rgb(255, 165, 0),
         SignatureState::Verified => Color::Green,
-        SignatureState::Failed => Color::Red,
+        SignatureState::Failed => Color::LightRed,
     }
 }
 
@@ -1364,7 +1377,7 @@ fn graph_style(column: usize) -> Style {
         Color::Green,
         Color::Reset,
         Color::White,
-        Color::Red,
+        Color::LightRed,
     ];
     let index = column % 14;
     let style = Style::default().fg(COLORS[index % COLORS.len()]);
@@ -1490,7 +1503,7 @@ mod tests {
             "selection info has a left margin"
         );
         assert_eq!(buffer[(info_x, 0)].fg, Color::Green);
-        assert_eq!(buffer[(info_x + 3, 0)].fg, Color::Red);
+        assert_eq!(buffer[(info_x + 3, 0)].fg, Color::LightRed);
         assert!(!buffer[(info_x, 0)].modifier.contains(Modifier::DIM));
         let spacer_x = info_x + info.chars().count() as u16;
         assert_eq!(buffer[(spacer_x, 0)].symbol(), " ", "the marker has a left spacer");
@@ -1533,6 +1546,10 @@ mod tests {
         };
         assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 2 })), "⇣2");
         assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 0 })), "");
+        assert!(
+            selection_info_line(Some(&Changes::default()), None).spans.is_empty(),
+            "selection information hides empty diff counts"
+        );
         Ok(())
     }
 
@@ -1551,10 +1568,10 @@ mod tests {
 
         assert_eq!(rendered_line(&terminal, 0).trim(), "M file");
         for (y, color) in [
-            (1, Color::Red),
+            (1, Color::LightRed),
             (2, Color::Green),
             (3, Color::Cyan),
-            (4, Color::Red),
+            (4, Color::LightRed),
             (5, Color::Green),
         ] {
             assert_eq!(terminal.backend().buffer()[(0, y)].fg, color);
@@ -2051,7 +2068,7 @@ mod tests {
             (SignatureState::Unsigned, Color::Blue),
             (SignatureState::Unverified, Color::Rgb(255, 165, 0)),
             (SignatureState::Verified, Color::Green),
-            (SignatureState::Failed, Color::Red),
+            (SignatureState::Failed, Color::LightRed),
         ];
         let mut terminal = Terminal::new(TestBackend::new(2, states.len() as u16))?;
         terminal.draw(|frame| {
@@ -2485,7 +2502,7 @@ mod tests {
         let added_x = position("A 1");
         let deleted_x = position("D 1");
         assert_eq!(terminal.backend().buffer()[(added_x, 7)].fg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(deleted_x, 7)].fg, Color::Red);
+        assert_eq!(terminal.backend().buffer()[(deleted_x, 7)].fg, Color::LightRed);
         assert!(
             terminal.backend().buffer()[(added_x, 7)]
                 .modifier
@@ -2622,7 +2639,7 @@ mod tests {
             "the selected filepath is inverted"
         );
         assert_eq!(terminal.backend().buffer()[(added_x, 9)].fg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(removed_x, 9)].fg, Color::Red);
+        assert_eq!(terminal.backend().buffer()[(removed_x, 9)].fg, Color::LightRed);
         assert!(
             !terminal.backend().buffer()[(added_x, 9)]
                 .modifier
@@ -2641,6 +2658,23 @@ mod tests {
             "the changes pane advertises the next cycle mode"
         );
 
+        app.update(Action::MoveUp);
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(rendered_line(&terminal, 8).contains("A added +10"));
+        assert!(
+            !rendered_line(&terminal, 8).contains("-0"),
+            "selected paths hide empty counts"
+        );
+
         app.update(Action::Last);
         app.update(Action::ScrollRight);
         terminal.draw(|frame| {
@@ -2830,7 +2864,10 @@ mod tests {
         let staged_x = rendered_line(&terminal, staged_y).find('A').expect("staged letter") as u16;
         let unstaged_x = rendered_line(&terminal, unstaged_y).find('M').expect("unstaged letter") as u16;
         assert_eq!(terminal.backend().buffer()[(staged_x, staged_y)].fg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(unstaged_x, unstaged_y)].fg, Color::Red);
+        assert_eq!(
+            terminal.backend().buffer()[(unstaged_x, unstaged_y)].fg,
+            Color::LightRed
+        );
 
         let modified = Changes {
             paths: (0..12)
@@ -2849,7 +2886,11 @@ mod tests {
             .iter()
             .map(|span| span.content.as_ref())
             .collect::<String>();
-        assert!(summary.contains("M 12 · +0 -0"));
+        assert!(summary.contains("M 12"));
+        assert!(
+            !summary.contains("+0") && !summary.contains("-0"),
+            "empty diff counts are hidden"
+        );
         assert!(!summary.contains("= 12"), "a single term already expresses the total");
 
         terminal.draw(|frame| {
@@ -2864,9 +2905,13 @@ mod tests {
             );
         })?;
         assert!(
-            (0..8).any(|y| rendered_line(&terminal, y).contains("Worktree ── +0 -0")),
+            (0..8).any(|y| rendered_line(&terminal, y).contains("Worktree ──")),
             "an enabled clean worktree remains visible as an empty block"
         );
+        assert!(
+            !(0..8).any(|y| rendered_line(&terminal, y).contains("+0") || rendered_line(&terminal, y).contains("-0")),
+            "a clean worktree omits empty diff counts"
+        );
         assert!(
             !(0..8).any(|y| rendered_line(&terminal, y).contains("= 0")),
             "a clean worktree has no empty aggregate"

From cda3fafe20ea7a9d65ede3b5133c7386200838a9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 6 Aug 2026 20:03:57 +0200
Subject: [PATCH 021/282] feat: copy selected changed paths in tix

Make the existing y shortcut copy the selected path when either changes block has focus. Preserve raw Git path bytes and retain commit-id copying when history has focus.
---
 gix-tix/src/app.rs |  7 ++++++
 gix-tix/src/lib.rs | 58 ++++++++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/ui.rs  | 12 +++++++---
 3 files changed, 74 insertions(+), 3 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 3a966524de8..7ab678cc110 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -281,6 +281,7 @@ pub(crate) enum Action {
     VerifySignatures,
     Cancel,
     Copy,
+    CopyPath(BString),
     CopyAuthor,
     PreviewAuthorCopy(bool),
     ForceQuit,
@@ -291,6 +292,7 @@ pub(crate) enum Action {
 pub(crate) enum Effect {
     Cancel,
     CopyId(ObjectId),
+    CopyPath(BString),
     CopyAuthor(&'static Author),
     Reload(bool),
     OpenDiff(ChangePane, usize),
@@ -772,6 +774,7 @@ impl App {
                     return vec![Effect::CopyId(id)];
                 }
             }
+            Action::CopyPath(path) => return vec![Effect::CopyPath(path)],
             Action::CopyAuthor => {
                 if let Some(author) = self
                     .selected
@@ -2589,6 +2592,10 @@ mod tests {
         app.extend_commits(vec![row(7)]);
 
         assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(row(7).id)]);
+        assert_eq!(
+            app.update(Action::CopyPath("dir/file".into())),
+            vec![Effect::CopyPath("dir/file".into())]
+        );
         assert_eq!(app.update(Action::CopyAuthor), vec![Effect::CopyAuthor(row(7).author)]);
         complete(&mut app);
         assert_eq!(app.state, State::Complete);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index ed112f78129..490daad31f0 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1054,6 +1054,12 @@ fn event_loop(
         let Some(action) = action else {
             continue;
         };
+        let action = copy_selected_path_action(
+            action,
+            &app,
+            tree_changes.as_ref().map(|(_, _, changes)| changes),
+            worktree_changes.as_ref().map(|(_, changes)| changes),
+        );
         dirty = true;
         urgent |= !throttles_draw;
         let previous_changes_mode = app.changes_mode;
@@ -1089,6 +1095,7 @@ fn event_loop(
                     terminal.backend_mut(),
                     CopyToClipboard::to_clipboard_from(id.to_hex().to_string())
                 )?,
+                Effect::CopyPath(path) => execute!(terminal.backend_mut(), CopyToClipboard::to_clipboard_from(path))?,
                 Effect::CopyAuthor(author) => {
                     let actor = actor_bytes(author);
                     execute!(terminal.backend_mut(), CopyToClipboard::to_clipboard_from(actor))?;
@@ -2519,6 +2526,25 @@ fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) ->
     }
 }
 
+fn copy_selected_path_action(
+    action: Action,
+    app: &App,
+    tree_changes: Option<&Changes>,
+    worktree_changes: Option<&Changes>,
+) -> Action {
+    if action != Action::Copy {
+        return action;
+    }
+    let (pane, changes) = match app.changes_focus {
+        Some(pane @ ChangePane::Tree) => (pane, tree_changes),
+        Some(pane @ ChangePane::Worktree) => (pane, worktree_changes),
+        None => return action,
+    };
+    changes
+        .and_then(|changes| changes.paths.get(app.changes(pane).selected))
+        .map_or(action, |change| Action::CopyPath(change.path.clone()))
+}
+
 fn repeats_viewport(action: &Action) -> bool {
     matches!(
         action,
@@ -2556,6 +2582,38 @@ fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::
 mod tests {
     use super::*;
 
+    #[test]
+    fn copies_the_selected_path_from_the_focused_changes_block() {
+        let mut app = App::new(1);
+        app.changes_focus = Some(ChangePane::Tree);
+        app.set_changes_bounds(ChangePane::Tree, 2, 2, 80, 0);
+        drop(app.update(Action::MoveDown));
+        let changes = Changes {
+            paths: ["first", "dir/second"]
+                .into_iter()
+                .map(|path| app::PathChange {
+                    kind: ChangeKind::Modified,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: path.into(),
+                    lines: None,
+                })
+                .collect(),
+            ..Changes::default()
+        };
+
+        assert_eq!(
+            copy_selected_path_action(Action::Copy, &app, Some(&changes), None),
+            Action::CopyPath("dir/second".into())
+        );
+        app.changes_focus = None;
+        assert_eq!(
+            copy_selected_path_action(Action::Copy, &app, Some(&changes), None),
+            Action::Copy,
+            "history retains commit-id copying"
+        );
+    }
+
     #[test]
     fn loads_commit_messages_from_an_existing_repository() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 183ecc6a029..70a454f4e8b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -538,6 +538,7 @@ pub(crate) fn draw_with_worktree(
             } else {
                 spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
             }
+            spans.push(Span::raw(" · y copy"));
             spans.push(Span::raw(match app.changes_mode {
                 Some(ChangesMode::Both) => " · c tree",
                 Some(ChangesMode::Tree) => " · c to hide",
@@ -2654,9 +2655,13 @@ mod tests {
         assert!(rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"));
 
         assert!(
-            rendered_line(&terminal, 14).contains("Enter diff · c tree"),
+            rendered_line(&terminal, 14).contains("Enter diff · y copy · c tree"),
             "the changes pane advertises the next cycle mode"
         );
+        assert!(
+            rendered_line(&terminal, 14).contains("y copy"),
+            "the changes pane advertises path copying"
+        );
 
         app.update(Action::MoveUp);
         terminal.draw(|frame| {
@@ -2734,8 +2739,9 @@ mod tests {
             "parent context no longer crowds the aggregate border"
         );
         assert!(
-            rendered_line(&terminal, 14)
-                .contains("vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · c tree"),
+            rendered_line(&terminal, 14).contains(
+                "vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · y copy · c tree"
+            ),
             "merge diffs keep parent controls alongside navigation"
         );
         let parent = rendered_line(&terminal, 1);

From c86aacd30357419f631b357ff9dd1f6aee23ab2d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 7 Aug 2026 12:52:24 +0200
Subject: [PATCH 022/282] change: widen the default tix commit panel

Reserve eighty content columns for commit messages on sufficiently wide terminals, in addition to the panel border and horizontal margins. This prevents conventionally wrapped commit text from orphaning its final word.
---
 gix-tix/src/ui.rs | 30 ++++++++++++++++++++++++------
 1 file changed, 24 insertions(+), 6 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 70a454f4e8b..8cb547b0bbc 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -17,6 +17,7 @@ use crate::{
 };
 
 const COMPARED_PARENT_COLOR: Color = Color::Cyan;
+const COMMIT_PANE_WIDTH: u16 = 84;
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
@@ -208,7 +209,7 @@ pub(crate) fn draw_with_worktree(
     let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
     let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
     let commit_pane = app.show_commit.then(|| {
-        let width = 80.min(full_body.width / 2);
+        let width = COMMIT_PANE_WIDTH.min(full_body.width / 2);
         let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
         body.width = body.width.min(commits.width);
         let mut content = message.inner(Margin {
@@ -2200,20 +2201,37 @@ mod tests {
 
         app.update(Action::ToggleCommit);
         let mut wide_terminal = Terminal::new(TestBackend::new(200, 6))?;
+        let conventional_line = format!("{} word", "x".repeat(75));
         wide_terminal.draw(|frame| {
             super::draw(
                 frame,
                 &mut app,
                 &Decorations::new(),
                 &gix::mailmap::Snapshot::default(),
-                Some(b"subject".as_bstr()),
+                Some(conventional_line.as_bytes().as_bstr()),
                 None,
             );
         })?;
         assert_eq!(
-            wide_terminal.backend().buffer()[(122, 0)].symbol(),
-            "s",
-            "the pane remains eighty columns wide on a wide screen"
+            wide_terminal.backend().buffer()[(118, 0)].symbol(),
+            "x",
+            "the pane reserves eighty content columns on a wide screen"
+        );
+        assert!(
+            rendered_line(&wide_terminal, 0)
+                .chars()
+                .skip(118)
+                .take(80)
+                .collect::<String>()
+                .ends_with(" word")
+                && rendered_line(&wide_terminal, 1)
+                    .chars()
+                    .skip(118)
+                    .take(80)
+                    .collect::<String>()
+                    .trim()
+                    .is_empty(),
+            "an eighty-column message line does not wrap its final word"
         );
         Ok(())
     }
@@ -2815,7 +2833,7 @@ mod tests {
             ChangesLayout::SideBySide,
             "sufficient remaining width still permits side-by-side changes"
         );
-        assert_eq!(wide_terminal.backend().buffer()[(160, 7)].symbol(), "│");
+        assert_eq!(wide_terminal.backend().buffer()[(156, 7)].symbol(), "│");
         Ok(())
     }
 

From 2780da79da54a9de0fef63257d63601f8143ba96 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 16:24:14 +0200
Subject: [PATCH 023/282] feat: persist tix diagnostics to OS log storage

Write daily, non-ANSI tracing logs to the platform-standard application log directory so watcher and refresh failures can be diagnosed after the terminal UI exits. Keep seven days of logs and install the subscriber only for the calling thread so embedding tix cannot replace an application-wide tracing subscriber.

Logging is best-effort: initialization failures are reported before terminal setup and do not prevent tix from starting.
---
 Cargo.lock             |  81 ++++++++++++++++++++++++++++
 gix-tix/Cargo.toml     |   4 ++
 gix-tix/src/lib.rs     |  13 +++++
 gix-tix/src/logging.rs | 119 +++++++++++++++++++++++++++++++++++++++++
 4 files changed, 217 insertions(+)
 create mode 100644 gix-tix/src/logging.rs

diff --git a/Cargo.lock b/Cargo.lock
index 94051ba0a1e..366b40f9ee1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1078,6 +1078,27 @@ dependencies = [
  "crypto-common 0.2.2",
 ]
 
+[[package]]
+name = "directories"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16f5094c54661b38d03bd7e50df373292118db60b585c08a411c6d840017fe7d"
+dependencies = [
+ "dirs-sys",
+]
+
+[[package]]
+name = "dirs-sys"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01a3366d27ee9890022452ee61b2b63a67e6f13f58900b651ff5665f0bb1fab"
+dependencies = [
+ "libc",
+ "option-ext",
+ "redox_users",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "displaydoc"
 version = "0.2.6"
@@ -2575,10 +2596,14 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "crossterm",
+ "directories",
  "gix",
  "gix-testtools",
  "notify",
  "ratatui",
+ "tracing",
+ "tracing-appender",
+ "tracing-subscriber",
 ]
 
 [[package]]
@@ -3553,6 +3578,15 @@ version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
 
+[[package]]
+name = "libredox"
+version = "0.1.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2026a5056764a10b2bf5d56488cba40da507f5493a6a429340e2004d9ed085fa"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "libsqlite3-sys"
 version = "0.38.1"
@@ -3936,6 +3970,12 @@ dependencies = [
  "vcpkg",
 ]
 
+[[package]]
+name = "option-ext"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
+
 [[package]]
 name = "page_size"
 version = "0.6.0"
@@ -4429,6 +4469,17 @@ dependencies = [
  "bitflags 2.13.0",
 ]
 
+[[package]]
+name = "redox_users"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4e608c6638b9c18977b00b475ac1f28d14e84b27d8d42f70e0bf1e3dec127ac"
+dependencies = [
+ "getrandom 0.2.17",
+ "libredox",
+ "thiserror 2.0.18",
+]
+
 [[package]]
 name = "regex"
 version = "1.12.4"
@@ -5040,6 +5091,12 @@ version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
 
+[[package]]
+name = "symlink"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7973cce6668464ea31f176d85b13c7ab3bba2cb3b77a2ed26abd7801688010a"
+
 [[package]]
 name = "syn"
 version = "1.0.109"
@@ -5240,6 +5297,7 @@ dependencies = [
  "powerfmt",
  "serde_core",
  "time-core",
+ "time-macros",
 ]
 
 [[package]]
@@ -5248,6 +5306,16 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9e1c906769ad99c88eaa54e728060edef082f8e358ff32030cb7c7d315e81109"
 
+[[package]]
+name = "time-macros"
+version = "0.2.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c431b87111666e491a90baa837f914fb45cd5dc3c268591b0220ff5057f2085f"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
 [[package]]
 name = "tinystr"
 version = "0.8.3"
@@ -5437,6 +5505,19 @@ dependencies = [
  "tracing-core",
 ]
 
+[[package]]
+name = "tracing-appender"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "050686193eb999b4bb3bc2acfa891a13da00f79734704c4b8b4ef1a10b368a3c"
+dependencies = [
+ "crossbeam-channel",
+ "symlink",
+ "thiserror 2.0.18",
+ "time",
+ "tracing-subscriber",
+]
+
 [[package]]
 name = "tracing-attributes"
 version = "0.1.31"
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 37ad53d3fcb..6b4af3ca78b 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -25,9 +25,13 @@ sha256 = ["gix/sha256"]
 [dependencies]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
+directories = "6.0.0"
 gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command", "status"] }
 notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
+tracing = "0.1.37"
+tracing-appender = "0.2.4"
+tracing-subscriber = "0.3.17"
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 490daad31f0..8003f909670 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4,6 +4,7 @@
 
 mod app;
 mod history;
+mod logging;
 mod ui;
 
 use std::{
@@ -374,6 +375,18 @@ pub enum Screen {
 
 /// Run the interactive commit graph for `repository`.
 pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, options: Options) -> Result<()> {
+    let _log_guard = match logging::init() {
+        Ok(guard) => Some(guard),
+        Err(err) => {
+            eprintln!("warning: could not initialize tix diagnostics: {err:#}");
+            None
+        }
+    };
+    tracing::info!(
+        revision_count = revisions.len(),
+        hidden_revision_count = options.hide.len(),
+        "starting tix"
+    );
     let terminal_height = match options.screen {
         Screen::Always => 0,
         Screen::Auto | Screen::Half => terminal::size().context("could not determine terminal size")?.1,
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
new file mode 100644
index 00000000000..f5dba90f934
--- /dev/null
+++ b/gix-tix/src/logging.rs
@@ -0,0 +1,119 @@
+use std::{
+    fs,
+    path::{Path, PathBuf},
+    time::{Duration, SystemTime},
+};
+
+use anyhow::{Context, Result};
+use tracing_subscriber::{filter::Targets, prelude::*};
+
+const FILE_PREFIX: &str = "tix.log";
+const RETENTION: Duration = Duration::from_secs(7 * 24 * 60 * 60);
+
+pub(crate) fn init() -> Result<tracing::subscriber::DefaultGuard> {
+    let directory = log_directory().context("could not determine the platform log directory")?;
+    fs::create_dir_all(&directory)
+        .with_context(|| format!("could not create log directory at {}", directory.display()))?;
+    let cleanup_errors = prune(&directory, SystemTime::now());
+    let appender = tracing_appender::rolling::RollingFileAppender::builder()
+        .rotation(tracing_appender::rolling::Rotation::DAILY)
+        .filename_prefix(FILE_PREFIX)
+        .build(&directory)
+        .context("could not open the daily diagnostic log")?;
+    let subscriber = tracing_subscriber::registry().with(
+        tracing_subscriber::fmt::layer()
+            .with_ansi(false)
+            .with_target(false)
+            .with_writer(appender)
+            .with_filter(
+                Targets::new()
+                    .with_default(tracing::Level::WARN)
+                    .with_target("gix_tix", tracing::Level::DEBUG),
+            ),
+    );
+    let guard = tracing::subscriber::set_default(subscriber);
+    tracing::info!(path = %directory.display(), "initialized diagnostics");
+    for error in cleanup_errors {
+        tracing::warn!(%error, "could not prune an old diagnostic log");
+    }
+    Ok(guard)
+}
+
+#[cfg(target_os = "macos")]
+fn log_directory() -> Option<PathBuf> {
+    directories::BaseDirs::new().map(|dirs| dirs.home_dir().join("Library/Logs/org.GitoxideLabs.tix"))
+}
+
+#[cfg(target_os = "linux")]
+fn log_directory() -> Option<PathBuf> {
+    directories::ProjectDirs::from("org", "GitoxideLabs", "tix").and_then(|dirs| dirs.state_dir().map(Path::to_owned))
+}
+
+#[cfg(target_os = "windows")]
+fn log_directory() -> Option<PathBuf> {
+    directories::BaseDirs::new().map(|dirs| dirs.data_local_dir().join("GitoxideLabs/tix/logs"))
+}
+
+#[cfg(not(any(target_os = "macos", target_os = "linux", target_os = "windows")))]
+fn log_directory() -> Option<PathBuf> {
+    directories::ProjectDirs::from("org", "GitoxideLabs", "tix").map(|dirs| dirs.data_local_dir().join("logs"))
+}
+
+fn prune(directory: &Path, now: SystemTime) -> Vec<String> {
+    let mut errors = Vec::new();
+    let entries = match fs::read_dir(directory) {
+        Ok(entries) => entries,
+        Err(err) => {
+            errors.push(err.to_string());
+            return errors;
+        }
+    };
+    for entry in entries {
+        let result = (|| -> std::io::Result<()> {
+            let entry = entry?;
+            let name = entry.file_name();
+            if !name.to_string_lossy().starts_with(&format!("{FILE_PREFIX}.")) {
+                return Ok(());
+            }
+            let age = now.duration_since(entry.metadata()?.modified()?).unwrap_or_default();
+            if age > RETENTION {
+                fs::remove_file(entry.path())?;
+            }
+            Ok(())
+        })();
+        if let Err(err) = result {
+            errors.push(err.to_string());
+        }
+    }
+    errors
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{fs::File, time::UNIX_EPOCH};
+
+    use super::*;
+
+    #[test]
+    fn prunes_only_expired_daily_logs() -> gix_testtools::Result {
+        let directory = std::env::temp_dir().join(format!(
+            "gix-tix-log-prune-{}-{}",
+            std::process::id(),
+            SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos()
+        ));
+        fs::create_dir(&directory)?;
+        let old = directory.join("tix.log.older");
+        let recent = directory.join("tix.log.recent");
+        let unrelated = directory.join("other.log.old");
+        File::create(&old)?.set_modified(UNIX_EPOCH)?;
+        File::create(&recent)?;
+        File::create(&unrelated)?.set_modified(UNIX_EPOCH)?;
+
+        assert!(prune(&directory, SystemTime::now()).is_empty());
+        assert!(!old.exists(), "expired tix logs are removed");
+        assert!(recent.exists(), "recent tix logs are retained");
+        assert!(unrelated.exists(), "unrelated files are retained");
+        fs::remove_dir_all(directory)?;
+        Ok(())
+    }
+}

From 330919f5cb73835e4b0a103adeb23c592278e1f3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 16:26:05 +0200
Subject: [PATCH 024/282] fix: reliably refresh tix after repository changes

Start worktree observation whenever the default combined changes view is active, including at startup, so edits made before cycling the panel are not missed. Treat ref events as potential worktree-status changes as well, which covers checked-out branch movement changing both HEAD and the index/worktree comparison.

Bound notification batches and use a fixed 75ms coalescing window so event storms cannot starve terminal input. Honor backend rescan requests, retain the native event-driven design, and retry failed ref or worktree watchers every five seconds while they are needed.

Add diagnostic tracing around watcher roots, event decisions, cache invalidation, snapshot comparisons, refresh workers, retries, and worktree-removal recovery.
---
 gix-tix/src/lib.rs | 345 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 282 insertions(+), 63 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8003f909670..9bc3ba1a8d6 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -52,6 +52,7 @@ const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
+const WATCH_RETRY_INTERVAL: Duration = Duration::from_secs(5);
 
 struct FillRepository {
     path: PathBuf,
@@ -69,6 +70,11 @@ struct WorktreeWatcher {
     index: PathBuf,
 }
 
+struct RefWatcher {
+    _watcher: RecommendedWatcher,
+    events: mpsc::Receiver<notify::Result<notify::Event>>,
+}
+
 impl WorktreeWatcher {
     fn event_is_relevant(&self, event: &notify::Event) -> bool {
         worktree_event_is_relevant(event, &self.workdir, &self.dot_git, &self.git_dir, &self.index)
@@ -82,10 +88,37 @@ fn worktree_event_is_relevant(
     git_dir: &Path,
     index: &Path,
 ) -> bool {
-    !matches!(event.kind, notify::EventKind::Access(_))
-        && event.paths.iter().any(|path| {
-            path == index || (path.starts_with(workdir) && !path.starts_with(dot_git) && !path.starts_with(git_dir))
-        })
+    event.need_rescan()
+        || (!matches!(event.kind, notify::EventKind::Access(_))
+            && event.paths.iter().any(|path| {
+                path == index || (path.starts_with(workdir) && !path.starts_with(dot_git) && !path.starts_with(git_dir))
+            }))
+}
+
+fn notification_is_actionable(event: &notify::Event) -> bool {
+    event.need_rescan() || !matches!(event.kind, notify::EventKind::Access(_))
+}
+
+fn worktree_watcher_needed(repository_is_bare: bool, mode: Option<ChangesMode>) -> bool {
+    !repository_is_bare && mode == Some(ChangesMode::Both)
+}
+
+fn schedule_once(deadline: &mut Option<Instant>, now: Instant, delay: Duration) -> bool {
+    if deadline.is_some() {
+        false
+    } else {
+        *deadline = Some(now + delay);
+        true
+    }
+}
+
+fn take_due(deadline: &mut Option<Instant>, now: Instant) -> bool {
+    if deadline.is_some_and(|deadline| now >= deadline) {
+        *deadline = None;
+        true
+    } else {
+        false
+    }
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -632,7 +665,15 @@ fn event_loop(
         .context("could not open Git notes")?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
     let mut ref_snapshot = history::snapshot(&view_repository, &revisions, &hide)?;
-    let (mut ref_watcher, mut ref_events) = start_ref_watcher(&repository_path, &common_dir);
+    let mut watcher_retry_deadline = None;
+    let mut ref_watcher = match start_ref_watcher(&repository_path, &common_dir) {
+        Ok(watcher) => Some(watcher),
+        Err(err) => {
+            tracing::warn!(error = %err, "reference watcher startup failed");
+            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+            None
+        }
+    };
     let (cancelled, receiver) = start_history(
         repository,
         &revisions,
@@ -676,6 +717,16 @@ fn event_loop(
         repository_is_bare,
         line_diff_parallelism,
     )?;
+    if worktree_watcher_needed(repository_is_bare, app.changes_mode) {
+        match start_worktree_watcher(&view_repository) {
+            Ok(watcher) => worktree_watcher = Some(watcher),
+            Err(err) => {
+                tracing::warn!(error = %err, "worktree watcher startup failed");
+                app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+            }
+        }
+    }
     let mut decorations = Decorations::new();
     draw(
         terminal,
@@ -701,45 +752,129 @@ fn event_loop(
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
     let result: Result<Option<Duration>> = (|| loop {
+        let mut worktree_watch_error = None;
         if let Some(watcher) = worktree_watcher.as_mut() {
-            while let Ok(event) = watcher.events.try_recv() {
-                match event {
-                    Ok(event) if watcher.event_is_relevant(&event) => {
-                        worktree_refresh_deadline = Some(Instant::now() + WORKTREE_EVENT_IDLE);
+            let mut received = 0;
+            let mut relevant = 0;
+            let mut rescans = 0;
+            while received < EVENT_BATCH_SIZE {
+                match watcher.events.try_recv() {
+                    Ok(Ok(event)) => {
+                        received += 1;
+                        rescans += usize::from(event.need_rescan());
+                        if watcher.event_is_relevant(&event) {
+                            relevant += 1;
+                            schedule_once(&mut worktree_refresh_deadline, Instant::now(), WORKTREE_EVENT_IDLE);
+                        }
                     }
-                    Ok(_) => {}
-                    Err(err) => {
-                        app.worktree_changes.error = Some(format!("worktree watch: {err}"));
-                        worktree_watcher = None;
-                        worktree_refresh_deadline = None;
-                        dirty = true;
-                        urgent = true;
+                    Ok(Err(err)) => {
+                        worktree_watch_error = Some(err);
                         break;
                     }
+                    Err(mpsc::TryRecvError::Empty | mpsc::TryRecvError::Disconnected) => break,
                 }
             }
+            if received > 0 {
+                tracing::debug!(received, relevant, rescans, "processed worktree event batch");
+            }
         }
-        if worktree_refresh_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
+        if let Some(err) = worktree_watch_error {
+            tracing::warn!(error = %err, "worktree watcher failed");
+            app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+            worktree_watcher = None;
             worktree_refresh_deadline = None;
-            invalidate_worktree_changes(&mut worktree_changes);
+            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
             dirty = true;
             urgent = true;
         }
-        while let Ok(event) = ref_events.try_recv() {
-            match event {
-                Ok(event) if !matches!(event.kind, notify::EventKind::Access(_)) => {
-                    refresh_pending = true;
-                    refresh_from_filesystem = true;
-                    if refresh_receiver.is_some() {
-                        refresh_select_top = true;
+        if take_due(&mut worktree_refresh_deadline, Instant::now()) {
+            let invalidated = invalidate_worktree_changes(&mut worktree_changes);
+            tracing::debug!(invalidated, "worktree event deadline elapsed");
+            dirty = true;
+            urgent = true;
+        }
+        let mut ref_watch_error = None;
+        if let Some(watcher) = ref_watcher.as_mut() {
+            let mut received = 0;
+            let mut actionable = 0;
+            let mut rescans = 0;
+            while received < EVENT_BATCH_SIZE {
+                match watcher.events.try_recv() {
+                    Ok(Ok(event)) => {
+                        received += 1;
+                        rescans += usize::from(event.need_rescan());
+                        if notification_is_actionable(&event) {
+                            actionable += 1;
+                            refresh_pending = true;
+                            refresh_from_filesystem = true;
+                            if refresh_receiver.is_some() {
+                                refresh_select_top = true;
+                            }
+                            if invalidate_worktree_changes(&mut worktree_changes) {
+                                dirty = true;
+                                urgent = true;
+                            }
+                        }
+                    }
+                    Ok(Err(err)) => {
+                        ref_watch_error = Some(err);
+                        break;
+                    }
+                    Err(mpsc::TryRecvError::Empty | mpsc::TryRecvError::Disconnected) => break,
+                }
+            }
+            if received > 0 {
+                tracing::debug!(received, actionable, rescans, "processed reference event batch");
+            }
+        }
+        if let Some(err) = ref_watch_error {
+            tracing::warn!(error = %err, "reference watcher failed");
+            ref_watcher = None;
+            app.manual_refresh = true;
+            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+        }
+        if take_due(&mut watcher_retry_deadline, Instant::now()) {
+            let mut retry = false;
+            if ref_watcher.is_none() {
+                match start_ref_watcher(&repository_path, &common_dir) {
+                    Ok(watcher) => {
+                        tracing::info!("reference watcher recovered");
+                        ref_watcher = Some(watcher);
+                        app.manual_refresh = false;
+                    }
+                    Err(err) => {
+                        tracing::warn!(error = %err, "reference watcher retry failed");
+                        retry = true;
                     }
                 }
-                Ok(_) => {}
-                Err(_) => {
-                    ref_watcher = None;
-                    app.manual_refresh = true;
+            }
+            if worktree_watcher_needed(repository_is_bare, app.changes_mode) && worktree_watcher.is_none() {
+                match start_worktree_watcher(&view_repository) {
+                    Ok(watcher) => {
+                        tracing::info!("worktree watcher recovered");
+                        worktree_watcher = Some(watcher);
+                        if app
+                            .worktree_changes
+                            .error
+                            .as_deref()
+                            .is_some_and(|message| message.starts_with("worktree watch:"))
+                        {
+                            app.worktree_changes.error = None;
+                        }
+                        invalidate_worktree_changes(&mut worktree_changes);
+                        dirty = true;
+                        urgent = true;
+                    }
+                    Err(err) => {
+                        tracing::warn!(error = %err, "worktree watcher retry failed");
+                        app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                        retry = true;
+                    }
                 }
             }
+            if retry {
+                schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+            }
         }
         if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
             repeat_deadline = None;
@@ -790,6 +925,7 @@ fn event_loop(
             match result {
                 Ok(result) => {
                     let result = result?;
+                    tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
                     decorations = result.decorations;
                     selection_relation = None;
                     app.selection_relation = None;
@@ -848,9 +984,15 @@ fn event_loop(
                         true,
                         line_diff_parallelism,
                     )?;
-                    let (watcher, events) = start_ref_watcher(&repository_path, &repository_path);
-                    ref_watcher = watcher;
-                    ref_events = events;
+                    tracing::warn!(common_dir = %repository_path.display(), "worktree disappeared; recovered with common repository");
+                    ref_watcher = match start_ref_watcher(&repository_path, &repository_path) {
+                        Ok(watcher) => Some(watcher),
+                        Err(err) => {
+                            tracing::warn!(error = %err, "reference watcher recovery failed");
+                            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                            None
+                        }
+                    };
                     app.manual_refresh = ref_watcher.is_none();
                     app.notice = Some("worktree removed; using the common repository without worktree changes".into());
                     open_repository(&repository_path, true, true)
@@ -861,6 +1003,7 @@ fn event_loop(
             let next = history::snapshot(&repository, &revisions, &hide)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed;
+            tracing::debug!(tips_changed, hidden_changed, "compared reference snapshot");
             let select_top = std::mem::take(&mut refresh_from_filesystem);
             ref_snapshot = next;
             refresh_pending = false;
@@ -883,6 +1026,7 @@ fn event_loop(
                 refresh_select_top = select_top;
                 refresh_expand_hidden = false;
                 app.state = State::Loading;
+                tracing::info!(select_top, "started history refresh");
             } else {
                 let next = history::decorations(&repository)?;
                 let relation_changed = selection_relation
@@ -895,6 +1039,7 @@ fn event_loop(
                     app.selection_relation = None;
                     decorations = next;
                     dirty = true;
+                    tracing::debug!(relation_changed, "updated history decorations");
                 }
             }
         }
@@ -999,7 +1144,8 @@ fn event_loop(
         let worktree_timeout = worktree_refresh_deadline
             .map(|deadline| deadline.saturating_duration_since(Instant::now()))
             .or_else(|| worktree_watcher.as_ref().map(|_| REF_EVENT_INTERVAL));
-        let wake_after = [repeat_timeout, watcher_timeout, worktree_timeout]
+        let retry_timeout = watcher_retry_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
+        let wake_after = [repeat_timeout, watcher_timeout, worktree_timeout, retry_timeout]
             .into_iter()
             .flatten()
             .min();
@@ -1092,9 +1238,23 @@ fn event_loop(
             )?;
             if app.changes_mode == Some(ChangesMode::Both) {
                 invalidate_worktree_changes(&mut worktree_changes);
-                worktree_watcher = start_worktree_watcher(&view_repository);
-                if worktree_watcher.is_none() {
-                    app.worktree_changes.error = Some("worktree changes won't update automatically".into());
+                match start_worktree_watcher(&view_repository) {
+                    Ok(watcher) => {
+                        worktree_watcher = Some(watcher);
+                        if app
+                            .worktree_changes
+                            .error
+                            .as_deref()
+                            .is_some_and(|message| message.starts_with("worktree watch:"))
+                        {
+                            app.worktree_changes.error = None;
+                        }
+                    }
+                    Err(err) => {
+                        tracing::warn!(error = %err, "worktree watcher startup failed");
+                        app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                        schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                    }
                 }
             } else if previous_changes_mode == Some(ChangesMode::Both) {
                 worktree_watcher = None;
@@ -1304,19 +1464,12 @@ fn start_history_refresh(
     receiver
 }
 
-fn start_ref_watcher(
-    git_dir: &Path,
-    common_dir: &Path,
-) -> (
-    Option<RecommendedWatcher>,
-    mpsc::Receiver<notify::Result<notify::Event>>,
-) {
-    let (sender, receiver) = mpsc::channel();
-    let Ok(mut watcher) = notify::recommended_watcher(move |event| {
+fn start_ref_watcher(git_dir: &Path, common_dir: &Path) -> Result<RefWatcher> {
+    let (sender, events) = mpsc::channel();
+    let mut watcher = notify::recommended_watcher(move |event| {
         let _ = sender.send(event);
-    }) else {
-        return (None, receiver);
-    };
+    })
+    .context("could not initialize reference watcher")?;
     let mut roots = vec![(common_dir.to_owned(), RecursiveMode::NonRecursive)];
     if git_dir != common_dir {
         roots.push((git_dir.to_owned(), RecursiveMode::NonRecursive));
@@ -1326,15 +1479,23 @@ fn start_ref_watcher(
             roots.push((root, RecursiveMode::Recursive));
         }
     }
-    if roots.into_iter().all(|(path, mode)| watcher.watch(&path, mode).is_ok()) {
-        (Some(watcher), receiver)
-    } else {
-        (None, receiver)
+    for (path, mode) in &roots {
+        watcher
+            .watch(path, *mode)
+            .with_context(|| format!("could not watch references at {}", path.display()))?;
     }
+    tracing::info!(?roots, "watching references");
+    Ok(RefWatcher {
+        _watcher: watcher,
+        events,
+    })
 }
 
-fn start_worktree_watcher(repository: &gix::Repository) -> Option<WorktreeWatcher> {
-    let workdir = repository.workdir()?.to_owned();
+fn start_worktree_watcher(repository: &gix::Repository) -> Result<WorktreeWatcher> {
+    let workdir = repository
+        .workdir()
+        .context("cannot watch a bare repository")?
+        .to_owned();
     let index = repository.index_path();
     let git_dir = repository.git_dir().to_owned();
     let dot_git = workdir.join(gix::discover::DOT_GIT_DIR);
@@ -1342,13 +1503,18 @@ fn start_worktree_watcher(repository: &gix::Repository) -> Option<WorktreeWatche
     let mut watcher = notify::recommended_watcher(move |event| {
         let _ = sender.send(event);
     })
-    .ok()?;
-    watcher.watch(&workdir, RecursiveMode::Recursive).ok()?;
-    let index_parent = index.parent()?;
+    .context("could not initialize worktree watcher")?;
+    watcher
+        .watch(&workdir, RecursiveMode::Recursive)
+        .with_context(|| format!("could not watch worktree at {}", workdir.display()))?;
+    let index_parent = index.parent().context("index path has no parent")?;
     if !index_parent.starts_with(&workdir) {
-        watcher.watch(index_parent, RecursiveMode::NonRecursive).ok()?;
+        watcher
+            .watch(index_parent, RecursiveMode::NonRecursive)
+            .with_context(|| format!("could not watch index at {}", index_parent.display()))?;
     }
-    Some(WorktreeWatcher {
+    tracing::info!(workdir = %workdir.display(), index = %index.display(), "watching worktree changes");
+    Ok(WorktreeWatcher {
         _watcher: watcher,
         events,
         workdir,
@@ -1358,10 +1524,15 @@ fn start_worktree_watcher(repository: &gix::Repository) -> Option<WorktreeWatche
     })
 }
 
-fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) {
+fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) -> bool {
     if let Some((marker, _)) = changes {
+        if *marker == usize::MAX {
+            return false;
+        }
         *marker = usize::MAX;
+        return true;
     }
+    false
 }
 
 fn visible_decorations_changed(old: &Decorations, new: &Decorations, rows: &[CommitRow]) -> bool {
@@ -1576,6 +1747,7 @@ fn draw(
             *tree_changes = Some((id, app.changes_parent, loaded));
         }
         if worktree_changes_to_load {
+            let started = Instant::now();
             repository.object_cache_size(OBJECT_CACHE_SIZE);
             let loaded = load_worktree_changes(
                 repository,
@@ -1586,10 +1758,23 @@ fn draw(
             repository.object_cache_size(None);
             match loaded {
                 Ok(loaded) => {
-                    app.worktree_changes.error = None;
+                    tracing::debug!(
+                        path_count = loaded.paths.len(),
+                        elapsed_ms = started.elapsed().as_millis(),
+                        "loaded worktree changes"
+                    );
+                    if !app
+                        .worktree_changes
+                        .error
+                        .as_deref()
+                        .is_some_and(|message| message.starts_with("worktree watch:"))
+                    {
+                        app.worktree_changes.error = None;
+                    }
                     *worktree_changes = Some((0, loaded));
                 }
                 Err(err) => {
+                    tracing::warn!(error = %err, "could not load worktree changes");
                     app.worktree_changes.error = Some(format!("status: {err:#}"));
                     if let Some((marker, _)) = worktree_changes.as_mut() {
                         *marker = 0;
@@ -3459,7 +3644,7 @@ mod tests {
 
     #[test]
     fn filters_worktree_watch_events_and_invalidates_cached_status() {
-        use notify::event::{AccessKind, ModifyKind};
+        use notify::event::{AccessKind, Flag, ModifyKind};
 
         let workdir = Path::new("/repo");
         let dot_git = workdir.join(".git");
@@ -3493,9 +3678,43 @@ mod tests {
         assert!(!worktree_event_is_relevant(
             &access, workdir, &dot_git, &git_dir, &index
         ));
+        assert!(!notification_is_actionable(&access));
+        let rescan = notify::Event::new(notify::EventKind::Other).set_flag(Flag::Rescan);
+        assert!(worktree_event_is_relevant(&rescan, workdir, &dot_git, &git_dir, &index));
+        assert!(notification_is_actionable(&rescan));
 
         let mut changes = Some((0, Changes::default()));
-        invalidate_worktree_changes(&mut changes);
+        assert!(invalidate_worktree_changes(&mut changes));
         assert_eq!(changes.as_ref().map(|(marker, _)| *marker), Some(usize::MAX));
+        assert!(!invalidate_worktree_changes(&mut changes));
+    }
+
+    #[test]
+    fn starts_worktree_watching_for_the_combined_view() {
+        assert!(worktree_watcher_needed(false, Some(ChangesMode::Both)));
+        assert!(!worktree_watcher_needed(false, Some(ChangesMode::Tree)));
+        assert!(!worktree_watcher_needed(false, None));
+        assert!(!worktree_watcher_needed(true, Some(ChangesMode::Both)));
+    }
+
+    #[test]
+    fn event_deadlines_coalesce_without_extending_and_can_be_retried() {
+        let now = Instant::now();
+        let mut deadline = None;
+        assert!(schedule_once(&mut deadline, now, WORKTREE_EVENT_IDLE));
+        let first = deadline;
+        assert!(!schedule_once(
+            &mut deadline,
+            now + Duration::from_millis(50),
+            WORKTREE_EVENT_IDLE
+        ));
+        assert_eq!(deadline, first, "later events do not extend the debounce window");
+        assert!(!take_due(&mut deadline, now + Duration::from_millis(74)));
+        assert!(take_due(&mut deadline, now + WORKTREE_EVENT_IDLE));
+        assert_eq!(deadline, None);
+
+        assert!(schedule_once(&mut deadline, now, WATCH_RETRY_INTERVAL));
+        assert!(!take_due(&mut deadline, now + Duration::from_secs(4)));
+        assert!(take_due(&mut deadline, now + WATCH_RETRY_INTERVAL));
     }
 }

From 228854b90e1c52fe12b2840cdb468ce58c778461 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 17:17:58 +0200
Subject: [PATCH 025/282] fix: retain changed-path selection across refreshes

Preserve the selected path and its relative viewport position when filesystem notifications reload tree or worktree changes. Fall back to the previous numeric position, clamped by layout, only when the selected path disappeared.
---
 gix-tix/src/lib.rs | 63 +++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 60 insertions(+), 3 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 9bc3ba1a8d6..8e329818d22 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1606,6 +1606,25 @@ fn count_exclusive_commits(repo: &gix::Repository, tip: gix::ObjectId, hidden: g
     })
 }
 
+fn remembered_change_selection(view: &app::ChangesView, changes: Option<&Changes>) -> Option<(BString, usize)> {
+    changes.and_then(|changes| {
+        changes
+            .paths
+            .get(view.selected)
+            .map(|change| (change.path.clone(), view.selected.saturating_sub(view.offset)))
+    })
+}
+
+fn restore_change_selection(view: &mut app::ChangesView, changes: &Changes, remembered: Option<(BString, usize)>) {
+    let Some((path, viewport_row)) = remembered else {
+        return;
+    };
+    if let Some(selected) = changes.paths.iter().position(|change| change.path == path) {
+        view.selected = selected;
+        view.offset = selected.saturating_sub(viewport_row);
+    }
+}
+
 #[expect(clippy::too_many_arguments, reason = "drawing needs the complete view state")]
 fn draw(
     terminal: &mut ratatui::DefaultTerminal,
@@ -1687,9 +1706,17 @@ fn draw(
         && worktree_changes
             .as_ref()
             .is_none_or(|(marker, _)| *marker == usize::MAX);
-    if tree_changes_to_load.is_some() || worktree_changes_to_load {
-        app.reset_changes_view();
-    }
+    let tree_selection = tree_changes_to_load.and_then(|_| {
+        remembered_change_selection(&app.tree_changes, tree_changes.as_ref().map(|(_, _, changes)| changes))
+    });
+    let worktree_selection = worktree_changes_to_load
+        .then(|| {
+            remembered_change_selection(
+                &app.worktree_changes,
+                worktree_changes.as_ref().map(|(_, changes)| changes),
+            )
+        })
+        .flatten();
     if !app.show_commit || selected.is_none() {
         *commit_message = None;
     }
@@ -1744,6 +1771,7 @@ fn draw(
             repository.object_cache_size(None);
             let loaded = loaded?;
             app.changes_parent = loaded.parent.map_or(0, |parent| parent.index);
+            restore_change_selection(&mut app.tree_changes, &loaded, tree_selection);
             *tree_changes = Some((id, app.changes_parent, loaded));
         }
         if worktree_changes_to_load {
@@ -1771,6 +1799,7 @@ fn draw(
                     {
                         app.worktree_changes.error = None;
                     }
+                    restore_change_selection(&mut app.worktree_changes, &loaded, worktree_selection);
                     *worktree_changes = Some((0, loaded));
                 }
                 Err(err) => {
@@ -3697,6 +3726,34 @@ mod tests {
         assert!(!worktree_watcher_needed(true, Some(ChangesMode::Both)));
     }
 
+    #[test]
+    fn restores_changed_path_selection_after_reordering() {
+        let path = |path: &str| PathChange {
+            kind: ChangeKind::Modified,
+            group: ChangeGroup::Unstaged,
+            source: None,
+            path: path.into(),
+            lines: None,
+        };
+        let previous = Changes {
+            paths: ["a", "b", "selected"].into_iter().map(path).collect(),
+            ..Changes::default()
+        };
+        let mut view = app::ChangesView::default();
+        view.selected = 2;
+        view.offset = 1;
+        let remembered = remembered_change_selection(&view, Some(&previous));
+        let refreshed = Changes {
+            paths: ["x", "y", "z", "selected"].into_iter().map(path).collect(),
+            ..Changes::default()
+        };
+
+        restore_change_selection(&mut view, &refreshed, remembered);
+
+        assert_eq!(view.selected, 3, "the same path remains selected");
+        assert_eq!(view.offset, 2, "the path retains its relative viewport row");
+    }
+
     #[test]
     fn event_deadlines_coalesce_without_extending_and_can_be_retried() {
         let now = Instant::now();

From 38c3dd73b967fd076b564959bf206630c1c17341 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 17:21:32 +0200
Subject: [PATCH 026/282] fix: release idle tix repository handles

Remove the long-lived view repository and notes platform from the event loop because both retained object database pack handles while tix was idle. Open repositories only for bounded view population and watcher setup, then retain detached mailmap, note, and reference data.

Document repository lifetime as a local gix-tix invariant so future panes and platforms do not accidentally reintroduce persistent repository ownership.
---
 gix-tix/AGENTS.md  |   8 ++
 gix-tix/src/lib.rs | 250 +++++++++++++++++++++++++--------------------
 2 files changed, 147 insertions(+), 111 deletions(-)
 create mode 100644 gix-tix/AGENTS.md

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
new file mode 100644
index 00000000000..b3c339703dd
--- /dev/null
+++ b/gix-tix/AGENTS.md
@@ -0,0 +1,8 @@
+# gix-tix invariants
+
+## Repository lifetime
+
+- Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle.
+- Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
+- The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
+- Filesystem watchers retain paths and native watcher handles, never repositories.
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8e329818d22..b9eecec27db 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -153,19 +153,33 @@ pub(crate) enum FileChange {
     Unavailable(&'static str),
 }
 
-type LineDiffResult = (usize, FileChange, Result<LineCounts>);
-
 struct LineDiffJob {
     index: usize,
     change: FileChange,
 }
 
+enum LineDiffMessage {
+    Job(LineDiffJob),
+    FinishBatch,
+}
+
+enum LineDiffResult {
+    Change(usize, FileChange, Result<LineCounts>),
+    BatchFinished,
+}
+
 struct LineDiffPool {
-    jobs: Option<mpsc::Sender<LineDiffJob>>,
+    jobs: Vec<mpsc::Sender<LineDiffMessage>>,
     results: mpsc::Receiver<LineDiffResult>,
     workers: Vec<std::thread::JoinHandle<()>>,
 }
 
+type LineDiffState = (
+    gix::Repository,
+    gix::diff::blob::Platform,
+    Option<gix::diff::blob::Platform>,
+);
+
 fn worktree_diff_cache(
     repository: &gix::Repository,
     mode: gix::diff::blob::pipeline::Mode,
@@ -240,79 +254,106 @@ fn line_counts_for_change(
     Ok(counts.map(|counts| (counts.insertions, counts.removals)))
 }
 
+fn open_line_diff_state(repository_path: &Path, bare: bool) -> Result<LineDiffState> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository for parallel line diffs")?;
+    repository.object_cache_size(OBJECT_CACHE_SIZE);
+    let tree_cache = repository
+        .diff_resource_cache_for_tree_diff()
+        .context("could not initialize parallel line diffs")?;
+    let worktree_cache = if bare {
+        None
+    } else {
+        worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)?
+    };
+    Ok((repository, tree_cache, worktree_cache))
+}
+
 impl LineDiffPool {
     fn new(repository_path: &Path, bare: bool, parallelism: usize) -> Result<Self> {
-        let repository = open_repository(repository_path, bare, false)
-            .context("could not open repository for parallel line diffs")?
-            .into_sync();
-        let mut worker_state = Vec::with_capacity(parallelism);
-        for _ in 0..parallelism {
-            let mut repository = repository.to_thread_local();
-            repository.object_cache_size(OBJECT_CACHE_SIZE);
-            let tree_cache = repository
-                .diff_resource_cache_for_tree_diff()
-                .context("could not initialize parallel line diffs")?;
-            let worktree_cache = if bare {
-                None
-            } else {
-                worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)?
-            };
-            worker_state.push((repository, tree_cache, worktree_cache));
-        }
-
-        let (jobs, job_receiver) = mpsc::channel::<LineDiffJob>();
-        let job_receiver =
-            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(job_receiver));
+        drop(open_line_diff_state(repository_path, bare)?);
         let (result_sender, results) = mpsc::channel();
-        let workers = worker_state
-            .into_iter()
-            .map(|(repository, mut tree_cache, mut worktree_cache)| {
-                let job_receiver = gix::features::threading::OwnShared::clone(&job_receiver);
+        let mut jobs = Vec::with_capacity(parallelism);
+        let workers = (0..parallelism)
+            .map(|_| {
+                let (job_sender, job_receiver) = mpsc::channel();
+                jobs.push(job_sender);
                 let result_sender = result_sender.clone();
+                let repository_path = repository_path.to_owned();
                 std::thread::spawn(move || {
-                    loop {
-                        let Ok(job) = gix::features::threading::lock(&job_receiver).recv() else {
-                            break;
-                        };
-                        let result =
-                            line_counts_for_change(&repository, &job.change, &mut tree_cache, worktree_cache.as_mut());
-                        tree_cache.clear_resource_cache_keep_allocation();
-                        if let Some(cache) = worktree_cache.as_mut() {
-                            cache.clear_resource_cache_keep_allocation();
-                        }
-                        if result_sender.send((job.index, job.change, result)).is_err() {
-                            break;
+                    let mut state: Option<LineDiffState> = None;
+                    while let Ok(message) = job_receiver.recv() {
+                        match message {
+                            LineDiffMessage::Job(job) => {
+                                let result = (|| {
+                                    if state.is_none() {
+                                        state = Some(open_line_diff_state(&repository_path, bare)?);
+                                    }
+                                    let (repository, tree_cache, worktree_cache) =
+                                        state.as_mut().expect("line diff state was just initialized");
+                                    let result = line_counts_for_change(
+                                        repository,
+                                        &job.change,
+                                        tree_cache,
+                                        worktree_cache.as_mut(),
+                                    );
+                                    tree_cache.clear_resource_cache_keep_allocation();
+                                    if let Some(cache) = worktree_cache.as_mut() {
+                                        cache.clear_resource_cache_keep_allocation();
+                                    }
+                                    result
+                                })();
+                                if result_sender
+                                    .send(LineDiffResult::Change(job.index, job.change, result))
+                                    .is_err()
+                                {
+                                    break;
+                                }
+                            }
+                            LineDiffMessage::FinishBatch => {
+                                state = None;
+                                if result_sender.send(LineDiffResult::BatchFinished).is_err() {
+                                    break;
+                                }
+                            }
                         }
                     }
                 })
             })
             .collect();
-        Ok(LineDiffPool {
-            jobs: Some(jobs),
-            results,
-            workers,
-        })
+        Ok(LineDiffPool { jobs, results, workers })
     }
 
     fn line_counts(&mut self, changes: Vec<FileChange>) -> Result<Vec<(FileChange, LineCounts)>> {
         let len = changes.len();
-        let jobs = self.jobs.as_ref().context("line diff pool is shutting down")?;
+        let worker_count = self.jobs.len();
         for (index, change) in changes.into_iter().enumerate() {
-            jobs.send(LineDiffJob { index, change })
+            self.jobs[index % worker_count]
+                .send(LineDiffMessage::Job(LineDiffJob { index, change }))
+                .context("line diff workers stopped unexpectedly")?;
+        }
+        for jobs in &self.jobs {
+            jobs.send(LineDiffMessage::FinishBatch)
                 .context("line diff workers stopped unexpectedly")?;
         }
 
         let mut out: Vec<_> = std::iter::repeat_with(|| None).take(len).collect();
         let mut first_error = None;
-        for _ in 0..len {
-            let (index, change, result) = self.results.recv().context("line diff workers stopped unexpectedly")?;
-            match result {
-                Ok(lines) => {
-                    *out.get_mut(index)
-                        .context("line diff worker returned an invalid result index")? = Some((change, lines));
+        let mut completed = 0;
+        let mut finished = 0;
+        while completed < len || finished < worker_count {
+            match self.results.recv().context("line diff workers stopped unexpectedly")? {
+                LineDiffResult::Change(index, change, Ok(lines)) => {
+                    *out.get_mut(index).expect("jobs preserve their original result index") = Some((change, lines));
+                    completed += 1;
+                }
+                LineDiffResult::Change(_, _, Err(err)) => {
+                    if first_error.is_none() {
+                        first_error = Some(err);
+                    }
+                    completed += 1;
                 }
-                Err(err) if first_error.is_none() => first_error = Some(err),
-                Err(_) => {}
+                LineDiffResult::BatchFinished => finished += 1,
             }
         }
         if let Some(err) = first_error {
@@ -326,7 +367,7 @@ impl LineDiffPool {
 
 impl Drop for LineDiffPool {
     fn drop(&mut self) {
-        drop(self.jobs.take());
+        self.jobs.clear();
         for worker in self.workers.drain(..) {
             drop(worker.join());
         }
@@ -650,21 +691,20 @@ fn event_loop(
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
-    let mut repository_is_bare = view_repository.workdir().is_none();
+    view_repository.object_cache_size(None);
+    let (mut repository_is_bare, mut mailmap, mut ref_snapshot) = {
+        let bare = view_repository.workdir().is_none();
+        let mailmap = view_repository.open_mailmap();
+        let refs = history::snapshot(&view_repository, &revisions, &hide)?;
+        (bare, mailmap, refs)
+    };
     if recovered_at_startup {
         repository = view_repository.into_sync();
         repository_is_bare = true;
-        view_repository = open_repository(&repository_path, true, false)
-            .context("could not reopen common repository for history metadata")?;
+    } else {
+        drop(view_repository);
     }
-    view_repository.object_cache_size(None);
-    let mut mailmap = view_repository.open_mailmap();
-    let mut notes = view_repository
-        .notes()
-        .map_err(gix::Exn::into_error)
-        .context("could not open Git notes")?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-    let mut ref_snapshot = history::snapshot(&view_repository, &revisions, &hide)?;
     let mut watcher_retry_deadline = None;
     let mut ref_watcher = match start_ref_watcher(&repository_path, &common_dir) {
         Ok(watcher) => Some(watcher),
@@ -718,7 +758,7 @@ fn event_loop(
         line_diff_parallelism,
     )?;
     if worktree_watcher_needed(repository_is_bare, app.changes_mode) {
-        match start_worktree_watcher(&view_repository) {
+        match start_worktree_watcher(&repository_path, repository_is_bare) {
             Ok(watcher) => worktree_watcher = Some(watcher),
             Err(err) => {
                 tracing::warn!(error = %err, "worktree watcher startup failed");
@@ -735,7 +775,6 @@ fn event_loop(
         &mailmap,
         &authors,
         &mut fill_repository,
-        &mut notes,
         &mut commit_message,
         &mut tree_changes,
         &mut worktree_changes,
@@ -849,7 +888,7 @@ fn event_loop(
                 }
             }
             if worktree_watcher_needed(repository_is_bare, app.changes_mode) && worktree_watcher.is_none() {
-                match start_worktree_watcher(&view_repository) {
+                match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => {
                         tracing::info!("worktree watcher recovered");
                         worktree_watcher = Some(watcher);
@@ -963,11 +1002,6 @@ fn event_loop(
                     repository_path.clone_from(&common_dir);
                     repository_is_bare = true;
                     mailmap = recovered.open_mailmap();
-                    notes = recovered
-                        .notes()
-                        .map_err(gix::Exn::into_error)
-                        .context("could not reopen Git notes after worktree removal")?;
-                    view_repository = recovered;
                     fill_repository.path.clone_from(&repository_path);
                     fill_repository.bare = true;
                     fill_repository.retain = false;
@@ -995,8 +1029,7 @@ fn event_loop(
                     };
                     app.manual_refresh = ref_watcher.is_none();
                     app.notice = Some("worktree removed; using the common repository without worktree changes".into());
-                    open_repository(&repository_path, true, true)
-                        .context("could not inspect common repository references")?
+                    recovered
                 }
                 Err(err) => return Err(err).context("could not inspect changed references"),
             };
@@ -1051,7 +1084,6 @@ fn event_loop(
                 &mailmap,
                 &authors,
                 &mut fill_repository,
-                &mut notes,
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
@@ -1129,7 +1161,6 @@ fn event_loop(
                 &mailmap,
                 &authors,
                 &mut fill_repository,
-                &mut notes,
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
@@ -1238,7 +1269,7 @@ fn event_loop(
             )?;
             if app.changes_mode == Some(ChangesMode::Both) {
                 invalidate_worktree_changes(&mut worktree_changes);
-                match start_worktree_watcher(&view_repository) {
+                match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => {
                         worktree_watcher = Some(watcher);
                         if app
@@ -1275,7 +1306,6 @@ fn event_loop(
                 }
                 Effect::Reload(show_hidden) => {
                     app.show_hidden = show_hidden;
-                    notes = open_notes(&repository_path, repository_is_bare)?;
                     refresh_pending = true;
                     refresh_expand_hidden = true;
                 }
@@ -1347,7 +1377,6 @@ fn event_loop(
             &mailmap,
             &authors,
             &mut fill_repository,
-            &mut notes,
             &mut commit_message,
             &mut tree_changes,
             &mut worktree_changes,
@@ -1491,7 +1520,9 @@ fn start_ref_watcher(git_dir: &Path, common_dir: &Path) -> Result<RefWatcher> {
     })
 }
 
-fn start_worktree_watcher(repository: &gix::Repository) -> Result<WorktreeWatcher> {
+fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<WorktreeWatcher> {
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not open repository for worktree watcher setup")?;
     let workdir = repository
         .workdir()
         .context("cannot watch a bare repository")?
@@ -1633,7 +1664,6 @@ fn draw(
     mailmap: &gix::mailmap::Snapshot,
     authors: &SharedAuthors,
     fill_repository: &mut FillRepository,
-    notes: &mut gix::note::Platform,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     tree_changes: &mut Option<(gix::ObjectId, usize, Changes)>,
     worktree_changes: &mut Option<(usize, Changes)>,
@@ -1652,23 +1682,11 @@ fn draw(
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(render_rows).min(app.rows.len());
-    for index in start..end {
-        let id = app.rows[index].id;
-        if app.notes_loaded(id) {
-            continue;
-        }
-        let loaded = notes
-            .get(id)
-            .map_err(gix::Exn::into_error)
-            .context("could not load visible commit notes")?
-            .into_iter()
-            .map(|note| {
-                let mut blob = note.blob;
-                BString::from(blob.take_data())
-            })
-            .collect();
-        app.set_notes(id, loaded);
-    }
+    let notes_to_load: Vec<_> = app.rows[start..end]
+        .iter()
+        .map(|row| row.id)
+        .filter(|id| !app.notes_loaded(*id))
+        .collect();
     let changes_visible = app.changes_visible();
     let selected_id = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
     app.selection_relation = selection_cache
@@ -1724,7 +1742,8 @@ fn draw(
         *tree_changes = None;
         *worktree_changes = None;
     }
-    if app.rows[start..end].iter().any(|row| !row.metadata_loaded)
+    if !notes_to_load.is_empty()
+        || app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
         || tree_changes_to_load.is_some()
         || worktree_changes_to_load
@@ -1739,6 +1758,25 @@ fn draw(
         } else {
             one_shot_repository.insert(open_fill_repository(&fill_repository.path, fill_repository.bare)?)
         };
+        if !notes_to_load.is_empty() {
+            let mut notes = repository
+                .notes()
+                .map_err(gix::Exn::into_error)
+                .context("could not open Git notes")?;
+            for id in notes_to_load {
+                let loaded = notes
+                    .get(id)
+                    .map_err(gix::Exn::into_error)
+                    .context("could not load visible commit notes")?
+                    .into_iter()
+                    .map(|note| {
+                        let mut blob = note.blob;
+                        BString::from(blob.take_data())
+                    })
+                    .collect();
+                app.set_notes(id, loaded);
+            }
+        }
         for index in start..end {
             if app.rows[index].metadata_loaded {
                 continue;
@@ -1888,16 +1926,6 @@ fn open_fill_repository(repository_path: &Path, bare: bool) -> Result<gix::Repos
     Ok(repository)
 }
 
-fn open_notes(repository_path: &Path, bare: bool) -> Result<gix::note::Platform> {
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not open repository for Git notes")?;
-    repository.object_cache_size(None);
-    repository
-        .notes()
-        .map_err(gix::Exn::into_error)
-        .context("could not open Git notes")
-}
-
 fn prepare_file_diff(repository_path: &Path, bare: bool, change: &FileChange, path: &PathChange) -> Result<FileDiff> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for file diff")?;

From 23ed897285aaf457cc5c601e3d5003626abaaf00 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 05:38:25 +0200
Subject: [PATCH 027/282] Document agent authorship for tix changes
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Require commits created or materially rewritten by an AI agent to use that agent’s own author identity instead of silently inheriting the repository owner’s identity. Preserve existing authorship and permit a different identity only when the user explicitly requests it for the particular commit.

This makes commit provenance reviewable while keeping explicit authorship decisions under the user’s control.
---
 gix-tix/AGENTS.md | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index b3c339703dd..9ba5c27f400 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -1,5 +1,12 @@
 # gix-tix invariants
 
+## Commit authorship
+
+- A commit created or materially rewritten by an AI agent must use that agent's own name and email as its author. Do not silently inherit the repository owner's configured identity.
+- Preserve the author of an existing commit when the agent is not responsible for its contents.
+- Use another author's identity only when the user explicitly requests it for that particular commit.
+- Keep this provenance in commit metadata so reviewers can distinguish agent-authored changes without relying on commit-message trailers.
+
 ## Repository lifetime
 
 - Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle.

From ad7bf64387aed49d4030ed0421fae0fd89f3fc11 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 17:42:43 +0200
Subject: [PATCH 028/282] fix: keep tix ancestry comparisons in its cached
 graph

Replace the main history rev-walk with a traversal that retains detached parent, generation, and commit-time data while streaming visible rows. Reverse-index local branches and, when their visible target is encountered, resolve configured upstreams and schedule both sides of each tracking relationship as internal-only traversal tips.

Computing both sides through hidden frontiers ensures ahead/behind painting always sees complete ancestry. Compute ahead/behind and hidden-history counts with a bounded two-color paint over this in-memory graph instead of opening a repository and traversing object history whenever the selection changes. Cache completed relationships and preserve shallow, hidden-boundary, commit-graph, and deferred-metadata behavior.

Move the graph through filesystem refresh workers and stop new walks at any complete cached ancestry, including upstream-only history. Give explicit hidden-history expansion its own traversal state so topology-only cached commits become display rows until already-materialized ancestry is reached, without adding commits reachable only from a hidden tip.

This lets ref changes append to the existing graph without retraversing known commits, makes show-hidden restore the original view, and still drops every repository and commit-graph handle when its worker finishes.
---
 gix-tix/src/app.rs     |   46 --
 gix-tix/src/history.rs | 1061 +++++++++++++++++++++++++++++++++++-----
 gix-tix/src/lib.rs     |  246 ++++------
 3 files changed, 1031 insertions(+), 322 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7ab678cc110..22f1b2b824f 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -815,34 +815,10 @@ impl App {
         }
     }
 
-    pub(crate) fn known_ids(&self) -> HashSet<ObjectId> {
-        self.all_rows.keys().copied().collect()
-    }
-
     pub(crate) fn hidden_ids(&self) -> HashSet<ObjectId> {
         self.hidden_rows.clone()
     }
 
-    pub(crate) fn visible_ancestry_to_hidden(&self, tip: ObjectId) -> Option<usize> {
-        let mut pending = vec![tip];
-        let mut seen = HashSet::new();
-        let mut visible = 0;
-        let mut reached_hidden = false;
-        while let Some(id) = pending.pop() {
-            if !seen.insert(id) {
-                continue;
-            }
-            if self.hidden_rows.contains(&id) {
-                reached_hidden = true;
-                continue;
-            }
-            let Some(row) = self.all_rows.get(&id) else { continue };
-            visible += 1;
-            pending.extend(row.parent_ids.iter().copied());
-        }
-        reached_hidden.then_some(visible)
-    }
-
     pub(crate) fn start_refresh(
         &mut self,
         commits: LoadedCommits,
@@ -1800,28 +1776,6 @@ mod tests {
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
     }
 
-    #[test]
-    fn counts_distinct_visible_ancestry_only_when_it_reaches_hidden_history() {
-        let mut app = App::new(10);
-        app.extend_commits(vec![
-            row_with_parents(4, &[3, 2]),
-            row_with_parents(3, &[1]),
-            row_with_parents(2, &[1]),
-        ]);
-        app.extend_hidden_commits(vec![row(1)]);
-
-        assert_eq!(app.visible_ancestry_to_hidden(id(4)), Some(3));
-        assert_eq!(app.visible_ancestry_to_hidden(id(3)), Some(1));
-        assert_eq!(app.visible_ancestry_to_hidden(id(1)), Some(0));
-
-        app.hidden_rows.clear();
-        assert_eq!(
-            app.visible_ancestry_to_hidden(id(4)),
-            None,
-            "without hidden history the fallback count has no useful base"
-        );
-    }
-
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index e33550a5793..c8d888a9c5c 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1,4 +1,5 @@
 use std::{
+    cmp::Ordering as CmpOrdering,
     collections::{HashMap, HashSet},
     ffi::OsString,
     sync::atomic::{AtomicBool, Ordering},
@@ -37,6 +38,448 @@ pub(crate) enum DecorationKind {
 
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct SelectionRef {
+    pub name: BString,
+    pub upstream: Option<Option<ObjectId>>,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Node {
+    complete: bool,
+    stored: bool,
+    flags: u8,
+    expanded: u8,
+    emitted: bool,
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct HistoryGraph {
+    commits: gix::revwalk::graph::IdMap<gix::revwalk::graph::Commit<Node>>,
+    tracking: HashMap<ObjectId, Vec<SelectionRef>>,
+    relations: HashMap<(ObjectId, ObjectId), (usize, usize)>,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+struct GenThenTime {
+    generation: gix::revwalk::graph::Generation,
+    time: gix::date::SecondsSinceUnixEpoch,
+}
+
+impl From<&gix::revwalk::graph::Commit<Node>> for GenThenTime {
+    fn from(commit: &gix::revwalk::graph::Commit<Node>) -> Self {
+        GenThenTime {
+            generation: commit
+                .generation
+                .unwrap_or(gix::commitgraph::GENERATION_NUMBER_INFINITY),
+            time: commit.commit_time,
+        }
+    }
+}
+
+impl Ord for GenThenTime {
+    fn cmp(&self, other: &Self) -> CmpOrdering {
+        self.generation.cmp(&other.generation).then(self.time.cmp(&other.time))
+    }
+}
+
+impl PartialOrd for GenThenTime {
+    fn partial_cmp(&self, other: &Self) -> Option<CmpOrdering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl HistoryGraph {
+    fn ensure_commit(
+        &mut self,
+        repo: &gix::Repository,
+        cache: Option<&gix::commitgraph::Graph>,
+        shallow: &HashSet<ObjectId>,
+        id: ObjectId,
+        buf: &mut Vec<u8>,
+    ) -> Result<()> {
+        if self.commits.contains_key(&id) {
+            return Ok(());
+        }
+        let commit = gix::traverse::commit::find(cache, &repo.objects, &id, buf)
+            .context("could not load commit for cached history traversal")?;
+        let (mut parents, commit_time, generation) = match commit {
+            gix::traverse::commit::Either::CommitRefIter(iter) => {
+                let mut parents = gix::traverse::commit::ParentIds::new();
+                let mut commit_time = 0;
+                for token in iter {
+                    match token.context("could not decode cached history commit")? {
+                        Token::Tree { .. } => {}
+                        Token::Parent { id } => parents.push(id),
+                        Token::Committer { signature } => {
+                            commit_time = signature.seconds();
+                            break;
+                        }
+                        _ => {}
+                    }
+                }
+                (parents, commit_time, None)
+            }
+            gix::traverse::commit::Either::CachedCommit(commit) => {
+                let cache = cache.expect("cached commits originate from the provided commit-graph");
+                let mut parents = gix::traverse::commit::ParentIds::new();
+                for parent in commit.iter_parents() {
+                    let parent =
+                        parent.map_err(|err| anyhow::anyhow!("could not decode commit-graph parent: {err}"))?;
+                    parents.push(cache.id_at(parent).to_owned());
+                }
+                (
+                    parents,
+                    commit.committer_timestamp() as gix::date::SecondsSinceUnixEpoch,
+                    Some(commit.generation()),
+                )
+            }
+        };
+        if shallow.contains(&id) {
+            parents.clear();
+        }
+        self.commits.insert(
+            id,
+            gix::revwalk::graph::Commit {
+                parents,
+                commit_time,
+                generation,
+                data: Node::default(),
+            },
+        );
+        Ok(())
+    }
+
+    #[expect(clippy::too_many_arguments)]
+    fn schedule_cached(
+        &mut self,
+        repo: &gix::Repository,
+        cache: Option<&gix::commitgraph::Graph>,
+        shallow: &HashSet<ObjectId>,
+        states: &mut HashMap<ObjectId, WalkState>,
+        queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, ObjectId>,
+        buf: &mut Vec<u8>,
+        id: ObjectId,
+        flags: u8,
+    ) -> Result<()> {
+        self.ensure_commit(repo, cache, shallow, id, buf)?;
+        let state = states.entry(id).or_default();
+        if state.flags & flags != flags {
+            state.flags |= flags;
+            queue.insert(self.commits[&id].commit_time, id);
+        }
+        Ok(())
+    }
+
+    pub(crate) fn selection_refs(&self, id: ObjectId, decorations: &Decorations) -> Vec<SelectionRef> {
+        let tracked = self.tracking.get(&id);
+        let mut refs: Vec<_> = decorations
+            .get(&id)
+            .into_iter()
+            .flatten()
+            .map(|decoration| {
+                let upstream = if decoration.kind == DecorationKind::Local {
+                    tracked
+                        .into_iter()
+                        .flatten()
+                        .find(|reference| reference.name == decoration.name)
+                        .and_then(|reference| reference.upstream)
+                } else {
+                    None
+                };
+                SelectionRef {
+                    name: decoration.name.clone(),
+                    upstream,
+                }
+            })
+            .collect();
+        refs.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.upstream.cmp(&b.upstream)));
+        refs
+    }
+
+    pub(crate) fn selection_relation(
+        &mut self,
+        id: ObjectId,
+        refs: &[SelectionRef],
+        hidden: &[ObjectId],
+    ) -> Option<crate::app::SelectionRelation> {
+        let has_upstream = refs.iter().any(|reference| reference.upstream.is_some());
+        for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
+            let relation = if let Some(relation) = self.relations.get(&(id, upstream)).copied() {
+                Some(relation)
+            } else {
+                let relation = self.paint(id, std::slice::from_ref(&upstream))?;
+                self.relations.insert((id, upstream), relation);
+                Some(relation)
+            };
+            if let Some((ahead, behind)) = relation {
+                return Some(crate::app::SelectionRelation::Tracking { ahead, behind });
+            }
+        }
+        if has_upstream || refs.is_empty() || hidden.is_empty() {
+            return None;
+        }
+        self.paint(id, hidden)
+            .map(|(visible, _)| crate::app::SelectionRelation::Visible(visible))
+    }
+
+    fn paint(&self, first: ObjectId, others: &[ObjectId]) -> Option<(usize, usize)> {
+        if !self.commits.contains_key(&first) || others.iter().any(|id| !self.commits.contains_key(id)) {
+            return None;
+        }
+        let mut flags = HashMap::<ObjectId, u8>::new();
+        let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, ObjectId>::new();
+        let mut queued = HashSet::new();
+        let mut pending = 0usize;
+        for (id, flag) in std::iter::once((first, VISIBLE)).chain(others.iter().copied().map(|id| (id, HIDDEN))) {
+            *flags.entry(id).or_default() |= flag;
+            if queued.insert(id) {
+                queue.insert(GenThenTime::from(&self.commits[&id]), id);
+                pending += 1;
+            }
+        }
+        while pending != 0 {
+            let Some((_priority, id)) = queue.pop() else { break };
+            queued.remove(&id);
+            let mut propagated = flags[&id];
+            if propagated & STALE == 0 {
+                pending -= 1;
+            }
+            if propagated & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN {
+                propagated |= STALE;
+                *flags.get_mut(&id).expect("queued commits have flags") = propagated;
+            }
+            for &parent in &self.commits[&id].parents {
+                let Some(commit) = self.commits.get(&parent) else {
+                    continue;
+                };
+                let parent_flags = flags.entry(parent).or_default();
+                let previous = *parent_flags;
+                if previous & propagated != propagated {
+                    *parent_flags = previous | propagated;
+                    if queued.contains(&parent) {
+                        if previous & STALE == 0 && *parent_flags & STALE != 0 {
+                            pending -= 1;
+                        }
+                    } else {
+                        queued.insert(parent);
+                        if *parent_flags & STALE == 0 {
+                            pending += 1;
+                        }
+                        queue.insert(GenThenTime::from(commit), parent);
+                    }
+                }
+            }
+        }
+        let mut ahead = 0;
+        let mut behind = 0;
+        for flags in flags.into_values() {
+            match flags & (VISIBLE | HIDDEN) {
+                VISIBLE => ahead += 1,
+                HIDDEN => behind += 1,
+                _ => {}
+            }
+        }
+        Some((ahead, behind))
+    }
+
+    pub(crate) fn refresh(
+        &mut self,
+        repo: &gix::Repository,
+        revisions: &[OsString],
+        hidden_revisions: &[OsString],
+        expand: &HashSet<ObjectId>,
+        authors: &SharedAuthors,
+    ) -> Result<Refresh> {
+        let refs = snapshot(repo, revisions, hidden_revisions)?;
+        let shallow: HashSet<_> = repo
+            .shallow_commits()
+            .context("could not read shallow commits")?
+            .into_iter()
+            .flat_map(|commits| commits.iter().copied().collect::<Vec<_>>())
+            .collect();
+        let cache = repo
+            .commit_graph_if_enabled()
+            .context("could not open commit-graph for history refresh")?;
+        let local_refs = local_refs_by_target(repo)?;
+        let mut tracking = HashMap::new();
+        let mut states = HashMap::<ObjectId, WalkState>::new();
+        let mut queue = gix::revwalk::PriorityQueue::new();
+        let mut buf = Vec::new();
+        for id in refs.view_tips.iter().chain(&refs.hidden_tips).copied() {
+            self.schedule_cached(
+                repo,
+                cache.as_ref(),
+                &shallow,
+                &mut states,
+                &mut queue,
+                &mut buf,
+                id,
+                VISIBLE,
+            )?;
+        }
+        for &id in expand {
+            self.schedule_cached(
+                repo,
+                cache.as_ref(),
+                &shallow,
+                &mut states,
+                &mut queue,
+                &mut buf,
+                id,
+                EXPAND,
+            )?;
+        }
+        for (&id, names) in &local_refs {
+            if self.commits.get(&id).is_none_or(|commit| !commit.data.stored) {
+                continue;
+            }
+            let tracked = resolve_tracking(repo, names)?;
+            if tracked.iter().any(|reference| reference.upstream.flatten().is_some()) {
+                self.schedule_cached(
+                    repo,
+                    cache.as_ref(),
+                    &shallow,
+                    &mut states,
+                    &mut queue,
+                    &mut buf,
+                    id,
+                    INTERNAL,
+                )?;
+            }
+            for upstream in tracked.iter().filter_map(|reference| reference.upstream.flatten()) {
+                self.schedule_cached(
+                    repo,
+                    cache.as_ref(),
+                    &shallow,
+                    &mut states,
+                    &mut queue,
+                    &mut buf,
+                    upstream,
+                    INTERNAL,
+                )?;
+            }
+            tracking.insert(id, tracked);
+        }
+
+        let mut rows = Vec::new();
+        let mut attributions = Vec::new();
+        while let Some((_time, id)) = queue.pop() {
+            let Some(state) = states.get_mut(&id) else { continue };
+            let delta = state.flags & !state.expanded;
+            if delta == 0 {
+                continue;
+            }
+            state.expanded |= delta;
+            let commit = &self.commits[&id];
+            let was_stored = commit.data.stored;
+            let stop = commit.data.complete && (delta & EXPAND == 0 || was_stored && !expand.contains(&id));
+            let should_store = delta & (VISIBLE | EXPAND) != 0 && !was_stored;
+            let parent_ids = commit.parents.clone();
+            let generation = commit.generation;
+            if should_store {
+                if let Some(names) = local_refs.get(&id) {
+                    let tracked = resolve_tracking(repo, names)?;
+                    if tracked.iter().any(|reference| reference.upstream.flatten().is_some()) {
+                        self.schedule_cached(
+                            repo,
+                            cache.as_ref(),
+                            &shallow,
+                            &mut states,
+                            &mut queue,
+                            &mut buf,
+                            id,
+                            INTERNAL,
+                        )?;
+                    }
+                    for upstream in tracked.iter().filter_map(|reference| reference.upstream.flatten()) {
+                        self.schedule_cached(
+                            repo,
+                            cache.as_ref(),
+                            &shallow,
+                            &mut states,
+                            &mut queue,
+                            &mut buf,
+                            upstream,
+                            INTERNAL,
+                        )?;
+                    }
+                    tracking.insert(id, tracked);
+                }
+                let metadata = if generation.is_some() {
+                    None
+                } else {
+                    let object = repo.find_commit(id).context("could not read refreshed commit")?;
+                    let mut authors = gix::features::threading::lock(authors);
+                    Some(decode_metadata(object.iter(), &mut authors, &mut attributions)?)
+                };
+                let metadata_loaded = metadata.is_some();
+                let Metadata {
+                    committer_time,
+                    author,
+                    attributions: row_attributions,
+                    title,
+                    has_agent_marker,
+                    signature,
+                } = metadata.unwrap_or_else(|| Metadata {
+                    committer_time: Default::default(),
+                    author: &EMPTY_AUTHOR,
+                    attributions: 0..0,
+                    title: BString::default(),
+                    has_agent_marker: false,
+                    signature: SignatureState::Unsigned,
+                });
+                rows.push(Commit {
+                    id,
+                    parent_ids: parent_ids.clone(),
+                    committer_time,
+                    author,
+                    attributions: row_attributions,
+                    title,
+                    metadata_loaded,
+                    has_agent_marker,
+                    signature,
+                });
+                self.commits
+                    .get_mut(&id)
+                    .expect("loaded commit remains present")
+                    .data
+                    .stored = true;
+            }
+            if stop {
+                continue;
+            }
+            for parent in parent_ids {
+                self.schedule_cached(
+                    repo,
+                    cache.as_ref(),
+                    &shallow,
+                    &mut states,
+                    &mut queue,
+                    &mut buf,
+                    parent,
+                    delta & (VISIBLE | INTERNAL | EXPAND),
+                )?;
+            }
+        }
+        for (id, state) in states {
+            if state.expanded & (VISIBLE | INTERNAL | EXPAND) != 0 {
+                self.commits
+                    .get_mut(&id)
+                    .expect("walked commits remain cached")
+                    .data
+                    .complete = true;
+            }
+        }
+        self.tracking = tracking;
+        Ok(Refresh {
+            refs,
+            decorations: decorations(repo)?,
+            commits: LoadedCommits { rows, attributions },
+        })
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct RefSnapshot {
     pub view: HashMap<BString, gix::refs::Target>,
@@ -57,13 +500,165 @@ pub(crate) struct Authors {
     authors: HashMap<(&'static BStr, &'static BStr), &'static Author>,
 }
 const COMMIT_BATCH_SIZE: usize = 1024;
+const VISIBLE: u8 = 1 << 0;
+const INTERNAL: u8 = 1 << 1;
+const HIDDEN: u8 = 1 << 2;
+const STALE: u8 = 1 << 3;
+const EXPAND: u8 = 1 << 4;
+
+#[derive(Default)]
+struct WalkState {
+    flags: u8,
+    expanded: u8,
+}
+
+fn schedule(
+    graph: &mut gix::revwalk::Graph<'_, '_, gix::revwalk::graph::Commit<Node>>,
+    queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, ObjectId>,
+    shallow: &HashSet<ObjectId>,
+    id: ObjectId,
+    flags: u8,
+) -> Result<()> {
+    let Some(commit) = graph
+        .get_or_insert_full_commit(id, |commit| {
+            if shallow.contains(&id) {
+                commit.parents.clear();
+            }
+        })
+        .context("could not load commit for history traversal")?
+    else {
+        return Ok(());
+    };
+    if commit.data.flags & flags != flags {
+        commit.data.flags |= flags;
+        queue.insert(commit.commit_time, id);
+    }
+    Ok(())
+}
+
+fn hidden_frontier(
+    graph: &mut gix::revwalk::Graph<'_, '_, gix::revwalk::graph::Commit<Node>>,
+    visible_tips: &[ObjectId],
+    hidden_tips: &[ObjectId],
+    shallow: &HashSet<ObjectId>,
+) -> Result<HashSet<ObjectId>> {
+    if hidden_tips.is_empty() {
+        return Ok(HashSet::new());
+    }
+    let mut flags = HashMap::<ObjectId, u8>::new();
+    let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, ObjectId>::new();
+    for (tips, flag) in [(visible_tips, VISIBLE), (hidden_tips, HIDDEN)] {
+        for &id in tips {
+            let Some(commit) = graph
+                .get_or_insert_full_commit(id, |commit| {
+                    if shallow.contains(&id) {
+                        commit.parents.clear();
+                    }
+                })
+                .context("could not load commit while preparing hidden history")?
+            else {
+                continue;
+            };
+            *flags.entry(id).or_default() |= flag;
+            queue.insert(GenThenTime::from(&*commit), id);
+        }
+    }
+    while queue
+        .iter_unordered()
+        .any(|id| flags.get(id).is_some_and(|flags| flags & STALE == 0))
+    {
+        let Some((_priority, id)) = queue.pop() else { break };
+        let mut propagated = flags[&id];
+        if propagated & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN {
+            propagated |= STALE;
+            *flags.get_mut(&id).expect("queued commits have flags") = propagated;
+        }
+        let parents = graph.get(&id).expect("queued commits are loaded").parents.clone();
+        for parent in parents {
+            let Some(commit) = graph
+                .get_or_insert_full_commit(parent, |commit| {
+                    if shallow.contains(&parent) {
+                        commit.parents.clear();
+                    }
+                })
+                .context("could not load hidden commit parent")?
+            else {
+                continue;
+            };
+            let parent_flags = flags.entry(parent).or_default();
+            if *parent_flags & propagated != propagated {
+                *parent_flags |= propagated;
+                queue.insert(GenThenTime::from(&*commit), parent);
+            }
+        }
+    }
+    Ok(flags
+        .into_iter()
+        .filter_map(|(id, flags)| (flags & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN).then_some(id))
+        .collect())
+}
+
+fn local_refs_by_target(repo: &gix::Repository) -> Result<HashMap<ObjectId, Vec<BString>>> {
+    let mut out = HashMap::<ObjectId, Vec<BString>>::new();
+    let platform = repo.references().context("could not open references")?;
+    let refs = platform
+        .local_branches()
+        .context("could not iterate local branches")?
+        .peeled()
+        .context("could not prepare local branches for peeling")?;
+    for reference in refs {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read local branch: {err}")),
+        };
+        out.entry(reference.id().detach())
+            .or_default()
+            .push(reference.name().as_bstr().to_owned());
+    }
+    Ok(out)
+}
+
+fn resolve_tracking(repo: &gix::Repository, names: &[BString]) -> Result<Vec<SelectionRef>> {
+    let mut out = Vec::with_capacity(names.len());
+    for full_name in names {
+        let Some(reference) = repo
+            .try_find_reference(full_name.as_bstr())
+            .with_context(|| format!("could not read local branch {full_name}"))?
+        else {
+            continue;
+        };
+        let upstream = reference
+            .remote_tracking_ref_name(gix::remote::Direction::Fetch)
+            .map(|name| {
+                let name = name.context("could not resolve remote-tracking branch name")?;
+                Ok::<_, anyhow::Error>(
+                    repo.try_find_reference(name.as_bstr())
+                        .with_context(|| format!("could not read remote-tracking branch {name}"))?
+                        .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach)),
+                )
+            })
+            .transpose()?;
+        out.push(SelectionRef {
+            name: full_name
+                .strip_prefix(b"refs/heads/")
+                .unwrap_or(full_name.as_slice())
+                .into(),
+            upstream,
+        });
+    }
+    out.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.upstream.cmp(&b.upstream)));
+    out.dedup();
+    Ok(out)
+}
 
 #[derive(Debug)]
 pub(crate) enum Event {
     Decorations(Decorations),
     Commits(LoadedCommits),
     HiddenCommits(LoadedCommits),
-    Complete,
+    VisibleComplete,
+    Complete(HistoryGraph),
     Cancelled,
 }
 
@@ -77,7 +672,8 @@ pub(crate) fn load(
 ) -> Result<()> {
     let Some(tips) = resolve_tips(repo, revisions)? else {
         emit(Event::Decorations(decorations(repo)?));
-        emit(Event::Complete);
+        emit(Event::VisibleComplete);
+        emit(Event::Complete(HistoryGraph::default()));
         return Ok(());
     };
     let hidden_tips = resolve_revisions(repo, hidden_revisions, "hidden ")?;
@@ -85,78 +681,122 @@ pub(crate) fn load(
     if !emit(Event::Decorations(decorations(repo)?)) {
         return Ok(());
     }
-    let walk = repo
-        .rev_walk(tips)
-        .with_hidden(hidden_tips)
-        .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
-        .all()
-        .context("could not start revision walk")?;
+    let shallow: HashSet<_> = repo
+        .shallow_commits()
+        .context("could not read shallow commits")?
+        .into_iter()
+        .flat_map(|commits| commits.iter().copied().collect::<Vec<_>>())
+        .collect();
+    let commit_graph = repo
+        .commit_graph_if_enabled()
+        .context("could not open commit-graph for history traversal")?;
+    let mut graph = repo.revision_graph::<gix::revwalk::graph::Commit<Node>>(commit_graph.as_ref());
+    let hidden = hidden_frontier(&mut graph, &tips, &hidden_tips, &shallow)?;
+    let local_refs = local_refs_by_target(repo)?;
+    let mut tracking = HashMap::new();
+    let mut queue = gix::revwalk::PriorityQueue::new();
+    for &tip in &tips {
+        schedule(&mut graph, &mut queue, &shallow, tip, VISIBLE)?;
+    }
     let mut rows = Vec::with_capacity(COMMIT_BATCH_SIZE);
     let mut attributions = Vec::with_capacity(COMMIT_BATCH_SIZE);
-    let mut visible = HashSet::new();
     let mut connected = Vec::new();
-    let mut seen_parents = HashSet::new();
-    for info in walk {
+    let mut connected_seen = HashSet::new();
+    while let Some((_time, id)) = queue.pop() {
         if cancelled.load(Ordering::Relaxed) {
             emit(Event::Cancelled);
             return Ok(());
         }
-        let info = info.context("could not traverse revision history")?;
-        let metadata = if info.generation.is_some() {
+        let commit = graph.get_mut(&id).expect("queued commits are loaded");
+        let delta = commit.data.flags & !commit.data.expanded;
+        if delta == 0 {
+            continue;
+        }
+        commit.data.expanded |= delta;
+        commit.data.complete = true;
+        let should_emit = delta & VISIBLE != 0 && !commit.data.emitted && !hidden.contains(&id);
+        commit.data.emitted |= should_emit;
+        commit.data.stored |= should_emit;
+        let parent_ids = commit.parents.clone();
+        let generation = commit.generation;
+        if should_emit && let Some(names) = local_refs.get(&id) {
+            let refs = resolve_tracking(repo, names)?;
+            if refs.iter().any(|reference| reference.upstream.flatten().is_some()) {
+                schedule(&mut graph, &mut queue, &shallow, id, INTERNAL)?;
+            }
+            for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
+                schedule(&mut graph, &mut queue, &shallow, upstream, INTERNAL)?;
+            }
+            tracking.insert(id, refs);
+        }
+        let metadata = if !should_emit || generation.is_some() {
             None
         } else {
-            let object = info.object().context("could not read commit")?;
+            let object = repo.find_commit(id).context("could not read commit")?;
             let mut authors = gix::features::threading::lock(authors);
             Some(decode_metadata(object.iter(), &mut authors, &mut attributions)?)
         };
-        let metadata_loaded = metadata.is_some();
-        let Metadata {
-            committer_time,
-            author,
-            attributions: row_attributions,
-            title,
-            has_agent_marker,
-            signature,
-        } = metadata.unwrap_or_else(|| Metadata {
-            committer_time: Default::default(),
-            author: &EMPTY_AUTHOR,
-            attributions: 0..0,
-            title: BString::default(),
-            has_agent_marker: false,
-            signature: SignatureState::Unsigned,
-        });
-        visible.insert(info.id);
-        connected.extend(
-            info.parent_ids
-                .iter()
-                .copied()
-                .filter(|parent| seen_parents.insert(*parent)),
-        );
-        rows.push(Commit {
-            id: info.id,
-            parent_ids: info.parent_ids,
-            committer_time,
-            author,
-            attributions: row_attributions,
-            title,
-            metadata_loaded,
-            has_agent_marker,
-            signature,
-        });
-        if rows.len() == COMMIT_BATCH_SIZE
-            && !emit(Event::Commits(LoadedCommits {
-                rows: std::mem::replace(&mut rows, Vec::with_capacity(COMMIT_BATCH_SIZE)),
-                attributions: std::mem::replace(&mut attributions, Vec::with_capacity(COMMIT_BATCH_SIZE)),
-            }))
-        {
-            return Ok(());
+        if should_emit {
+            let metadata_loaded = metadata.is_some();
+            let Metadata {
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                has_agent_marker,
+                signature,
+            } = metadata.unwrap_or_else(|| Metadata {
+                committer_time: Default::default(),
+                author: &EMPTY_AUTHOR,
+                attributions: 0..0,
+                title: BString::default(),
+                has_agent_marker: false,
+                signature: SignatureState::Unsigned,
+            });
+            if !hidden_revisions.is_empty() {
+                connected.extend(parent_ids.iter().copied().filter(|id| connected_seen.insert(*id)));
+            }
+            rows.push(Commit {
+                id,
+                parent_ids: parent_ids.clone(),
+                committer_time,
+                author,
+                attributions: row_attributions,
+                title,
+                metadata_loaded,
+                has_agent_marker,
+                signature,
+            });
+            if rows.len() == COMMIT_BATCH_SIZE
+                && !emit(Event::Commits(LoadedCommits {
+                    rows: std::mem::replace(&mut rows, Vec::with_capacity(COMMIT_BATCH_SIZE)),
+                    attributions: std::mem::replace(&mut attributions, Vec::with_capacity(COMMIT_BATCH_SIZE)),
+                }))
+            {
+                return Ok(());
+            }
+        }
+        let propagated = if hidden.contains(&id) {
+            delta & INTERNAL
+        } else {
+            delta & (VISIBLE | INTERNAL)
+        };
+        for parent in parent_ids {
+            let parent_flags = if hidden.contains(&parent) {
+                propagated & !VISIBLE
+            } else {
+                propagated
+            };
+            if parent_flags != 0 {
+                schedule(&mut graph, &mut queue, &shallow, parent, parent_flags)?;
+            }
         }
     }
     if !rows.is_empty() && !emit(Event::Commits(LoadedCommits { rows, attributions })) {
         return Ok(());
     }
     if !hidden_revisions.is_empty() {
-        connected.retain(|id| !visible.contains(id));
+        connected.retain(|id| graph.get(id).is_none_or(|commit| !commit.data.emitted));
         let mut rows = Vec::with_capacity(connected.len());
         let mut attributions = Vec::new();
         let mut authors = gix::features::threading::lock(authors);
@@ -186,12 +826,27 @@ pub(crate) fn load(
                 has_agent_marker,
                 signature,
             });
+            if let Some(commit) = graph
+                .get_or_insert_full_commit(id, |commit| {
+                    if shallow.contains(&id) {
+                        commit.parents.clear();
+                    }
+                })
+                .context("could not retain connected hidden commit")?
+            {
+                commit.data.stored = true;
+            }
         }
         if !rows.is_empty() && !emit(Event::HiddenCommits(LoadedCommits { rows, attributions })) {
             return Ok(());
         }
     }
-    emit(Event::Complete);
+    emit(Event::VisibleComplete);
+    emit(Event::Complete(HistoryGraph {
+        commits: graph.detach(),
+        tracking,
+        relations: HashMap::new(),
+    }));
     Ok(())
 }
 
@@ -204,74 +859,6 @@ pub(crate) fn snapshot(repo: &gix::Repository, revisions: &[OsString], hidden: &
     })
 }
 
-pub(crate) fn refresh(
-    repo: &gix::Repository,
-    revisions: &[OsString],
-    hidden_revisions: &[OsString],
-    known: &HashSet<ObjectId>,
-    expand: &HashSet<ObjectId>,
-    authors: &SharedAuthors,
-) -> Result<Refresh> {
-    let refs = snapshot(repo, revisions, hidden_revisions)?;
-    let mut tips = refs.view_tips.clone();
-    tips.extend(refs.hidden_tips.iter().copied());
-    tips.extend(expand.iter().copied());
-    let mut rows = Vec::new();
-    let mut attributions = Vec::new();
-    if !tips.is_empty() {
-        let walk = repo
-            .rev_walk(tips)
-            .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
-            .selected(|id| !known.contains(id) || expand.contains(id))
-            .context("could not start incremental revision walk")?;
-        for info in walk {
-            let info = info.context("could not refresh revision history")?;
-            if known.contains(&info.id) {
-                continue;
-            }
-            let metadata = if info.generation.is_some() {
-                None
-            } else {
-                let object = info.object().context("could not read commit")?;
-                let mut authors = gix::features::threading::lock(authors);
-                Some(decode_metadata(object.iter(), &mut authors, &mut attributions)?)
-            };
-            let metadata_loaded = metadata.is_some();
-            let Metadata {
-                committer_time,
-                author,
-                attributions: row_attributions,
-                title,
-                has_agent_marker,
-                signature,
-            } = metadata.unwrap_or_else(|| Metadata {
-                committer_time: Default::default(),
-                author: &EMPTY_AUTHOR,
-                attributions: 0..0,
-                title: BString::default(),
-                has_agent_marker: false,
-                signature: SignatureState::Unsigned,
-            });
-            rows.push(Commit {
-                id: info.id,
-                parent_ids: info.parent_ids,
-                committer_time,
-                author,
-                attributions: row_attributions,
-                title,
-                metadata_loaded,
-                has_agent_marker,
-                signature,
-            });
-        }
-    }
-    Ok(Refresh {
-        refs,
-        decorations: decorations(repo)?,
-        commits: LoadedCommits { rows, attributions },
-    })
-}
-
 fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {
     let implicit_head = OsString::from("HEAD");
     let revisions = if revisions.is_empty() {
@@ -572,6 +1159,12 @@ mod tests {
         gix_testtools::scripted_fixture_read_only_needs_archive("history.sh")
     }
 
+    fn id(n: u8) -> ObjectId {
+        let mut bytes = [0; 20];
+        bytes[19] = n;
+        ObjectId::Sha1(bytes)
+    }
+
     fn loaded(path: &std::path::Path, revisions: &[&str], hidden_revisions: &[&str]) -> Result<Vec<Event>> {
         let mut events = Vec::new();
         let authors =
@@ -607,6 +1200,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn paints_criss_cross_relations_from_cached_parents() {
+        let mut graph = HistoryGraph::default();
+        for (n, parents, generation) in [
+            (1, vec![], 1),
+            (2, vec![1], 2),
+            (3, vec![1], 2),
+            (4, vec![2, 3], 3),
+            (5, vec![3, 2], 3),
+            (6, vec![4], 4),
+            (7, vec![5], 4),
+        ] {
+            graph.commits.insert(
+                id(n),
+                gix::revwalk::graph::Commit {
+                    parents: parents.into_iter().map(id).collect(),
+                    commit_time: generation.into(),
+                    generation: Some(generation),
+                    data: Node::default(),
+                },
+            );
+        }
+
+        assert_eq!(
+            graph.paint(id(6), &[id(7)]),
+            Some((2, 2)),
+            "both merge tips stop at the shared criss-cross ancestry"
+        );
+    }
+
     #[test]
     fn walks_the_same_reachable_set_as_git_for_multiple_tips() -> gix_testtools::Result {
         let fixture = fixture()?;
@@ -629,7 +1252,7 @@ mod tests {
         );
         let expected = String::from_utf8(output.stdout)?.lines().map(str::to_owned).collect();
         assert_eq!(actual, expected, "all commits reachable from either tip are shown once");
-        assert!(matches!(events.last(), Some(Event::Complete)), "the walk completes");
+        assert!(matches!(events.last(), Some(Event::Complete(_))), "the walk completes");
         let (topic, attributions) = events
             .iter()
             .filter_map(|event| match event {
@@ -755,6 +1378,190 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn refresh_stops_at_the_persistent_graph() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let events = loaded(fixture.path(), &["main"], &[])?;
+        let mut graph = events
+            .into_iter()
+            .find_map(|event| match event {
+                Event::Complete(graph) => Some(graph),
+                _ => None,
+            })
+            .expect("history loading returns the persistent graph");
+
+        std::fs::write(fixture.path().join("new"), "new\n")?;
+        for args in [
+            &["add", "new"][..],
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "new"],
+        ] {
+            let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
+            assert!(status.success(), "git prepares one new commit");
+        }
+        let repo = crate::open_test_repository(fixture.path())?;
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let first = graph.refresh(&repo, &["main".into()], &[], &HashSet::new(), &authors)?;
+        assert_eq!(first.commits.rows.len(), 1, "only the new descendant is loaded");
+        let second = graph.refresh(&repo, &["main".into()], &[], &HashSet::new(), &authors)?;
+        assert!(
+            second.commits.rows.is_empty(),
+            "an unchanged tip stops immediately at complete cached ancestry"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn refresh_stops_at_cached_tracking_ancestry() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let main = crate::open_test_repository(fixture.path())?
+            .rev_parse_single("main")?
+            .detach();
+        for args in [
+            &["config", "remote.origin.url", "https://example.com/repo"][..],
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"][..],
+            &["config", "branch.topic.remote", "origin"][..],
+            &["config", "branch.topic.merge", "refs/heads/main"][..],
+            &["update-ref", "refs/remotes/origin/main", &main.to_hex().to_string()][..],
+        ] {
+            let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
+            assert!(status.success(), "git configures a tracking branch");
+        }
+        let events = loaded(fixture.path(), &["topic"], &[])?;
+        let mut graph = events
+            .into_iter()
+            .find_map(|event| match event {
+                Event::Complete(graph) => Some(graph),
+                _ => None,
+            })
+            .expect("history loading returns the persistent graph");
+        let repo = gix::open(fixture.path())?;
+        let cached = graph.commits.get_mut(&main).expect("the tracking tip was scheduled");
+        assert!(cached.data.complete && !cached.data.stored);
+        cached.parents.push(id(255));
+
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let refresh = graph.refresh(&repo, &["topic".into()], &[], &HashSet::new(), &authors)?;
+        assert!(
+            refresh.commits.rows.is_empty(),
+            "an unchanged tracking tip stops before revisiting its cached parents"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn hidden_history_keeps_tracking_relations_complete_and_can_be_expanded() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        let git = |args: &[&str]| -> gix_testtools::Result {
+            let output = Command::new("git").current_dir(path).args(args).output()?;
+            assert!(
+                output.status.success(),
+                "git {args:?} prepares the hidden tracking fixture: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            Ok(())
+        };
+        let commit = |name: &str| -> gix_testtools::Result {
+            std::fs::write(path.join(name), format!("{name}\n"))?;
+            git(&["add", name])?;
+            git(&["commit", "-q", "-m", name])
+        };
+
+        git(&["config", "commit.gpgsign", "false"])?;
+        git(&["switch", "-q", "-c", "relation-base", "main"])?;
+        commit("base-0")?;
+        let base = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        for name in ["base-1", "base-2", "base-3"] {
+            commit(name)?;
+        }
+        git(&["switch", "-q", "-c", "hidden"])?;
+        commit("hidden-only")?;
+        let hidden_only = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        git(&["switch", "-q", "-c", "local", "relation-base"])?;
+        commit("local-only")?;
+        let local = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        git(&["switch", "-q", "--detach", &base.to_hex().to_string()])?;
+        commit("upstream-only")?;
+        let upstream = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        git(&["switch", "-q", "local"])?;
+        for args in [
+            &["config", "remote.origin.url", "https://example.com/repo"][..],
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"][..],
+            &["config", "branch.local.remote", "origin"][..],
+            &["config", "branch.local.merge", "refs/heads/local"][..],
+            &[
+                "update-ref",
+                "refs/remotes/origin/local",
+                &upstream.to_hex().to_string(),
+            ][..],
+        ] {
+            git(args)?;
+        }
+
+        let mut decorations = Decorations::new();
+        let mut visible = HashSet::new();
+        let mut boundary = HashSet::new();
+        let mut graph = None;
+        for event in loaded(path, &["local"], &["hidden"])? {
+            match event {
+                Event::Decorations(value) => decorations = value,
+                Event::Commits(batch) => visible.extend(batch.rows.into_iter().map(|row| row.id)),
+                Event::HiddenCommits(batch) => {
+                    boundary.extend(batch.rows.into_iter().map(|row| row.id));
+                    visible.extend(boundary.iter().copied());
+                }
+                Event::Complete(value) => graph = Some(value),
+                Event::VisibleComplete | Event::Cancelled => {}
+            }
+        }
+        let mut graph = graph.expect("history loading returns the persistent graph");
+        let refs = graph.selection_refs(local, &decorations);
+        let counts = Command::new("git")
+            .current_dir(path)
+            .args([
+                "rev-list",
+                "--left-right",
+                "--count",
+                "local...refs/remotes/origin/local",
+            ])
+            .output()?;
+        assert!(counts.status.success(), "git computes the expected tracking relation");
+        let expected: Vec<_> = String::from_utf8(counts.stdout)?
+            .split_whitespace()
+            .map(str::parse::<usize>)
+            .collect::<Result<_, _>>()?;
+        assert_eq!(
+            graph.selection_relation(local, &refs, &[]),
+            Some(crate::app::SelectionRelation::Tracking {
+                ahead: expected[0],
+                behind: expected[1],
+            }),
+            "hidden tips do not truncate either side of the tracking relation"
+        );
+
+        let repo = crate::open_test_repository(path)?;
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let refresh = graph.refresh(&repo, &["local".into()], &[], &boundary, &authors)?;
+        visible.extend(refresh.commits.rows.into_iter().map(|row| row.id));
+        let expected: HashSet<_> = repo
+            .rev_walk([local])
+            .all()?
+            .map(|info| info.map(|info| info.id))
+            .collect::<Result<_, _>>()?;
+        assert_eq!(
+            visible, expected,
+            "showing hidden materializes the original view ancestry"
+        );
+        assert!(
+            !visible.contains(&hidden_only),
+            "showing hidden does not add commits reachable only from a hidden tip"
+        );
+        Ok(())
+    }
+
     #[test]
     fn hides_tips_and_every_commit_reachable_from_them() -> gix_testtools::Result {
         let fixture = fixture()?;
@@ -803,7 +1610,7 @@ mod tests {
             "the screen-size probe uses the same hidden history"
         );
         assert!(
-            matches!(events.last(), Some(Event::Complete)),
+            matches!(events.last(), Some(Event::Complete(_))),
             "the filtered walk completes"
         );
         Ok(())
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b9eecec27db..235697ef9d9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -41,7 +41,7 @@ use gix::{
     bstr::{BString, ByteSlice},
     prelude::TreeDiffChangeExt,
 };
-use history::{Authors, DecorationKind, Decorations, Event, SharedAuthors};
+use history::{Authors, Decorations, Event, HistoryGraph, SelectionRef, SharedAuthors};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
 use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
 
@@ -121,12 +121,6 @@ fn take_due(deadline: &mut Option<Instant>, now: Instant) -> bool {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq)]
-struct SelectionRef {
-    name: BString,
-    upstream: Option<Option<gix::ObjectId>>,
-}
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct SelectionRelationCache {
     id: gix::ObjectId,
@@ -727,7 +721,7 @@ fn event_loop(
     }
     app.manual_refresh = ref_watcher.is_none();
     let mut lane_receiver = None;
-    let mut refresh_receiver: Option<mpsc::Receiver<Result<history::Refresh>>> = None;
+    let mut refresh_receiver: Option<mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
     let mut refresh_from_filesystem = false;
     let mut refresh_select_top = false;
@@ -739,6 +733,7 @@ fn event_loop(
     let mut worktree_watcher: Option<WorktreeWatcher> = None;
     let mut worktree_refresh_deadline: Option<Instant> = None;
     let mut selection_relation = None;
+    let mut history_graph = None;
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
     let mut line_diff_pool = None;
     let mut fill_repository = FillRepository {
@@ -778,6 +773,7 @@ fn event_loop(
         &mut commit_message,
         &mut tree_changes,
         &mut worktree_changes,
+        &mut history_graph,
         &mut selection_relation,
         &mut line_diff_pool,
     )?;
@@ -962,7 +958,8 @@ fn event_loop(
         }
         if let Some(result) = refresh_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
-                Ok(result) => {
+                Ok((graph, result)) => {
+                    history_graph = Some(graph);
                     let result = result?;
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
                     decorations = result.decorations;
@@ -991,6 +988,7 @@ fn event_loop(
         if refresh_pending
             && refresh_receiver.is_none()
             && lane_receiver.is_none()
+            && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
@@ -1040,41 +1038,27 @@ fn event_loop(
             let select_top = std::mem::take(&mut refresh_from_filesystem);
             ref_snapshot = next;
             refresh_pending = false;
-            if tips_changed || refresh_expand_hidden {
-                let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
-                let expand = if refresh_expand_hidden || hidden_changed {
-                    app.hidden_ids()
-                } else {
-                    Default::default()
-                };
-                refresh_receiver = Some(start_history_refresh(
-                    repository_path.clone(),
-                    repository_is_bare,
-                    revisions.clone(),
-                    hidden,
-                    app.known_ids(),
-                    expand,
-                    gix::features::threading::OwnShared::clone(&authors),
-                ));
-                refresh_select_top = select_top;
-                refresh_expand_hidden = false;
-                app.state = State::Loading;
-                tracing::info!(select_top, "started history refresh");
+            let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
+            let expand = if refresh_expand_hidden || hidden_changed {
+                app.hidden_ids()
             } else {
-                let next = history::decorations(&repository)?;
-                let relation_changed = selection_relation
-                    .as_ref()
-                    .is_some_and(|cached: &SelectionRelationCache| {
-                        selection_refs(&repository, cached.id, &next) != cached.refs
-                    });
-                if visible_decorations_changed(&decorations, &next, &app.rows) || relation_changed {
-                    selection_relation = None;
-                    app.selection_relation = None;
-                    decorations = next;
-                    dirty = true;
-                    tracing::debug!(relation_changed, "updated history decorations");
-                }
-            }
+                Default::default()
+            };
+            refresh_receiver = Some(start_history_refresh(
+                repository_path.clone(),
+                repository_is_bare,
+                revisions.clone(),
+                hidden,
+                expand,
+                gix::features::threading::OwnShared::clone(&authors),
+                history_graph
+                    .take()
+                    .expect("refresh starts only with a cached history graph"),
+            ));
+            refresh_select_top = select_top;
+            refresh_expand_hidden = false;
+            app.state = State::Loading;
+            tracing::info!(select_top, "started history refresh");
         }
         if urgent {
             draw(
@@ -1087,6 +1071,7 @@ fn event_loop(
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
+                &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
             )?;
@@ -1125,8 +1110,7 @@ fn event_loop(
                         history_requires_alternate_screen = true;
                     }
                 }
-                Event::Complete => {
-                    history_finished = true;
+                Event::VisibleComplete => {
                     resize_inline = true;
                     history_requires_alternate_screen =
                         history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
@@ -1134,6 +1118,12 @@ fn event_loop(
                         lane_receiver = Some(start_lane_worker(rows));
                     }
                 }
+                Event::Complete(graph) => {
+                    history_finished = true;
+                    history_graph = Some(graph);
+                    selection_relation = None;
+                    app.selection_relation = None;
+                }
                 Event::Cancelled => {
                     history_finished = true;
                     drop(app.update(Action::Cancelled));
@@ -1164,6 +1154,7 @@ fn event_loop(
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
+                &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
             )?;
@@ -1380,6 +1371,7 @@ fn event_loop(
             &mut commit_message,
             &mut tree_changes,
             &mut worktree_changes,
+            &mut history_graph,
             &mut selection_relation,
             &mut line_diff_pool,
         )?;
@@ -1476,19 +1468,19 @@ fn start_history_refresh(
     bare: bool,
     revisions: Vec<OsString>,
     hidden_revisions: Vec<OsString>,
-    known: std::collections::HashSet<gix::ObjectId>,
     expand: std::collections::HashSet<gix::ObjectId>,
     authors: SharedAuthors,
-) -> mpsc::Receiver<Result<history::Refresh>> {
+    mut graph: HistoryGraph,
+) -> mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
         let result = open_repository(&repository_path, bare, true)
             .context("could not reopen repository for history refresh")
             .and_then(|mut repository| {
                 repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
-                history::refresh(&repository, &revisions, &hidden_revisions, &known, &expand, &authors)
+                graph.refresh(&repository, &revisions, &hidden_revisions, &expand, &authors)
             });
-        let _ = sender.send(result);
+        let _ = sender.send((graph, result));
     });
     receiver
 }
@@ -1566,77 +1558,6 @@ fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) -> bool {
     false
 }
 
-fn visible_decorations_changed(old: &Decorations, new: &Decorations, rows: &[CommitRow]) -> bool {
-    rows.iter().any(|row| old.get(&row.id) != new.get(&row.id))
-}
-
-fn selection_refs(repo: &gix::Repository, id: gix::ObjectId, decorations: &Decorations) -> Vec<SelectionRef> {
-    let mut refs: Vec<_> = decorations
-        .get(&id)
-        .into_iter()
-        .flatten()
-        .map(|decoration| {
-            let upstream = if decoration.kind == DecorationKind::Local {
-                let mut name = BString::from("refs/heads/");
-                name.extend_from_slice(&decoration.name);
-                repo.try_find_reference(name.as_bstr())
-                    .ok()
-                    .flatten()
-                    .and_then(|reference| reference.remote_tracking_ref_name(gix::remote::Direction::Fetch))
-                    .map(|name| {
-                        name.ok().and_then(|name| {
-                            repo.try_find_reference(name.as_bstr())
-                                .ok()
-                                .flatten()
-                                .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach))
-                        })
-                    })
-            } else {
-                None
-            };
-            SelectionRef {
-                name: decoration.name.clone(),
-                upstream,
-            }
-        })
-        .collect();
-    refs.sort_by(|a, b| a.name.cmp(&b.name).then_with(|| a.upstream.cmp(&b.upstream)));
-    refs
-}
-
-fn selection_relation(
-    repo: &gix::Repository,
-    id: gix::ObjectId,
-    refs: &[SelectionRef],
-    visible: Option<usize>,
-) -> Option<SelectionRelation> {
-    let has_upstream = refs.iter().any(|reference| reference.upstream.is_some());
-    for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
-        let Ok(ahead) = count_exclusive_commits(repo, id, upstream) else {
-            continue;
-        };
-        let Ok(behind) = count_exclusive_commits(repo, upstream, id) else {
-            continue;
-        };
-        return Some(SelectionRelation::Tracking { ahead, behind });
-    }
-    (!has_upstream && !refs.is_empty())
-        .then_some(visible)
-        .flatten()
-        .map(SelectionRelation::Visible)
-}
-
-fn count_exclusive_commits(repo: &gix::Repository, tip: gix::ObjectId, hidden: gix::ObjectId) -> Result<usize> {
-    let mut walk = repo
-        .rev_walk([tip])
-        .with_hidden([hidden])
-        .all()
-        .context("could not compare branch with its upstream")?;
-    walk.try_fold(0usize, |count, info| {
-        info.context("could not traverse branch comparison").map(|_| count + 1)
-    })
-}
-
 fn remembered_change_selection(view: &app::ChangesView, changes: Option<&Changes>) -> Option<(BString, usize)> {
     changes.and_then(|changes| {
         changes
@@ -1667,6 +1588,7 @@ fn draw(
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     tree_changes: &mut Option<(gix::ObjectId, usize, Changes)>,
     worktree_changes: &mut Option<(usize, Changes)>,
+    history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
 ) -> Result<()> {
@@ -1742,12 +1664,20 @@ fn draw(
         *tree_changes = None;
         *worktree_changes = None;
     }
+    if let Some(id) = relation_to_load
+        && let Some(graph) = history_graph
+    {
+        let refs = graph.selection_refs(id, decorations);
+        let hidden: Vec<_> = app.hidden_ids().into_iter().collect();
+        let relation = graph.selection_relation(id, &refs, &hidden);
+        *selection_cache = Some(SelectionRelationCache { id, refs, relation });
+        app.selection_relation = relation;
+    }
     if !notes_to_load.is_empty()
         || app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
         || tree_changes_to_load.is_some()
         || worktree_changes_to_load
-        || relation_to_load.is_some()
     {
         let mut one_shot_repository = None;
         let repository = if fill_repository.retain {
@@ -1788,14 +1718,6 @@ fn draw(
         if let Some(id) = message_to_load {
             *commit_message = Some((id, load_commit_message(repository, id)?));
         }
-        if let Some(id) = relation_to_load {
-            repository.object_cache_size(OBJECT_CACHE_SIZE);
-            let refs = selection_refs(repository, id, decorations);
-            let relation = selection_relation(repository, id, &refs, app.visible_ancestry_to_hidden(id));
-            repository.object_cache_size(None);
-            *selection_cache = Some(SelectionRelationCache { id, refs, relation });
-            app.selection_relation = relation;
-        }
         if let Some(id) = tree_changes_to_load {
             repository.object_cache_size(OBJECT_CACHE_SIZE);
             let loaded = load_changes(
@@ -2885,41 +2807,55 @@ mod tests {
     #[test]
     fn selection_relation_prefers_tracking_counts_and_handles_missing_upstreams() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let mut repository = gix::open(&fixture)?;
-        repository.object_cache_size(OBJECT_CACHE_SIZE);
+        let repository = open_test_repository(&fixture)?;
         let topic = repository.rev_parse_single("topic")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let mut graph = None;
+        history::load(
+            &repository,
+            &[OsString::from("topic"), OsString::from("main")],
+            &[],
+            &authors,
+            &AtomicBool::new(false),
+            |event| {
+                if let Event::Complete(value) = event {
+                    graph = Some(value);
+                }
+                true
+            },
+        )?;
+        let mut graph = graph.expect("history traversal returns its graph");
         let tracking = SelectionRef {
             name: "topic".into(),
             upstream: Some(Some(main)),
         };
         assert_eq!(
-            selection_relation(&repository, topic, &[tracking.clone(), tracking], Some(99)),
+            graph.selection_relation(topic, &[tracking.clone(), tracking], &[]),
             Some(SelectionRelation::Tracking { ahead: 1, behind: 2 }),
             "one upstream comparison wins over the visible-history fallback"
         );
         assert_eq!(
-            selection_relation(
-                &repository,
+            graph.selection_relation(
                 topic,
                 &[SelectionRef {
                     name: "topic".into(),
                     upstream: Some(None),
                 }],
-                Some(1),
+                &[],
             ),
             None,
             "a configured but missing tracking ref does not masquerade as an untracked branch"
         );
         assert_eq!(
-            selection_relation(
-                &repository,
+            graph.selection_relation(
                 topic,
                 &[SelectionRef {
                     name: "tag: topic".into(),
                     upstream: None,
                 }],
-                Some(1),
+                &[main],
             ),
             Some(SelectionRelation::Visible(1))
         );
@@ -2950,19 +2886,31 @@ mod tests {
             .args(["update-ref", "refs/remotes/origin/main", &main.to_hex().to_string()])
             .status()?;
         assert!(status.success(), "the configured tracking ref exists");
-        let repository = gix::open(path)?;
-        let refs = selection_refs(
+        let repository = open_test_repository(path)?;
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let mut graph = None;
+        history::load(
             &repository,
-            topic,
-            &Decorations::from([(
-                topic,
-                vec![history::Decoration {
-                    name: "topic".into(),
-                    kind: DecorationKind::Local,
-                }],
-            )]),
-        );
+            &[OsString::from("topic")],
+            &[],
+            &authors,
+            &AtomicBool::new(false),
+            |event| {
+                if let Event::Complete(value) = event {
+                    graph = Some(value);
+                }
+                true
+            },
+        )?;
+        let mut graph = graph.expect("history traversal returns its graph");
+        let refs = graph.selection_refs(topic, &history::decorations(&repository)?);
         assert_eq!(refs[0].upstream, Some(Some(main)));
+        assert_eq!(
+            graph.selection_relation(topic, &refs, &[]),
+            Some(SelectionRelation::Tracking { ahead: 1, behind: 2 }),
+            "the dynamically scheduled upstream has enough cached ancestry for comparison"
+        );
         Ok(())
     }
 

From 0a22730990ec8329d1d6bb6d22e950246f46e0af Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 20:35:09 +0200
Subject: [PATCH 029/282] fix: keep mouse navigation responsive in large tix
 histories

Avoid scanning every history row when no failed signature state needs resetting, and coalesce queued vertical mouse-scroll events into a single bounded selection move. This keeps terminal momentum from monopolizing the event loop on million-commit histories while preserving the total requested movement.
---
 gix-tix/src/app.rs | 32 +++++++++++++++++++++-----
 gix-tix/src/lib.rs | 56 +++++++++++++++++++++++++++++++++-------------
 2 files changed, 67 insertions(+), 21 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 22f1b2b824f..c7066e6bba9 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -255,6 +255,8 @@ pub(crate) enum Action {
     Cancelled,
     MoveUp,
     MoveDown,
+    MoveUpBy(usize),
+    MoveDownBy(usize),
     ScrollLeft,
     ScrollRight,
     HalfPageUp,
@@ -597,8 +599,12 @@ impl App {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
             Action::MoveDown if self.changes_focus.is_some() => self.move_changes(1, true),
-            Action::MoveUp => self.move_reachable(false),
-            Action::MoveDown => self.move_reachable(true),
+            Action::MoveUpBy(distance) if self.changes_focus.is_some() => self.move_changes(distance, false),
+            Action::MoveDownBy(distance) if self.changes_focus.is_some() => self.move_changes(distance, true),
+            Action::MoveUp => self.move_reachable(1, false),
+            Action::MoveDown => self.move_reachable(1, true),
+            Action::MoveUpBy(distance) => self.move_reachable(distance, false),
+            Action::MoveDownBy(distance) => self.move_reachable(distance, true),
             Action::ScrollLeft => {
                 if self.changes_focus.is_some() {
                     self.pan_changes(false);
@@ -1051,18 +1057,21 @@ impl App {
         self.ensure_visible();
     }
 
-    fn move_reachable(&mut self, down: bool) {
+    fn move_reachable(&mut self, distance: usize, down: bool) {
         let (Some(selected), Some(reachable)) = (self.selected, self.reachable_rows.as_ref()) else {
-            self.move_selection(1, down);
+            self.move_selection(distance, down);
             return;
         };
+        let distance = distance.max(1);
         let next = if down {
             (selected + 1..self.rows.len())
-                .find(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .filter(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .nth(distance - 1)
         } else {
             (0..selected)
                 .rev()
-                .find(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .filter(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .nth(distance - 1)
         };
         if let Some(next) = next {
             self.select(next);
@@ -1186,6 +1195,9 @@ impl App {
     }
 
     fn retry_failed_signatures(&mut self) {
+        if self.signature_failures == 0 {
+            return;
+        }
         for row in &mut self.rows {
             if row.signature == SignatureState::Failed {
                 row.signature = SignatureState::Unverified;
@@ -2021,6 +2033,14 @@ mod tests {
         app.update(Action::First);
         assert_eq!(app.selected, Some(0), "First selects the newest commit");
         assert_eq!(app.offset, 0, "the newest commit is visible");
+        app.update(Action::MoveDownBy(3));
+        assert_eq!(
+            app.selected,
+            Some(3),
+            "batched mouse navigation moves once by its full distance"
+        );
+        app.update(Action::MoveUpBy(2));
+        assert_eq!(app.selected, Some(1));
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 235697ef9d9..27e908e903c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -786,6 +786,7 @@ fn event_loop(
     let mut history_finished = false;
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
+    let mut pending_terminal_event = None;
     let result: Result<Option<Duration>> = (|| loop {
         let mut worktree_watch_error = None;
         if let Some(watcher) = worktree_watcher.as_mut() {
@@ -1171,10 +1172,13 @@ fn event_loop(
             .into_iter()
             .flatten()
             .min();
-        let terminal_event = match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
-            Some(timeout) if event::poll(timeout)? => Some(event::read()?),
-            Some(_) => None,
-            None => Some(event::read()?),
+        let terminal_event = match pending_terminal_event.take() {
+            Some(event) => Some(event),
+            None => match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
+                Some(timeout) if event::poll(timeout)? => Some(event::read()?),
+                Some(_) => None,
+                None => Some(event::read()?),
+            },
         };
         let Some(terminal_event) = terminal_event else {
             continue;
@@ -1186,7 +1190,21 @@ fn event_loop(
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
             TerminalEvent::Mouse(mouse) => {
-                let Some(action) = mouse_scroll_action(mouse.kind) else {
+                let kind = mouse.kind;
+                let mut distance = 1;
+                if matches!(kind, MouseEventKind::ScrollUp | MouseEventKind::ScrollDown) {
+                    while distance < EVENT_BATCH_SIZE && event::poll(Duration::ZERO)? {
+                        let next = event::read()?;
+                        match next {
+                            TerminalEvent::Mouse(next) if next.kind == kind => distance += 1,
+                            next => {
+                                pending_terminal_event = Some(next);
+                                break;
+                            }
+                        }
+                    }
+                }
+                let Some(action) = mouse_scroll_action(kind, distance) else {
                     continue;
                 };
                 let repeats_history = app.changes_focus.is_none() && repeats_viewport(&action);
@@ -2727,6 +2745,8 @@ fn repeats_viewport(action: &Action) -> bool {
         action,
         Action::MoveUp
             | Action::MoveDown
+            | Action::MoveUpBy(_)
+            | Action::MoveDownBy(_)
             | Action::HalfPageUp
             | Action::HalfPageDown
             | Action::PageUp
@@ -2740,10 +2760,10 @@ fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>, changes_
     !changes_focused && kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
 }
 
-fn mouse_scroll_action(kind: MouseEventKind) -> Option<Action> {
+fn mouse_scroll_action(kind: MouseEventKind, distance: usize) -> Option<Action> {
     match kind {
-        MouseEventKind::ScrollUp => Some(Action::MoveUp),
-        MouseEventKind::ScrollDown => Some(Action::MoveDown),
+        MouseEventKind::ScrollUp => Some(Action::MoveUpBy(distance.max(1))),
+        MouseEventKind::ScrollDown => Some(Action::MoveDownBy(distance.max(1))),
         MouseEventKind::ScrollLeft => Some(Action::ScrollLeft),
         MouseEventKind::ScrollRight => Some(Action::ScrollRight),
         _ => None,
@@ -3539,22 +3559,28 @@ mod tests {
 
     #[test]
     fn maps_continuous_mouse_scrolling_to_navigation() {
-        assert_eq!(mouse_scroll_action(MouseEventKind::ScrollUp), Some(Action::MoveUp));
-        assert_eq!(mouse_scroll_action(MouseEventKind::ScrollDown), Some(Action::MoveDown));
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollLeft),
+            mouse_scroll_action(MouseEventKind::ScrollUp, 4),
+            Some(Action::MoveUpBy(4))
+        );
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::ScrollDown, 3),
+            Some(Action::MoveDownBy(3))
+        );
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::ScrollLeft, 1),
             Some(Action::ScrollLeft)
         );
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollRight),
+            mouse_scroll_action(MouseEventKind::ScrollRight, 1),
             Some(Action::ScrollRight)
         );
-        assert_eq!(mouse_scroll_action(MouseEventKind::Moved), None);
+        assert_eq!(mouse_scroll_action(MouseEventKind::Moved, 1), None);
         assert!(repeats_viewport(
-            &mouse_scroll_action(MouseEventKind::ScrollDown).expect("vertical scrolling has an action")
+            &mouse_scroll_action(MouseEventKind::ScrollDown, 2).expect("vertical scrolling has an action")
         ));
         assert!(!repeats_viewport(
-            &mouse_scroll_action(MouseEventKind::ScrollRight).expect("horizontal scrolling has an action")
+            &mouse_scroll_action(MouseEventKind::ScrollRight, 1).expect("horizontal scrolling has an action")
         ));
     }
 

From 2f46b67c3e5a1a8af306fdec01d27ffb7bb8f17f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 21:00:48 +0200
Subject: [PATCH 030/282] perf: compact tix history storage

Store persistent ancestry once as index-addressed commits with flat u32 parent edges instead of repeating object IDs in cached parent lists. Use compact vector walk state for refresh and ahead/behind calculations, and share immutable display rows between the active view, append-only cache, and lane worker.

Keep lane-local parent pruning out of the append-only cache so later view projections retain off-screen ancestry needed for expansion.

This preserves fast incremental refreshes and navigation while reducing peak memory on the 1.35-million-commit Linux history from 1.45 GB to 796 MB, with startup changing from 3.35s to 3.49s.
---
 gix-tix/src/app.rs     |  92 ++++++--
 gix-tix/src/history.rs | 476 ++++++++++++++++++++++++++---------------
 gix-tix/src/lib.rs     |   6 +-
 3 files changed, 370 insertions(+), 204 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index c7066e6bba9..7839496d70f 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1,6 +1,7 @@
 use std::{
     collections::{HashMap, HashSet},
     ops::Range,
+    sync::Arc,
     time::{Duration, Instant},
 };
 
@@ -205,6 +206,7 @@ pub(crate) enum AttributionKind {
 
 pub(crate) type LoadedCommit = Commit<BString>;
 pub(crate) type CommitRow = Commit<Range<usize>>;
+pub(crate) type SharedCommitRow = Arc<CommitRow>;
 
 #[derive(Debug)]
 pub(crate) struct LoadedCommits {
@@ -304,8 +306,8 @@ pub(crate) enum Effect {
 
 #[derive(Debug)]
 pub(crate) struct App {
-    pub rows: Vec<CommitRow>,
-    all_rows: HashMap<ObjectId, CommitRow>,
+    pub rows: Vec<SharedCommitRow>,
+    all_rows: HashMap<ObjectId, SharedCommitRow>,
     all_order: Vec<ObjectId>,
     hidden_rows: HashSet<ObjectId>,
     pending_hidden_rows: Option<HashSet<ObjectId>>,
@@ -473,7 +475,7 @@ impl App {
         }
     }
 
-    fn store_commits(&mut self, commits: LoadedCommits) -> Vec<CommitRow> {
+    fn store_commits(&mut self, commits: LoadedCommits) -> Vec<SharedCommitRow> {
         let LoadedCommits { rows, attributions } = commits;
         self.titles.reserve(rows.iter().map(|row| row.title.len()).sum());
         let attribution_base = self.attributions.len();
@@ -493,7 +495,8 @@ impl App {
                     has_agent_marker: row.has_agent_marker,
                     signature: row.signature,
                 };
-                if self.all_rows.insert(row.id, row.clone()).is_none() {
+                let row = Arc::new(row);
+                if self.all_rows.insert(row.id, Arc::clone(&row)).is_none() {
                     self.all_order.push(row.id);
                 }
                 row
@@ -523,6 +526,7 @@ impl App {
         if row.metadata_loaded {
             return;
         }
+        let row = Arc::make_mut(row);
         let Metadata {
             committer_time,
             author,
@@ -542,7 +546,7 @@ impl App {
         row.metadata_loaded = true;
         row.has_agent_marker = has_agent_marker;
         row.signature = signature;
-        self.all_rows.insert(row.id, row.clone());
+        self.all_rows.insert(row.id, Arc::clone(&self.rows[index]));
     }
 
     pub(crate) fn title(&self, row: &CommitRow) -> &BStr {
@@ -745,14 +749,18 @@ impl App {
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
-                let ids: Vec<_> = self.rows[start..end]
+                let changed: Vec<_> = self.rows[start..end]
                     .iter_mut()
                     .filter(|row| !self.hidden_rows.contains(&row.id) && row.signature == SignatureState::Unverified)
                     .map(|row| {
-                        row.signature = SignatureState::Verifying;
-                        row.id
+                        Arc::make_mut(row).signature = SignatureState::Verifying;
+                        (row.id, Arc::clone(row))
                     })
                     .collect();
+                for (id, row) in &changed {
+                    self.all_rows.insert(*id, Arc::clone(row));
+                }
+                let ids: Vec<_> = changed.into_iter().map(|(id, _)| id).collect();
                 if !ids.is_empty() {
                     self.signature_verification_running = true;
                     return vec![Effect::VerifySignatures(ids)];
@@ -804,7 +812,7 @@ impl App {
         Vec::new()
     }
 
-    pub(crate) fn start_lane_computation(&mut self) -> Option<Vec<CommitRow>> {
+    pub(crate) fn start_lane_computation(&mut self) -> Option<Vec<SharedCommitRow>> {
         match self.state {
             State::Loading => {
                 self.state = State::Computing;
@@ -831,7 +839,7 @@ impl App {
         view_tips: &[ObjectId],
         hidden_tips: &[ObjectId],
         select_top: bool,
-    ) -> Option<Vec<CommitRow>> {
+    ) -> Option<Vec<SharedCommitRow>> {
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -851,7 +859,7 @@ impl App {
             .all_order
             .iter()
             .filter(|id| visible.contains(*id) || boundary.contains(*id))
-            .filter_map(|id| self.all_rows.get(id).cloned())
+            .filter_map(|id| self.all_rows.get(id).map(Arc::clone))
             .collect();
         self.pending_hidden_rows = Some(boundary);
         self.select_top_after_refresh = select_top;
@@ -874,7 +882,7 @@ impl App {
         reachable
     }
 
-    pub(crate) fn finish_lane_computation(&mut self, rows: Vec<CommitRow>, graph: Graph, lane_time: Duration) {
+    pub(crate) fn finish_lane_computation(&mut self, rows: Vec<SharedCommitRow>, graph: Graph, lane_time: Duration) {
         if self.state != State::Computing {
             return;
         }
@@ -908,6 +916,7 @@ impl App {
         }
         for row in &mut self.rows {
             if let Some(metadata) = metadata.get(&row.id) {
+                let row = Arc::make_mut(row);
                 row.committer_time = metadata.committer_time;
                 row.author = metadata.author;
                 row.attributions = metadata.attributions.clone();
@@ -964,16 +973,17 @@ impl App {
     pub(crate) fn finish_signature_verification(&mut self, results: Vec<(ObjectId, bool)>) {
         let mut failed = 0;
         for (id, valid) in results {
-            let Some(row) = self.rows.iter_mut().find(|row| row.id == id) else {
+            let Some(index) = self.rows.iter().position(|row| row.id == id) else {
                 continue;
             };
+            let row = Arc::make_mut(&mut self.rows[index]);
             row.signature = if valid {
                 SignatureState::Verified
             } else {
                 failed += 1;
                 SignatureState::Failed
             };
-            self.all_rows.insert(row.id, row.clone());
+            self.all_rows.insert(id, Arc::clone(&self.rows[index]));
         }
         self.signature_verification_running = false;
         self.signature_failures = failed;
@@ -1198,11 +1208,16 @@ impl App {
         if self.signature_failures == 0 {
             return;
         }
+        let mut changed = Vec::new();
         for row in &mut self.rows {
             if row.signature == SignatureState::Failed {
-                row.signature = SignatureState::Unverified;
+                Arc::make_mut(row).signature = SignatureState::Unverified;
+                changed.push((row.id, Arc::clone(row)));
             }
         }
+        for (id, row) in changed {
+            self.all_rows.insert(id, row);
+        }
         self.signature_failures = 0;
     }
 
@@ -1325,11 +1340,13 @@ impl App {
     }
 }
 
-fn estimate_lane_width(rows: &[CommitRow]) -> usize {
+fn estimate_lane_width(rows: &[SharedCommitRow]) -> usize {
     let mut rows = rows.to_vec();
     let known: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
     for row in &mut rows {
-        row.parent_ids.retain(|id| known.contains_key(id));
+        if row.parent_ids.iter().any(|id| !known.contains_key(id)) {
+            Arc::make_mut(row).parent_ids.retain(|id| known.contains_key(id));
+        }
     }
     let graph = Graph::new(&rows);
     graph
@@ -1340,10 +1357,12 @@ fn estimate_lane_width(rows: &[CommitRow]) -> usize {
         .unwrap_or_default()
 }
 
-pub(crate) fn compute_lanes(mut rows: Vec<CommitRow>) -> (Vec<CommitRow>, Graph, Duration) {
+pub(crate) fn compute_lanes(mut rows: Vec<SharedCommitRow>) -> (Vec<SharedCommitRow>, Graph, Duration) {
     let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
     for row in &mut rows {
-        row.parent_ids.retain(|id| positions.contains_key(id));
+        if row.parent_ids.iter().any(|id| !positions.contains_key(id)) {
+            Arc::make_mut(row).parent_ids.retain(|id| positions.contains_key(id));
+        }
     }
     let mut children = vec![0usize; rows.len()];
     for row in rows.iter() {
@@ -1397,7 +1416,7 @@ pub(crate) struct Graph {
 }
 
 impl Graph {
-    fn new(rows: &[CommitRow]) -> Self {
+    fn new(rows: &[SharedCommitRow]) -> Self {
         let mut state = LaneState::default();
         let mut graph = Graph {
             offsets: Vec::with_capacity(rows.len().div_ceil(CHECKPOINT_INTERVAL) + 1),
@@ -1414,7 +1433,7 @@ impl Graph {
         graph
     }
 
-    fn render(&self, rows: &[CommitRow], range: Range<usize>) -> RenderedLanes {
+    fn render(&self, rows: &[SharedCommitRow], range: Range<usize>) -> RenderedLanes {
         let start = range.start.min(rows.len());
         let end = range.end.min(rows.len());
         if start >= end {
@@ -1767,6 +1786,33 @@ mod tests {
             app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
             [id(4), id(3), id(2), id(1)]
         );
+        assert!(
+            app.rows
+                .iter()
+                .all(|row| Arc::ptr_eq(row, app.all_rows.get(&row.id).expect("visible rows remain cached"))),
+            "the active projection shares its immutable rows with the append-only cache"
+        );
+    }
+
+    #[test]
+    fn lane_computation_keeps_cached_parents_outside_the_current_view() {
+        let mut app = App::new(3);
+        app.extend_commits(vec![row_with_parents(2, &[1])]);
+        app.extend_hidden_commits(vec![row_with_parents(1, &[0])]);
+        let rows = app
+            .start_lane_computation()
+            .expect("loading rows starts lane computation");
+        let (rows, graph, elapsed) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, elapsed);
+
+        let rows = app
+            .start_refresh(vec![row(0)].into(), &[id(2)], &[], false)
+            .expect("refresh projects the extended ancestry");
+        assert_eq!(
+            rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(2), id(1), id(0)],
+            "lane pruning does not disconnect cached ancestry needed by a later expansion"
+        );
     }
 
     #[test]
@@ -1846,7 +1892,7 @@ mod tests {
         let mut app = App::new(2);
         app.extend_commits(vec![row(1), row(2), row(3)]);
         for row in &mut app.rows {
-            row.signature = SignatureState::Unverified;
+            Arc::make_mut(row).signature = SignatureState::Unverified;
         }
         app.offset = 1;
 
@@ -2049,7 +2095,7 @@ mod tests {
         app.extend_commits(vec![row(1), row(2), row(3)]);
         app.update(Action::Last);
         app.extend_hidden_commits(vec![row(4)]);
-        app.rows[3].signature = SignatureState::Unverified;
+        Arc::make_mut(&mut app.rows[3]).signature = SignatureState::Unverified;
 
         assert_eq!(
             app.selected,
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index c8d888a9c5c..9a8109652f6 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -44,10 +44,40 @@ pub(crate) struct SelectionRef {
     pub upstream: Option<Option<ObjectId>>,
 }
 
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub(crate) struct CommitIndex(u32);
+
+impl CommitIndex {
+    fn new(index: usize) -> Result<Self> {
+        Ok(CommitIndex(
+            index
+                .try_into()
+                .context("tix cannot index more than u32::MAX commits")?,
+        ))
+    }
+
+    pub(crate) fn as_usize(self) -> usize {
+        self.0 as usize
+    }
+}
+
+#[derive(Clone, Debug)]
+struct GraphCommit {
+    id: ObjectId,
+    parents: std::ops::Range<u32>,
+    commit_time: gix::date::SecondsSinceUnixEpoch,
+    generation: u32,
+    state: u8,
+}
+
+impl GraphCommit {
+    fn generation(&self) -> Option<gix::revwalk::graph::Generation> {
+        (self.generation != 0).then_some(self.generation)
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default)]
 struct Node {
-    complete: bool,
-    stored: bool,
     flags: u8,
     expanded: u8,
     emitted: bool,
@@ -55,9 +85,12 @@ struct Node {
 
 #[derive(Debug, Default)]
 pub(crate) struct HistoryGraph {
-    commits: gix::revwalk::graph::IdMap<gix::revwalk::graph::Commit<Node>>,
-    tracking: HashMap<ObjectId, Vec<SelectionRef>>,
-    relations: HashMap<(ObjectId, ObjectId), (usize, usize)>,
+    commits: Vec<GraphCommit>,
+    parents: Vec<CommitIndex>,
+    by_id: HashMap<ObjectId, CommitIndex>,
+    stored_order: Vec<CommitIndex>,
+    tracking: HashMap<CommitIndex, Vec<SelectionRef>>,
+    relations: HashMap<(CommitIndex, CommitIndex), (usize, usize)>,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -66,11 +99,11 @@ struct GenThenTime {
     time: gix::date::SecondsSinceUnixEpoch,
 }
 
-impl From<&gix::revwalk::graph::Commit<Node>> for GenThenTime {
-    fn from(commit: &gix::revwalk::graph::Commit<Node>) -> Self {
+impl From<&GraphCommit> for GenThenTime {
+    fn from(commit: &GraphCommit) -> Self {
         GenThenTime {
             generation: commit
-                .generation
+                .generation()
                 .unwrap_or(gix::commitgraph::GENERATION_NUMBER_INFINITY),
             time: commit.commit_time,
         }
@@ -90,6 +123,39 @@ impl PartialOrd for GenThenTime {
 }
 
 impl HistoryGraph {
+    fn intern(&mut self, id: ObjectId) -> Result<CommitIndex> {
+        if let Some(index) = self.by_id.get(&id) {
+            return Ok(*index);
+        }
+        let index = CommitIndex::new(self.commits.len())?;
+        self.commits.push(GraphCommit {
+            id,
+            parents: 0..0,
+            commit_time: 0,
+            generation: 0,
+            state: 0,
+        });
+        self.by_id.insert(id, index);
+        Ok(index)
+    }
+
+    fn index(&self, id: ObjectId) -> Option<CommitIndex> {
+        self.by_id.get(&id).copied()
+    }
+
+    pub(crate) fn id(&self, index: CommitIndex) -> ObjectId {
+        self.commits[index.as_usize()].id
+    }
+
+    fn parents(&self, index: CommitIndex) -> &[CommitIndex] {
+        let range = self.commits[index.as_usize()].parents.clone();
+        &self.parents[range.start as usize..range.end as usize]
+    }
+
+    fn parent_ids(&self, index: CommitIndex) -> gix::traverse::commit::ParentIds {
+        self.parents(index).iter().map(|parent| self.id(*parent)).collect()
+    }
+
     fn ensure_commit(
         &mut self,
         repo: &gix::Repository,
@@ -97,9 +163,10 @@ impl HistoryGraph {
         shallow: &HashSet<ObjectId>,
         id: ObjectId,
         buf: &mut Vec<u8>,
-    ) -> Result<()> {
-        if self.commits.contains_key(&id) {
-            return Ok(());
+    ) -> Result<CommitIndex> {
+        let index = self.intern(id)?;
+        if self.commits[index.as_usize()].state & NODE_LOADED != 0 {
+            return Ok(index);
         }
         let commit = gix::traverse::commit::find(cache, &repo.objects, &id, buf)
             .context("could not load commit for cached history traversal")?;
@@ -138,16 +205,27 @@ impl HistoryGraph {
         if shallow.contains(&id) {
             parents.clear();
         }
-        self.commits.insert(
-            id,
-            gix::revwalk::graph::Commit {
-                parents,
-                commit_time,
-                generation,
-                data: Node::default(),
-            },
-        );
-        Ok(())
+        let parents: Vec<_> = parents
+            .into_iter()
+            .map(|parent| self.intern(parent))
+            .collect::<Result<_>>()?;
+        let start: u32 = self
+            .parents
+            .len()
+            .try_into()
+            .context("tix cannot index more than u32::MAX parent edges")?;
+        self.parents.extend(parents);
+        let end: u32 = self
+            .parents
+            .len()
+            .try_into()
+            .context("tix cannot index more than u32::MAX parent edges")?;
+        let node = &mut self.commits[index.as_usize()];
+        node.parents = start..end;
+        node.commit_time = commit_time;
+        node.generation = generation.unwrap_or_default();
+        node.state |= NODE_LOADED;
+        Ok(index)
     }
 
     #[expect(clippy::too_many_arguments)]
@@ -156,23 +234,24 @@ impl HistoryGraph {
         repo: &gix::Repository,
         cache: Option<&gix::commitgraph::Graph>,
         shallow: &HashSet<ObjectId>,
-        states: &mut HashMap<ObjectId, WalkState>,
-        queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, ObjectId>,
+        states: &mut Vec<WalkState>,
+        queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, CommitIndex>,
         buf: &mut Vec<u8>,
         id: ObjectId,
         flags: u8,
     ) -> Result<()> {
-        self.ensure_commit(repo, cache, shallow, id, buf)?;
-        let state = states.entry(id).or_default();
+        let index = self.ensure_commit(repo, cache, shallow, id, buf)?;
+        states.resize(self.commits.len(), WalkState::default());
+        let state = &mut states[index.as_usize()];
         if state.flags & flags != flags {
             state.flags |= flags;
-            queue.insert(self.commits[&id].commit_time, id);
+            queue.insert(self.commits[index.as_usize()].commit_time, index);
         }
         Ok(())
     }
 
     pub(crate) fn selection_refs(&self, id: ObjectId, decorations: &Decorations) -> Vec<SelectionRef> {
-        let tracked = self.tracking.get(&id);
+        let tracked = self.index(id).and_then(|index| self.tracking.get(&index));
         let mut refs: Vec<_> = decorations
             .get(&id)
             .into_iter()
@@ -205,11 +284,12 @@ impl HistoryGraph {
     ) -> Option<crate::app::SelectionRelation> {
         let has_upstream = refs.iter().any(|reference| reference.upstream.is_some());
         for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
-            let relation = if let Some(relation) = self.relations.get(&(id, upstream)).copied() {
+            let pair = self.index(id).zip(self.index(upstream))?;
+            let relation = if let Some(relation) = self.relations.get(&pair).copied() {
                 Some(relation)
             } else {
                 let relation = self.paint(id, std::slice::from_ref(&upstream))?;
-                self.relations.insert((id, upstream), relation);
+                self.relations.insert(pair, relation);
                 Some(relation)
             };
             if let Some((ahead, behind)) = relation {
@@ -224,56 +304,53 @@ impl HistoryGraph {
     }
 
     fn paint(&self, first: ObjectId, others: &[ObjectId]) -> Option<(usize, usize)> {
-        if !self.commits.contains_key(&first) || others.iter().any(|id| !self.commits.contains_key(id)) {
-            return None;
-        }
-        let mut flags = HashMap::<ObjectId, u8>::new();
-        let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, ObjectId>::new();
-        let mut queued = HashSet::new();
+        let first = self.index(first)?;
+        let others: Vec<_> = others.iter().map(|id| self.index(*id)).collect::<Option<_>>()?;
+        let mut flags = vec![0u8; self.commits.len()];
+        let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, CommitIndex>::new();
+        let mut queued = vec![false; self.commits.len()];
         let mut pending = 0usize;
-        for (id, flag) in std::iter::once((first, VISIBLE)).chain(others.iter().copied().map(|id| (id, HIDDEN))) {
-            *flags.entry(id).or_default() |= flag;
-            if queued.insert(id) {
-                queue.insert(GenThenTime::from(&self.commits[&id]), id);
+        for (index, flag) in std::iter::once((first, VISIBLE)).chain(others.into_iter().map(|index| (index, HIDDEN))) {
+            flags[index.as_usize()] |= flag;
+            if !queued[index.as_usize()] {
+                queued[index.as_usize()] = true;
+                queue.insert(GenThenTime::from(&self.commits[index.as_usize()]), index);
                 pending += 1;
             }
         }
         while pending != 0 {
-            let Some((_priority, id)) = queue.pop() else { break };
-            queued.remove(&id);
-            let mut propagated = flags[&id];
+            let Some((_priority, index)) = queue.pop() else { break };
+            queued[index.as_usize()] = false;
+            let mut propagated = flags[index.as_usize()];
             if propagated & STALE == 0 {
                 pending -= 1;
             }
             if propagated & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN {
                 propagated |= STALE;
-                *flags.get_mut(&id).expect("queued commits have flags") = propagated;
+                flags[index.as_usize()] = propagated;
             }
-            for &parent in &self.commits[&id].parents {
-                let Some(commit) = self.commits.get(&parent) else {
-                    continue;
-                };
-                let parent_flags = flags.entry(parent).or_default();
+            for &parent in self.parents(index) {
+                let parent_flags = &mut flags[parent.as_usize()];
                 let previous = *parent_flags;
                 if previous & propagated != propagated {
                     *parent_flags = previous | propagated;
-                    if queued.contains(&parent) {
+                    if queued[parent.as_usize()] {
                         if previous & STALE == 0 && *parent_flags & STALE != 0 {
                             pending -= 1;
                         }
                     } else {
-                        queued.insert(parent);
+                        queued[parent.as_usize()] = true;
                         if *parent_flags & STALE == 0 {
                             pending += 1;
                         }
-                        queue.insert(GenThenTime::from(commit), parent);
+                        queue.insert(GenThenTime::from(&self.commits[parent.as_usize()]), parent);
                     }
                 }
             }
         }
         let mut ahead = 0;
         let mut behind = 0;
-        for flags in flags.into_values() {
+        for flags in flags {
             match flags & (VISIBLE | HIDDEN) {
                 VISIBLE => ahead += 1,
                 HIDDEN => behind += 1,
@@ -303,7 +380,7 @@ impl HistoryGraph {
             .context("could not open commit-graph for history refresh")?;
         let local_refs = local_refs_by_target(repo)?;
         let mut tracking = HashMap::new();
-        let mut states = HashMap::<ObjectId, WalkState>::new();
+        let mut states = vec![WalkState::default(); self.commits.len()];
         let mut queue = gix::revwalk::PriorityQueue::new();
         let mut buf = Vec::new();
         for id in refs.view_tips.iter().chain(&refs.hidden_tips).copied() {
@@ -331,7 +408,8 @@ impl HistoryGraph {
             )?;
         }
         for (&id, names) in &local_refs {
-            if self.commits.get(&id).is_none_or(|commit| !commit.data.stored) {
+            let Some(index) = self.index(id) else { continue };
+            if self.commits[index.as_usize()].state & NODE_STORED == 0 {
                 continue;
             }
             let tracked = resolve_tracking(repo, names)?;
@@ -359,24 +437,27 @@ impl HistoryGraph {
                     INTERNAL,
                 )?;
             }
-            tracking.insert(id, tracked);
+            tracking.insert(index, tracked);
         }
 
         let mut rows = Vec::new();
         let mut attributions = Vec::new();
-        while let Some((_time, id)) = queue.pop() {
-            let Some(state) = states.get_mut(&id) else { continue };
+        while let Some((_time, index)) = queue.pop() {
+            let state = &mut states[index.as_usize()];
             let delta = state.flags & !state.expanded;
             if delta == 0 {
                 continue;
             }
             state.expanded |= delta;
-            let commit = &self.commits[&id];
-            let was_stored = commit.data.stored;
-            let stop = commit.data.complete && (delta & EXPAND == 0 || was_stored && !expand.contains(&id));
+            let id = self.id(index);
+            let commit = &self.commits[index.as_usize()];
+            let was_stored = commit.state & NODE_STORED != 0;
+            let stop =
+                commit.state & NODE_COMPLETE != 0 && (delta & EXPAND == 0 || was_stored && !expand.contains(&id));
             let should_store = delta & (VISIBLE | EXPAND) != 0 && !was_stored;
-            let parent_ids = commit.parents.clone();
-            let generation = commit.generation;
+            let parent_indices = self.parents(index).to_vec();
+            let parent_ids = self.parent_ids(index);
+            let generation = commit.generation();
             if should_store {
                 if let Some(names) = local_refs.get(&id) {
                     let tracked = resolve_tracking(repo, names)?;
@@ -404,7 +485,7 @@ impl HistoryGraph {
                             INTERNAL,
                         )?;
                     }
-                    tracking.insert(id, tracked);
+                    tracking.insert(index, tracked);
                 }
                 let metadata = if generation.is_some() {
                     None
@@ -440,16 +521,13 @@ impl HistoryGraph {
                     has_agent_marker,
                     signature,
                 });
-                self.commits
-                    .get_mut(&id)
-                    .expect("loaded commit remains present")
-                    .data
-                    .stored = true;
+                self.commits[index.as_usize()].state |= NODE_STORED;
+                self.stored_order.push(index);
             }
             if stop {
                 continue;
             }
-            for parent in parent_ids {
+            for parent in parent_indices {
                 self.schedule_cached(
                     repo,
                     cache.as_ref(),
@@ -457,18 +535,14 @@ impl HistoryGraph {
                     &mut states,
                     &mut queue,
                     &mut buf,
-                    parent,
+                    self.id(parent),
                     delta & (VISIBLE | INTERNAL | EXPAND),
                 )?;
             }
         }
-        for (id, state) in states {
+        for (index, state) in states.into_iter().enumerate() {
             if state.expanded & (VISIBLE | INTERNAL | EXPAND) != 0 {
-                self.commits
-                    .get_mut(&id)
-                    .expect("walked commits remain cached")
-                    .data
-                    .complete = true;
+                self.commits[index].state |= NODE_COMPLETE;
             }
         }
         self.tracking = tracking;
@@ -505,39 +579,42 @@ const INTERNAL: u8 = 1 << 1;
 const HIDDEN: u8 = 1 << 2;
 const STALE: u8 = 1 << 3;
 const EXPAND: u8 = 1 << 4;
+const NODE_LOADED: u8 = 1 << 0;
+const NODE_COMPLETE: u8 = 1 << 1;
+const NODE_STORED: u8 = 1 << 2;
 
-#[derive(Default)]
+#[derive(Clone, Copy, Default)]
 struct WalkState {
     flags: u8,
     expanded: u8,
 }
 
+#[expect(clippy::too_many_arguments)]
 fn schedule(
-    graph: &mut gix::revwalk::Graph<'_, '_, gix::revwalk::graph::Commit<Node>>,
-    queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, ObjectId>,
+    graph: &mut HistoryGraph,
+    repo: &gix::Repository,
+    cache: Option<&gix::commitgraph::Graph>,
+    states: &mut Vec<Node>,
+    queue: &mut gix::revwalk::PriorityQueue<gix::date::SecondsSinceUnixEpoch, CommitIndex>,
     shallow: &HashSet<ObjectId>,
+    buf: &mut Vec<u8>,
     id: ObjectId,
     flags: u8,
 ) -> Result<()> {
-    let Some(commit) = graph
-        .get_or_insert_full_commit(id, |commit| {
-            if shallow.contains(&id) {
-                commit.parents.clear();
-            }
-        })
-        .context("could not load commit for history traversal")?
-    else {
-        return Ok(());
-    };
-    if commit.data.flags & flags != flags {
-        commit.data.flags |= flags;
-        queue.insert(commit.commit_time, id);
+    let index = graph.ensure_commit(repo, cache, shallow, id, buf)?;
+    states.resize(graph.commits.len(), Node::default());
+    let state = &mut states[index.as_usize()];
+    if state.flags & flags != flags {
+        state.flags |= flags;
+        queue.insert(graph.commits[index.as_usize()].commit_time, index);
     }
     Ok(())
 }
 
 fn hidden_frontier(
-    graph: &mut gix::revwalk::Graph<'_, '_, gix::revwalk::graph::Commit<Node>>,
+    graph: &mut HistoryGraph,
+    repo: &gix::Repository,
+    cache: Option<&gix::commitgraph::Graph>,
     visible_tips: &[ObjectId],
     hidden_tips: &[ObjectId],
     shallow: &HashSet<ObjectId>,
@@ -545,56 +622,41 @@ fn hidden_frontier(
     if hidden_tips.is_empty() {
         return Ok(HashSet::new());
     }
-    let mut flags = HashMap::<ObjectId, u8>::new();
-    let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, ObjectId>::new();
+    let mut flags = Vec::<u8>::new();
+    let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, CommitIndex>::new();
+    let mut buf = Vec::new();
     for (tips, flag) in [(visible_tips, VISIBLE), (hidden_tips, HIDDEN)] {
         for &id in tips {
-            let Some(commit) = graph
-                .get_or_insert_full_commit(id, |commit| {
-                    if shallow.contains(&id) {
-                        commit.parents.clear();
-                    }
-                })
-                .context("could not load commit while preparing hidden history")?
-            else {
-                continue;
-            };
-            *flags.entry(id).or_default() |= flag;
-            queue.insert(GenThenTime::from(&*commit), id);
+            let index = graph.ensure_commit(repo, cache, shallow, id, &mut buf)?;
+            flags.resize(graph.commits.len(), 0);
+            flags[index.as_usize()] |= flag;
+            queue.insert(GenThenTime::from(&graph.commits[index.as_usize()]), index);
         }
     }
-    while queue
-        .iter_unordered()
-        .any(|id| flags.get(id).is_some_and(|flags| flags & STALE == 0))
-    {
-        let Some((_priority, id)) = queue.pop() else { break };
-        let mut propagated = flags[&id];
+    while queue.iter_unordered().any(|index| flags[index.as_usize()] & STALE == 0) {
+        let Some((_priority, index)) = queue.pop() else { break };
+        let mut propagated = flags[index.as_usize()];
         if propagated & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN {
             propagated |= STALE;
-            *flags.get_mut(&id).expect("queued commits have flags") = propagated;
+            flags[index.as_usize()] = propagated;
         }
-        let parents = graph.get(&id).expect("queued commits are loaded").parents.clone();
+        let parents = graph.parents(index).to_vec();
         for parent in parents {
-            let Some(commit) = graph
-                .get_or_insert_full_commit(parent, |commit| {
-                    if shallow.contains(&parent) {
-                        commit.parents.clear();
-                    }
-                })
-                .context("could not load hidden commit parent")?
-            else {
-                continue;
-            };
-            let parent_flags = flags.entry(parent).or_default();
+            let parent_id = graph.id(parent);
+            let parent = graph.ensure_commit(repo, cache, shallow, parent_id, &mut buf)?;
+            flags.resize(graph.commits.len(), 0);
+            let parent_flags = &mut flags[parent.as_usize()];
             if *parent_flags & propagated != propagated {
                 *parent_flags |= propagated;
-                queue.insert(GenThenTime::from(&*commit), parent);
+                queue.insert(GenThenTime::from(&graph.commits[parent.as_usize()]), parent);
             }
         }
     }
     Ok(flags
         .into_iter()
-        .filter_map(|(id, flags)| (flags & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN).then_some(id))
+        .enumerate()
+        .filter(|(_, flags)| flags & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN)
+        .map(|(index, _)| graph.id(CommitIndex(index as u32)))
         .collect())
 }
 
@@ -690,44 +752,80 @@ pub(crate) fn load(
     let commit_graph = repo
         .commit_graph_if_enabled()
         .context("could not open commit-graph for history traversal")?;
-    let mut graph = repo.revision_graph::<gix::revwalk::graph::Commit<Node>>(commit_graph.as_ref());
-    let hidden = hidden_frontier(&mut graph, &tips, &hidden_tips, &shallow)?;
+    let mut graph = HistoryGraph::default();
+    let hidden = hidden_frontier(&mut graph, repo, commit_graph.as_ref(), &tips, &hidden_tips, &shallow)?;
     let local_refs = local_refs_by_target(repo)?;
     let mut tracking = HashMap::new();
+    let mut states = vec![Node::default(); graph.commits.len()];
     let mut queue = gix::revwalk::PriorityQueue::new();
+    let mut buf = Vec::new();
     for &tip in &tips {
-        schedule(&mut graph, &mut queue, &shallow, tip, VISIBLE)?;
+        schedule(
+            &mut graph,
+            repo,
+            commit_graph.as_ref(),
+            &mut states,
+            &mut queue,
+            &shallow,
+            &mut buf,
+            tip,
+            VISIBLE,
+        )?;
     }
     let mut rows = Vec::with_capacity(COMMIT_BATCH_SIZE);
     let mut attributions = Vec::with_capacity(COMMIT_BATCH_SIZE);
     let mut connected = Vec::new();
     let mut connected_seen = HashSet::new();
-    while let Some((_time, id)) = queue.pop() {
+    while let Some((_time, index)) = queue.pop() {
         if cancelled.load(Ordering::Relaxed) {
             emit(Event::Cancelled);
             return Ok(());
         }
-        let commit = graph.get_mut(&id).expect("queued commits are loaded");
-        let delta = commit.data.flags & !commit.data.expanded;
-        if delta == 0 {
-            continue;
-        }
-        commit.data.expanded |= delta;
-        commit.data.complete = true;
-        let should_emit = delta & VISIBLE != 0 && !commit.data.emitted && !hidden.contains(&id);
-        commit.data.emitted |= should_emit;
-        commit.data.stored |= should_emit;
-        let parent_ids = commit.parents.clone();
-        let generation = commit.generation;
+        let id = graph.id(index);
+        let (delta, should_emit) = {
+            let state = &mut states[index.as_usize()];
+            let delta = state.flags & !state.expanded;
+            if delta == 0 {
+                continue;
+            }
+            state.expanded |= delta;
+            let should_emit = delta & VISIBLE != 0 && !state.emitted && !hidden.contains(&id);
+            state.emitted |= should_emit;
+            (delta, should_emit)
+        };
+        graph.commits[index.as_usize()].state |= NODE_COMPLETE;
+        let parent_indices = graph.parents(index).to_vec();
+        let parent_ids = graph.parent_ids(index);
+        let generation = graph.commits[index.as_usize()].generation();
         if should_emit && let Some(names) = local_refs.get(&id) {
             let refs = resolve_tracking(repo, names)?;
             if refs.iter().any(|reference| reference.upstream.flatten().is_some()) {
-                schedule(&mut graph, &mut queue, &shallow, id, INTERNAL)?;
+                schedule(
+                    &mut graph,
+                    repo,
+                    commit_graph.as_ref(),
+                    &mut states,
+                    &mut queue,
+                    &shallow,
+                    &mut buf,
+                    id,
+                    INTERNAL,
+                )?;
             }
             for upstream in refs.iter().filter_map(|reference| reference.upstream.flatten()) {
-                schedule(&mut graph, &mut queue, &shallow, upstream, INTERNAL)?;
+                schedule(
+                    &mut graph,
+                    repo,
+                    commit_graph.as_ref(),
+                    &mut states,
+                    &mut queue,
+                    &shallow,
+                    &mut buf,
+                    upstream,
+                    INTERNAL,
+                )?;
             }
-            tracking.insert(id, refs);
+            tracking.insert(index, refs);
         }
         let metadata = if !should_emit || generation.is_some() {
             None
@@ -767,6 +865,8 @@ pub(crate) fn load(
                 has_agent_marker,
                 signature,
             });
+            graph.commits[index.as_usize()].state |= NODE_STORED;
+            graph.stored_order.push(index);
             if rows.len() == COMMIT_BATCH_SIZE
                 && !emit(Event::Commits(LoadedCommits {
                     rows: std::mem::replace(&mut rows, Vec::with_capacity(COMMIT_BATCH_SIZE)),
@@ -781,14 +881,25 @@ pub(crate) fn load(
         } else {
             delta & (VISIBLE | INTERNAL)
         };
-        for parent in parent_ids {
-            let parent_flags = if hidden.contains(&parent) {
+        for parent in parent_indices {
+            let parent_id = graph.id(parent);
+            let parent_flags = if hidden.contains(&parent_id) {
                 propagated & !VISIBLE
             } else {
                 propagated
             };
             if parent_flags != 0 {
-                schedule(&mut graph, &mut queue, &shallow, parent, parent_flags)?;
+                schedule(
+                    &mut graph,
+                    repo,
+                    commit_graph.as_ref(),
+                    &mut states,
+                    &mut queue,
+                    &shallow,
+                    &mut buf,
+                    parent_id,
+                    parent_flags,
+                )?;
             }
         }
     }
@@ -796,7 +907,7 @@ pub(crate) fn load(
         return Ok(());
     }
     if !hidden_revisions.is_empty() {
-        connected.retain(|id| graph.get(id).is_none_or(|commit| !commit.data.emitted));
+        connected.retain(|id| graph.index(*id).is_none_or(|index| !states[index.as_usize()].emitted));
         let mut rows = Vec::with_capacity(connected.len());
         let mut attributions = Vec::new();
         let mut authors = gix::features::threading::lock(authors);
@@ -826,15 +937,10 @@ pub(crate) fn load(
                 has_agent_marker,
                 signature,
             });
-            if let Some(commit) = graph
-                .get_or_insert_full_commit(id, |commit| {
-                    if shallow.contains(&id) {
-                        commit.parents.clear();
-                    }
-                })
-                .context("could not retain connected hidden commit")?
-            {
-                commit.data.stored = true;
+            let index = graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, id, &mut buf)?;
+            if graph.commits[index.as_usize()].state & NODE_STORED == 0 {
+                graph.commits[index.as_usize()].state |= NODE_STORED;
+                graph.stored_order.push(index);
             }
         }
         if !rows.is_empty() && !emit(Event::HiddenCommits(LoadedCommits { rows, attributions })) {
@@ -842,11 +948,8 @@ pub(crate) fn load(
         }
     }
     emit(Event::VisibleComplete);
-    emit(Event::Complete(HistoryGraph {
-        commits: graph.detach(),
-        tracking,
-        relations: HashMap::new(),
-    }));
+    graph.tracking = tracking;
+    emit(Event::Complete(graph));
     Ok(())
 }
 
@@ -1165,6 +1268,24 @@ mod tests {
         ObjectId::Sha1(bytes)
     }
 
+    fn insert_commit(graph: &mut HistoryGraph, n: u8, parents: &[u8], generation: u32) {
+        let index = graph.intern(id(n)).expect("the small test graph fits in u32");
+        let parents: Vec<_> = parents
+            .iter()
+            .map(|parent| graph.intern(id(*parent)).expect("the small test graph fits in u32"))
+            .collect();
+        let start = graph.parents.len() as u32;
+        graph.parents.extend(parents);
+        let end = graph.parents.len() as u32;
+        graph.commits[index.as_usize()] = GraphCommit {
+            id: id(n),
+            parents: start..end,
+            commit_time: generation.into(),
+            generation,
+            state: NODE_LOADED,
+        };
+    }
+
     fn loaded(path: &std::path::Path, revisions: &[&str], hidden_revisions: &[&str]) -> Result<Vec<Event>> {
         let mut events = Vec::new();
         let authors =
@@ -1212,15 +1333,7 @@ mod tests {
             (6, vec![4], 4),
             (7, vec![5], 4),
         ] {
-            graph.commits.insert(
-                id(n),
-                gix::revwalk::graph::Commit {
-                    parents: parents.into_iter().map(id).collect(),
-                    commit_time: generation.into(),
-                    generation: Some(generation),
-                    data: Node::default(),
-                },
-            );
+            insert_commit(&mut graph, n, &parents, generation);
         }
 
         assert_eq!(
@@ -1435,10 +1548,17 @@ mod tests {
                 _ => None,
             })
             .expect("history loading returns the persistent graph");
-        let repo = gix::open(fixture.path())?;
-        let cached = graph.commits.get_mut(&main).expect("the tracking tip was scheduled");
-        assert!(cached.data.complete && !cached.data.stored);
-        cached.parents.push(id(255));
+        let repo = crate::open_test_repository(fixture.path())?;
+        let index = graph.index(main).expect("the tracking tip was scheduled");
+        let fake_parent = graph.intern(id(255)).expect("the small test graph fits in u32");
+        let mut parents = graph.parents(index).to_vec();
+        parents.push(fake_parent);
+        let start = graph.parents.len() as u32;
+        graph.parents.extend(parents);
+        let end = graph.parents.len() as u32;
+        let cached = &mut graph.commits[index.as_usize()];
+        assert!(cached.state & NODE_COMPLETE != 0 && cached.state & NODE_STORED == 0);
+        cached.parents = start..end;
 
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 27e908e903c..3a89ed54a37 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -22,8 +22,8 @@ use std::{
 
 use anyhow::{Context, Result};
 use app::{
-    Action, App, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesMode, CommitRow, ComparedParent, Effect,
-    PathChange, SelectionRelation, State,
+    Action, App, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesMode, ComparedParent, Effect, PathChange,
+    SelectionRelation, SharedCommitRow, State,
 };
 use crossterm::{
     clipboard::CopyToClipboard,
@@ -1407,7 +1407,7 @@ fn prepare_inline_exit(app: &mut App) {
     app.show_selection_tail = false;
 }
 
-fn start_lane_worker(rows: Vec<CommitRow>) -> mpsc::Receiver<(Vec<CommitRow>, app::Graph, Duration)> {
+fn start_lane_worker(rows: Vec<SharedCommitRow>) -> mpsc::Receiver<(Vec<SharedCommitRow>, app::Graph, Duration)> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
         let _ = sender.send(app::compute_lanes(rows));

From 29ee7daeee1992d61e3272821b3996f63913fbef Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 8 Aug 2026 21:24:00 +0200
Subject: [PATCH 031/282] perf: cache recently viewed tree changes

Keep a bounded MRU of immutable commit and merge-parent diff results while the changes view is open. Reuse changed paths, detached diff resources, and computed line counts when revisiting history without retaining unbounded data.

Worktree changes remain separately cached and invalidated by filesystem notifications.
---
 gix-tix/src/lib.rs | 124 ++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 111 insertions(+), 13 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 3a89ed54a37..7c5804bf111 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -8,6 +8,7 @@ mod logging;
 mod ui;
 
 use std::{
+    collections::VecDeque,
     ffi::OsString,
     io::{self, Write},
     path::{Path, PathBuf},
@@ -128,6 +129,42 @@ struct SelectionRelationCache {
     relation: Option<SelectionRelation>,
 }
 
+const TREE_CHANGES_CACHE_SIZE: usize = 8;
+type TreeChangesEntry = (gix::ObjectId, usize, Changes);
+
+#[derive(Default)]
+struct TreeChangesCache(VecDeque<TreeChangesEntry>);
+
+impl TreeChangesCache {
+    fn as_ref(&self) -> Option<&TreeChangesEntry> {
+        self.0.front()
+    }
+
+    fn activate(&mut self, id: gix::ObjectId, parent: usize) -> bool {
+        let Some(position) = self
+            .0
+            .iter()
+            .position(|(cached_id, cached_parent, _)| *cached_id == id && *cached_parent == parent)
+        else {
+            return false;
+        };
+        if position != 0 {
+            let entry = self.0.remove(position).expect("the cached position exists");
+            self.0.push_front(entry);
+        }
+        true
+    }
+
+    fn insert(&mut self, entry: TreeChangesEntry) {
+        self.0.push_front(entry);
+        self.0.truncate(TREE_CHANGES_CACHE_SIZE);
+    }
+
+    fn clear(&mut self) {
+        self.0.clear();
+    }
+}
+
 type LineCounts = Option<(u32, u32)>;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -728,7 +765,7 @@ fn event_loop(
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
-    let mut tree_changes = None;
+    let mut tree_changes = TreeChangesCache::default();
     let mut worktree_changes = None;
     let mut worktree_watcher: Option<WorktreeWatcher> = None;
     let mut worktree_refresh_deadline: Option<Instant> = None;
@@ -1604,7 +1641,7 @@ fn draw(
     authors: &SharedAuthors,
     fill_repository: &mut FillRepository,
     commit_message: &mut Option<(gix::ObjectId, BString)>,
-    tree_changes: &mut Option<(gix::ObjectId, usize, Changes)>,
+    tree_changes: &mut TreeChangesCache,
     worktree_changes: &mut Option<(usize, Changes)>,
     history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
@@ -1651,22 +1688,32 @@ fn draw(
     if changes_visible && selected.is_some() && tree_changes.as_ref().map(|(cached, _, _)| *cached) != selected {
         app.changes_parent = 0;
     }
-    let tree_changes_to_load = (changes_visible && app.changes_mode.is_some())
+    let desired_tree_changes = (changes_visible && app.changes_mode.is_some())
         .then_some(selected)
         .flatten()
-        .filter(|id| {
-            tree_changes
-                .as_ref()
-                .is_none_or(|(cached, parent, _)| *cached != *id || *parent != app.changes_parent)
-        });
+        .map(|id| (id, app.changes_parent));
+    let tree_changes_changed = desired_tree_changes.is_some_and(|(id, parent)| {
+        tree_changes
+            .as_ref()
+            .is_none_or(|(cached, cached_parent, _)| *cached != id || *cached_parent != parent)
+    });
+    let tree_selection = tree_changes_changed
+        .then(|| remembered_change_selection(&app.tree_changes, tree_changes.as_ref().map(|(_, _, changes)| changes)))
+        .flatten();
+    let tree_changes_to_load = desired_tree_changes
+        .filter(|(id, parent)| !tree_changes.activate(*id, *parent))
+        .map(|(id, _)| id);
+    if tree_changes_changed
+        && tree_changes_to_load.is_none()
+        && let Some(changes) = tree_changes.as_ref().map(|(_, _, changes)| changes)
+    {
+        restore_change_selection(&mut app.tree_changes, changes, tree_selection.clone());
+    }
     let worktree_changes_to_load = changes_visible
         && app.changes_mode == Some(ChangesMode::Both)
         && worktree_changes
             .as_ref()
             .is_none_or(|(marker, _)| *marker == usize::MAX);
-    let tree_selection = tree_changes_to_load.and_then(|_| {
-        remembered_change_selection(&app.tree_changes, tree_changes.as_ref().map(|(_, _, changes)| changes))
-    });
     let worktree_selection = worktree_changes_to_load
         .then(|| {
             remembered_change_selection(
@@ -1679,7 +1726,7 @@ fn draw(
         *commit_message = None;
     }
     if app.changes_mode.is_none() {
-        *tree_changes = None;
+        tree_changes.clear();
         *worktree_changes = None;
     }
     if let Some(id) = relation_to_load
@@ -1750,7 +1797,7 @@ fn draw(
             let loaded = loaded?;
             app.changes_parent = loaded.parent.map_or(0, |parent| parent.index);
             restore_change_selection(&mut app.tree_changes, &loaded, tree_selection);
-            *tree_changes = Some((id, app.changes_parent, loaded));
+            tree_changes.insert((id, app.changes_parent, loaded));
         }
         if worktree_changes_to_load {
             let started = Instant::now();
@@ -2779,6 +2826,57 @@ fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::
 mod tests {
     use super::*;
 
+    #[test]
+    fn caches_recent_tree_changes_by_commit_and_parent() {
+        let id = |value| {
+            let mut bytes = [0; 20];
+            bytes[19] = value;
+            gix::ObjectId::Sha1(bytes)
+        };
+        let mut cache = TreeChangesCache::default();
+        cache.insert((id(42), 0, Changes::default()));
+        cache.insert((
+            id(42),
+            1,
+            Changes {
+                lines_added: 42,
+                ..Changes::default()
+            },
+        ));
+        assert!(cache.activate(id(42), 0));
+        assert_eq!(cache.as_ref().map(|(_, parent, _)| *parent), Some(0));
+        assert!(cache.activate(id(42), 1));
+        assert_eq!(
+            cache.as_ref().map(|(_, _, changes)| changes.lines_added),
+            Some(42),
+            "each merge parent retains its own diff result"
+        );
+        cache.clear();
+
+        for value in 0..=TREE_CHANGES_CACHE_SIZE as u8 {
+            cache.insert((
+                id(value),
+                usize::from(value),
+                Changes {
+                    lines_added: u64::from(value),
+                    ..Changes::default()
+                },
+            ));
+        }
+
+        assert!(
+            cache.activate(id(1), 1),
+            "a recently viewed commit and parent restores its computed diff"
+        );
+        assert_eq!(cache.as_ref().map(|(_, _, changes)| changes.lines_added), Some(1));
+        assert!(!cache.activate(id(0), 0), "the oldest entry is evicted at the bound");
+        cache.clear();
+        assert!(
+            cache.as_ref().is_none(),
+            "closing the changes view releases cached diffs"
+        );
+    }
+
     #[test]
     fn copies_the_selected_path_from_the_focused_changes_block() {
         let mut app = App::new(1);

From be1ac5b816086cfd8b067aa687afce5440418d7e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 9 Aug 2026 04:34:16 +0200
Subject: [PATCH 032/282] fix: retain history selection for worktree-only
 changes

Decide whether a filesystem-triggered history refresh selects the top row only after comparing the watched traversal refs. Index and worktree notifications may still invalidate status data, but no longer move the history selection when the view and hidden refs are unchanged.

Also avoid marking an already-running refresh for top selection before the pending notification has been classified.
---
 gix-tix/src/lib.rs | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 7c5804bf111..5c319357a9c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -880,9 +880,6 @@ fn event_loop(
                             actionable += 1;
                             refresh_pending = true;
                             refresh_from_filesystem = true;
-                            if refresh_receiver.is_some() {
-                                refresh_select_top = true;
-                            }
                             if invalidate_worktree_changes(&mut worktree_changes) {
                                 dirty = true;
                                 urgent = true;
@@ -1073,7 +1070,7 @@ fn event_loop(
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed;
             tracing::debug!(tips_changed, hidden_changed, "compared reference snapshot");
-            let select_top = std::mem::take(&mut refresh_from_filesystem);
+            let select_top = std::mem::take(&mut refresh_from_filesystem) && tips_changed;
             ref_snapshot = next;
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };

From a123763865d0aa4f579406aee1e466632b194587 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 9 Aug 2026 04:52:50 +0200
Subject: [PATCH 033/282] fix: delay background refresh status

Keep the completed history footer stable for the first 500 ms of filesystem-triggered and manual refreshes. Reveal loading or computing state only when the combined traversal and lane work remains active beyond that threshold.

Initial history loading keeps its immediate progress behavior, and the existing event-loop deadline mechanism provides the delayed redraw without polling.
---
 gix-tix/src/app.rs |  2 ++
 gix-tix/src/lib.rs | 41 +++++++++++++++++++++++++++++----
 gix-tix/src/ui.rs  | 57 ++++++++++++++++++++++++++++++++++++++++++----
 3 files changed, 92 insertions(+), 8 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7839496d70f..667fb1c3266 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -320,6 +320,7 @@ pub(crate) struct App {
     pub selected: Option<usize>,
     pub offset: usize,
     pub state: State,
+    pub(crate) deferred_history_state: Option<State>,
     pub viewport_rows: usize,
     pub lane_time: Option<Duration>,
     pub show_committer_date: bool,
@@ -385,6 +386,7 @@ impl App {
             selected: None,
             offset: 0,
             state: State::Loading,
+            deferred_history_state: None,
             viewport_rows,
             lane_time: None,
             show_committer_date: true,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 5c319357a9c..21911d21c6a 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -49,6 +49,7 @@ use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
+const HISTORY_STATUS_DELAY: Duration = Duration::from_millis(500);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
@@ -823,6 +824,7 @@ fn event_loop(
     let mut history_finished = false;
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
+    let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
     let result: Result<Option<Duration>> = (|| loop {
         let mut worktree_watch_error = None;
@@ -946,6 +948,11 @@ fn event_loop(
                 schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
             }
         }
+        if take_due(&mut history_status_deadline, Instant::now()) {
+            app.deferred_history_state = None;
+            dirty = true;
+            urgent = true;
+        }
         if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
             repeat_deadline = None;
             if app.changes_suppressed {
@@ -974,6 +981,8 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    history_status_deadline = None;
+                    app.deferred_history_state = None;
                     selection_relation = None;
                     app.selection_relation = None;
                     lane_receiver = None;
@@ -1026,6 +1035,7 @@ fn event_loop(
             && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
+            let refresh_started = Instant::now();
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
                 Ok(repository) => repository,
                 Err(_err) if worktree_repository_is_gone(&repository_path) => {
@@ -1092,6 +1102,8 @@ fn event_loop(
             ));
             refresh_select_top = select_top;
             refresh_expand_hidden = false;
+            app.deferred_history_state = Some(app.state);
+            history_status_deadline = Some(refresh_started + HISTORY_STATUS_DELAY);
             app.state = State::Loading;
             tracing::info!(select_top, "started history refresh");
         }
@@ -1202,10 +1214,18 @@ fn event_loop(
             .map(|deadline| deadline.saturating_duration_since(Instant::now()))
             .or_else(|| worktree_watcher.as_ref().map(|_| REF_EVENT_INTERVAL));
         let retry_timeout = watcher_retry_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
-        let wake_after = [repeat_timeout, watcher_timeout, worktree_timeout, retry_timeout]
-            .into_iter()
-            .flatten()
-            .min();
+        let history_status_timeout =
+            history_status_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
+        let wake_after = [
+            repeat_timeout,
+            watcher_timeout,
+            worktree_timeout,
+            retry_timeout,
+            history_status_timeout,
+        ]
+        .into_iter()
+        .flatten()
+        .min();
         let terminal_event = match pending_terminal_event.take() {
             Some(event) => Some(event),
             None => match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
@@ -3870,5 +3890,18 @@ mod tests {
         assert!(schedule_once(&mut deadline, now, WATCH_RETRY_INTERVAL));
         assert!(!take_due(&mut deadline, now + Duration::from_secs(4)));
         assert!(take_due(&mut deadline, now + WATCH_RETRY_INTERVAL));
+
+        assert!(
+            schedule_once(&mut deadline, now, HISTORY_STATUS_DELAY),
+            "background progress gets its own deadline"
+        );
+        assert!(
+            !take_due(&mut deadline, now + Duration::from_millis(499)),
+            "the completed footer remains visible before 500 ms"
+        );
+        assert!(
+            take_due(&mut deadline, now + HISTORY_STATUS_DELAY),
+            "background progress becomes visible at 500 ms"
+        );
     }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8cb547b0bbc..61d2f532a65 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -586,7 +586,8 @@ pub(crate) fn draw_with_worktree(
         }
     }
 
-    let status = match app.state {
+    let history_state = app.deferred_history_state.unwrap_or(app.state);
+    let status = match history_state {
         State::Loading => "",
         State::Cancelling => " · cancelling",
         State::Computing => " · computing",
@@ -646,7 +647,7 @@ pub(crate) fn draw_with_worktree(
     if app.preview_author_copy && app.manual_refresh {
         footer_spans.extend([
             Span::raw(" · "),
-            toggle("R refresh", matches!(app.state, State::Complete | State::Cancelled)),
+            toggle("R refresh", matches!(history_state, State::Complete | State::Cancelled)),
         ]);
     }
     footer_spans.push(Span::raw(if app.preview_author_copy {
@@ -668,7 +669,7 @@ pub(crate) fn draw_with_worktree(
         ]);
     }
     if app.changes_focus.is_none() {
-        if app.state == State::Loading {
+        if history_state == State::Loading {
             footer_spans.push(Span::raw(" · Esc cancel"));
         }
         footer_spans.push(Span::raw(" · q quit"));
@@ -680,7 +681,7 @@ pub(crate) fn draw_with_worktree(
 }
 
 fn history_position(app: &App) -> String {
-    match (app.state, app.selected) {
+    match (app.deferred_history_state.unwrap_or(app.state), app.selected) {
         (State::Complete, Some(selected)) => format!("#{}", app.rows.len().saturating_sub(selected)),
         _ => format!("{} commits", app.rows.len()),
     }
@@ -1453,6 +1454,54 @@ mod tests {
         assert_eq!(history_position(&app), "#1");
     }
 
+    #[test]
+    fn keeps_the_completed_footer_while_background_progress_is_deferred() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id: gix::ObjectId::Sha1([1; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        complete(&mut app);
+        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let completed = rendered_line(&terminal, 1);
+
+        app.deferred_history_state = Some(State::Complete);
+        app.state = State::Computing;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(
+            rendered_line(&terminal, 1),
+            completed,
+            "short lane computation preserves the completed footer"
+        );
+
+        app.deferred_history_state = None;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let computing = rendered_line(&terminal, 1);
+        assert!(
+            computing.contains("1 commits · computing"),
+            "expired deferral reveals computation progress"
+        );
+        assert_ne!(computing, completed, "visible progress changes the footer");
+
+        app.deferred_history_state = Some(State::Complete);
+        app.state = State::Loading;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(
+            rendered_line(&terminal, 1),
+            completed,
+            "short traversal setup also preserves the completed footer"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_selection_info_beside_the_right_marker_without_dimming_it() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);

From 205a53ed137abc664dc249402c586988af67f0a8 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 10 Aug 2026 12:34:26 +0200
Subject: [PATCH 034/282] change!: always run tix in the alternate screen

Make the alternate screen the only terminal lifecycle for tix. Remove the public Screen modes and the standalone --screen option, then initialize and restore the terminal directly through ratatui for every session.

Delete the preliminary screen-size revision walk, inline height prediction, half-screen sizing, runtime transitions between terminal surfaces, inline resize handling, and the reduced static exit frame. Short histories now start exactly like long histories, retain the default tree and worktree changes view, and use the first terminal row instead of reserving inline spacers.

Remove the now-unused bounded history counting helper and all tests dedicated to inline geometry and screen switching. Keep the existing alternate-screen rendering, external pager suspension, input setup, refresh animation, and terminal restoration paths unchanged.
---
 gix-tix/src/app.rs     |   2 -
 gix-tix/src/history.rs |  36 ----
 gix-tix/src/lib.rs     | 407 ++---------------------------------------
 gix-tix/src/main.rs    |  47 +----
 gix-tix/src/ui.rs      |  24 +--
 5 files changed, 16 insertions(+), 500 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 667fb1c3266..ab4792b1b41 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -347,7 +347,6 @@ pub(crate) struct App {
     commit_page: usize,
     commit_max: usize,
     pub(crate) show_selection_tail: bool,
-    pub inline: bool,
     pub preview_author_copy: bool,
     reachability_anchor: Option<ObjectId>,
     junction_parent: Option<usize>,
@@ -413,7 +412,6 @@ impl App {
             commit_page: 1,
             commit_max: 0,
             show_selection_tail: true,
-            inline: false,
             preview_author_copy: false,
             reachability_anchor: None,
             junction_parent: None,
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 9a8109652f6..3e743f8bb58 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1086,30 +1086,6 @@ fn contains_agent_marker(message: &[u8]) -> bool {
         .any(|marker| message.windows(marker.len()).any(|window| window == *marker))
 }
 
-pub(crate) fn count_up_to(
-    repo: &gix::Repository,
-    revisions: &[OsString],
-    hidden_revisions: &[OsString],
-    limit: usize,
-) -> Result<usize> {
-    let Some(tips) = resolve_tips(repo, revisions)? else {
-        return Ok(0);
-    };
-    let hidden_tips = resolve_revisions(repo, hidden_revisions, "hidden ")?;
-    let walk = repo
-        .rev_walk(tips)
-        .with_hidden(hidden_tips)
-        .sorting(gix::revision::walk::Sorting::ByCommitTime(Default::default()))
-        .all()
-        .context("could not start revision walk")?;
-    let mut count = 0;
-    for info in walk.take(limit) {
-        info.context("could not traverse revision history")?;
-        count += 1;
-    }
-    Ok(count)
-}
-
 fn resolve_tips(repo: &gix::Repository, revisions: &[OsString]) -> Result<Option<Vec<ObjectId>>> {
     if revisions.is_empty() {
         repo.head()
@@ -1717,18 +1693,6 @@ mod tests {
             [repo.rev_parse_single("topic^")?.detach()],
             "only the excluded parent directly connected to visible history is retained"
         );
-        let revisions = [OsString::from("topic")];
-        let hidden = [OsString::from("main")];
-        assert_eq!(
-            count_up_to(&repo, &revisions, &hidden, 1)?,
-            actual.len().min(1),
-            "the screen-size probe stops at its limit"
-        );
-        assert_eq!(
-            count_up_to(&repo, &revisions, &hidden, usize::MAX)?,
-            actual.len(),
-            "the screen-size probe uses the same hidden history"
-        );
         assert!(
             matches!(events.last(), Some(Event::Complete(_))),
             "the filtered walk completes"
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 21911d21c6a..6bc3e3229a9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -35,8 +35,8 @@ use crossterm::{
         PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
     },
     execute,
-    style::{Print, ResetColor},
-    terminal::{self, Clear, ClearType, EnterAlternateScreen, LeaveAlternateScreen},
+    style::ResetColor,
+    terminal::{self, Clear, ClearType},
 };
 use gix::{
     bstr::{BString, ByteSlice},
@@ -44,7 +44,7 @@ use gix::{
 };
 use history::{Authors, Decorations, Event, HistoryGraph, SelectionRef, SharedAuthors};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
-use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, text::Line};
+use ratatui::{backend::CrosstermBackend, text::Line};
 
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
@@ -463,20 +463,6 @@ pub struct Options {
     pub quit_on_finish: bool,
     /// Revisions whose reachable commits should initially be hidden.
     pub hide: Vec<OsString>,
-    /// How much of the terminal to use.
-    pub screen: Screen,
-}
-
-/// How `gix-tix` occupies the terminal.
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub enum Screen {
-    /// Use the main screen for short histories, otherwise the alternate screen.
-    #[default]
-    Auto,
-    /// Always use the alternate screen.
-    Always,
-    /// Use half of the main screen.
-    Half,
 }
 
 /// Run the interactive commit graph for `repository`.
@@ -493,43 +479,14 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
         hidden_revision_count = options.hide.len(),
         "starting tix"
     );
-    let terminal_height = match options.screen {
-        Screen::Always => 0,
-        Screen::Auto | Screen::Half => terminal::size().context("could not determine terminal size")?.1,
-    };
-    let visible_commits = match options.screen {
-        Screen::Auto | Screen::Half => history::count_up_to(
-            &repository.to_thread_local(),
-            &revisions,
-            &options.hide,
-            half_height(terminal_height) as usize,
-        )?,
-        Screen::Always => 0,
-    };
-    let inline_height = inline_height(options.screen, terminal_height, visible_commits);
-    let mut terminal = match inline_height {
-        Some(height) => ratatui::try_init_with_options(TerminalOptions {
-            viewport: Viewport::Inline(height),
-        }),
-        None => ratatui::try_init(),
-    }
-    .context("could not initialize terminal")?;
+    let mut terminal = ratatui::try_init().context("could not initialize terminal")?;
     let enhanced_keyboard = terminal::supports_keyboard_enhancement().unwrap_or(false);
     let keyboard_setup = enable_input(terminal.backend_mut(), enhanced_keyboard);
     let result = keyboard_setup
         .context("could not enable enhanced keyboard events")
-        .and_then(|()| {
-            event_loop(
-                &mut terminal,
-                repository,
-                revisions,
-                options,
-                inline_height.is_some(),
-                enhanced_keyboard,
-            )
-        });
+        .and_then(|()| event_loop(&mut terminal, repository, revisions, options, enhanced_keyboard));
     let keyboard_restore = disable_input(terminal.backend_mut(), enhanced_keyboard);
-    let restore = restore_terminal(&mut terminal, inline_height.is_some());
+    let restore = ratatui::try_restore().context("could not restore terminal");
     let lane_time = result?;
     keyboard_restore.context("could not restore keyboard events")?;
     restore?;
@@ -561,165 +518,14 @@ fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keybo
     execute!(backend, DisableMouseCapture, DisableFocusChange)
 }
 
-fn half_height(terminal_height: u16) -> u16 {
-    (terminal_height / 2).max(1)
-}
-
-fn inline_height(screen: Screen, terminal_height: u16, visible_commits: usize) -> Option<u16> {
-    let half = half_height(terminal_height);
-    let compact = u16::try_from(visible_commits).unwrap_or(u16::MAX).saturating_add(3);
-    match screen {
-        Screen::Always => None,
-        Screen::Half => Some(compact.min(half)),
-        Screen::Auto if visible_commits < half as usize => Some(compact),
-        Screen::Auto => None,
-    }
-}
-
-fn restore_terminal(terminal: &mut ratatui::DefaultTerminal, inline: bool) -> Result<()> {
-    if !inline {
-        return ratatui::try_restore().context("could not restore terminal");
-    }
-
-    let cursor = (|| {
-        let area = terminal.get_frame().area();
-        let terminal_height = terminal.size()?.height;
-        execute!(
-            terminal.backend_mut(),
-            cursor::MoveTo(0, area.bottom().saturating_sub(1)),
-            Clear(ClearType::CurrentLine)
-        )?;
-        if area.bottom() < terminal_height {
-            execute!(terminal.backend_mut(), cursor::MoveTo(0, area.bottom()))
-        } else {
-            execute!(
-                terminal.backend_mut(),
-                cursor::MoveTo(0, terminal_height.saturating_sub(1)),
-                Print("\r\n")
-            )
-        }
-        .and_then(|()| terminal.show_cursor())
-    })();
-    let raw_mode = terminal::disable_raw_mode();
-    cursor.context("could not restore terminal cursor")?;
-    raw_mode.context("could not disable terminal raw mode")?;
-    Ok(())
-}
-
-fn enter_alternate_screen(
-    terminal: &mut ratatui::DefaultTerminal,
-    enhanced_keyboard: bool,
-) -> std::io::Result<ratatui::DefaultTerminal> {
-    disable_input(terminal.backend_mut(), enhanced_keyboard)?;
-    let alternate = ratatui::Terminal::new(CrosstermBackend::new(std::io::stdout()))?;
-    execute!(terminal.backend_mut(), EnterAlternateScreen)?;
-    let inline = std::mem::replace(terminal, alternate);
-    enable_input(terminal.backend_mut(), enhanced_keyboard)?;
-    Ok(inline)
-}
-
-fn leave_alternate_screen(
-    terminal: &mut ratatui::DefaultTerminal,
-    inline: ratatui::DefaultTerminal,
-    enhanced_keyboard: bool,
-) -> std::io::Result<()> {
-    disable_input(terminal.backend_mut(), enhanced_keyboard)?;
-    drop(std::mem::replace(terminal, inline));
-    execute!(terminal.backend_mut(), LeaveAlternateScreen)?;
-    enable_input(terminal.backend_mut(), enhanced_keyboard)?;
-    terminal.hide_cursor()
-}
-
-fn should_switch_screen(started_inline: bool, needs_alternate_screen: bool, in_alternate_screen: bool) -> bool {
-    started_inline && needs_alternate_screen != in_alternate_screen
-}
-
-fn configure_initial_screen(app: &mut App, inline: bool) {
-    app.inline = inline;
-    if inline {
-        app.changes_mode = None;
-    }
-}
-
-fn history_needs_alternate_screen(screen: Screen, terminal_height: u16, commits: usize) -> bool {
-    screen == Screen::Auto && inline_height(screen, terminal_height, commits).is_none()
-}
-
-fn needs_alternate_screen(
-    show_panel: bool,
-    history_requires_alternate_screen: bool,
-    current_inline_height: Option<u16>,
-) -> bool {
-    show_panel || history_requires_alternate_screen || current_inline_height.is_none()
-}
-
-fn resize_inline_screen(terminal: &mut ratatui::DefaultTerminal, height: u16) -> std::io::Result<()> {
-    if terminal.get_frame().area().height == height {
-        return Ok(());
-    }
-    let resized = ratatui::Terminal::with_options(
-        CrosstermBackend::new(std::io::stdout()),
-        TerminalOptions {
-            viewport: Viewport::Inline(height),
-        },
-    )?;
-    drop(std::mem::replace(terminal, resized));
-    terminal.hide_cursor()
-}
-
-#[expect(
-    clippy::too_many_arguments,
-    reason = "screen transitions need the complete terminal state"
-)]
-fn sync_screen(
-    terminal: &mut ratatui::DefaultTerminal,
-    app: &mut App,
-    screen: Screen,
-    started_inline: bool,
-    history_requires_alternate_screen: bool,
-    resize_inline: bool,
-    inline_terminal: &mut Option<ratatui::DefaultTerminal>,
-    enhanced_keyboard: bool,
-) -> Result<()> {
-    let inline_height = inline_height(screen, terminal::size()?.1, app.rows.len());
-    let needs_alternate_screen = needs_alternate_screen(
-        app.show_commit || app.changes_mode.is_some(),
-        history_requires_alternate_screen,
-        inline_height,
-    );
-    if !should_switch_screen(started_inline, needs_alternate_screen, inline_terminal.is_some()) {
-        if let (true, Some(height)) = (started_inline && app.inline && resize_inline, inline_height) {
-            resize_inline_screen(terminal, height).context("could not resize the inline history")?;
-        }
-        return Ok(());
-    }
-    if needs_alternate_screen {
-        *inline_terminal =
-            Some(enter_alternate_screen(terminal, enhanced_keyboard).context("could not enter the alternate screen")?);
-        app.inline = false;
-    } else if let Some(inline) = inline_terminal.take() {
-        leave_alternate_screen(terminal, inline, enhanced_keyboard).context("could not leave the alternate screen")?;
-        app.inline = true;
-        if let Some(height) = inline_height {
-            resize_inline_screen(terminal, height).context("could not resize the inline history")?;
-        }
-    }
-    Ok(())
-}
-
 fn event_loop(
     terminal: &mut ratatui::DefaultTerminal,
     mut repository: gix::ThreadSafeRepository,
     revisions: Vec<OsString>,
     options: Options,
-    started_inline: bool,
     enhanced_keyboard: bool,
 ) -> Result<Option<Duration>> {
-    let Options {
-        quit_on_finish,
-        hide,
-        screen,
-    } = options;
+    let Options { quit_on_finish, hide } = options;
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
@@ -780,7 +586,6 @@ fn event_loop(
         retained: None,
         retain: false,
     };
-    configure_initial_screen(&mut app, started_inline);
     app.set_worktree_changes_available(!repository_is_bare);
     app.configure_hidden_filter(!hide.is_empty());
     sync_line_diff_pool(
@@ -818,9 +623,6 @@ fn event_loop(
     let mut last_draw = Instant::now();
     let mut dirty = false;
     let mut urgent = false;
-    let mut inline_terminal = None;
-    let mut history_requires_alternate_screen = false;
-    let mut resize_inline_pending = false;
     let mut history_finished = false;
     let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
@@ -986,9 +788,6 @@ fn event_loop(
                     selection_relation = None;
                     app.selection_relation = None;
                     lane_receiver = None;
-                    history_requires_alternate_screen =
-                        history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
-                    resize_inline_pending = true;
                     dirty = true;
                     if quit_on_finish {
                         return Ok(app.lane_time);
@@ -1132,7 +931,6 @@ fn event_loop(
             continue;
         }
         let mut events = 0;
-        let mut resize_inline = std::mem::take(&mut resize_inline_pending);
         while !history_finished && events < EVENT_BATCH_SIZE {
             let message = match receiver.try_recv() {
                 Ok(message) => message,
@@ -1145,22 +943,9 @@ fn event_loop(
             dirty = true;
             match message? {
                 Event::Decorations(value) => decorations = value,
-                Event::Commits(rows) => {
-                    app.extend_commits(rows);
-                    if history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len()) {
-                        history_requires_alternate_screen = true;
-                    }
-                }
-                Event::HiddenCommits(rows) => {
-                    app.extend_hidden_commits(rows);
-                    if history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len()) {
-                        history_requires_alternate_screen = true;
-                    }
-                }
+                Event::Commits(rows) => app.extend_commits(rows),
+                Event::HiddenCommits(rows) => app.extend_hidden_commits(rows),
                 Event::VisibleComplete => {
-                    resize_inline = true;
-                    history_requires_alternate_screen =
-                        history_needs_alternate_screen(screen, terminal::size()?.1, app.rows.len());
                     if let Some(rows) = app.start_lane_computation() {
                         lane_receiver = Some(start_lane_worker(rows));
                     }
@@ -1177,16 +962,6 @@ fn event_loop(
                 }
             }
         }
-        sync_screen(
-            terminal,
-            &mut app,
-            screen,
-            started_inline,
-            history_requires_alternate_screen,
-            resize_inline,
-            &mut inline_terminal,
-            enhanced_keyboard,
-        )?;
         let streaming = matches!(app.state, State::Loading | State::Cancelling | State::Computing)
             || verification_receiver.is_some()
             || repeat_deadline.is_some();
@@ -1408,57 +1183,8 @@ fn event_loop(
                 Effect::Quit => return Ok(None),
             }
         }
-        sync_screen(
-            terminal,
-            &mut app,
-            screen,
-            started_inline,
-            history_requires_alternate_screen,
-            false,
-            &mut inline_terminal,
-            enhanced_keyboard,
-        )?;
     })();
-    let restore = inline_terminal
-        .map(|inline| leave_alternate_screen(terminal, inline, enhanced_keyboard))
-        .transpose();
-    restore.context("could not restore the inline terminal")?;
-    let outcome = result?;
-    if outcome.is_none() && started_inline {
-        prepare_inline_exit(&mut app);
-        sync_line_diff_pool(
-            &mut line_diff_pool,
-            false,
-            &repository_path,
-            repository_is_bare,
-            line_diff_parallelism,
-        )?;
-        draw(
-            terminal,
-            &mut app,
-            &decorations,
-            &mailmap,
-            &authors,
-            &mut fill_repository,
-            &mut commit_message,
-            &mut tree_changes,
-            &mut worktree_changes,
-            &mut history_graph,
-            &mut selection_relation,
-            &mut line_diff_pool,
-        )?;
-    }
-    Ok(outcome)
-}
-
-fn prepare_inline_exit(app: &mut App) {
-    app.inline = true;
-    app.show_commit = false;
-    app.changes_mode = None;
-    app.changes_suppressed = false;
-    app.changes_focus = None;
-    app.reset_changes_view();
-    app.show_selection_tail = false;
+    result
 }
 
 fn start_lane_worker(rows: Vec<SharedCommitRow>) -> mpsc::Receiver<(Vec<SharedCommitRow>, app::Graph, Duration)> {
@@ -1664,11 +1390,7 @@ fn draw(
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
 ) -> Result<()> {
-    let render_rows = terminal
-        .get_frame()
-        .area()
-        .height
-        .saturating_sub(1 + 2 * u16::from(app.inline)) as usize;
+    let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
         return Ok(());
     }
@@ -3415,95 +3137,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn chooses_screen_from_terminal_and_history_height() {
-        assert_eq!(
-            inline_height(Screen::Auto, 20, 7),
-            Some(10),
-            "short histories occupy only their rows, spacers, and footer"
-        );
-        assert_eq!(
-            inline_height(Screen::Auto, 20, 8),
-            Some(11),
-            "spacers do not force an otherwise short history into the alternate screen"
-        );
-        assert_eq!(
-            inline_height(Screen::Auto, 20, 10),
-            None,
-            "the auto cutoff remains half the terminal height"
-        );
-        assert_eq!(
-            inline_height(Screen::Half, 21, 3),
-            Some(6),
-            "half mode shrinks to the rows, spacers, and footer needed by short histories"
-        );
-        assert_eq!(
-            inline_height(Screen::Half, 21, 10),
-            Some(10),
-            "half mode is capped at half the terminal, rounded down"
-        );
-        assert_eq!(
-            inline_height(Screen::Half, 21, 0),
-            Some(3),
-            "an empty history only needs its spacers and footer"
-        );
-        assert_eq!(
-            inline_height(Screen::Always, 20, 0),
-            None,
-            "always mode uses the alternate screen"
-        );
-    }
-
-    #[test]
-    fn switches_screens_for_inline_commit_panes_and_large_histories() {
-        let mut inline = App::new(1);
-        configure_initial_screen(&mut inline, true);
-        assert!(inline.inline);
-        assert_eq!(
-            inline.changes_mode, None,
-            "inline startup hides the default changes view"
-        );
-        let mut alternate = App::new(1);
-        configure_initial_screen(&mut alternate, false);
-        assert!(!alternate.inline);
-        assert!(
-            alternate.changes_mode == Some(ChangesMode::Both),
-            "alternate-screen startup keeps the default tree and worktree changes view"
-        );
-
-        assert!(
-            should_switch_screen(true, true, false),
-            "opening the commit pane from inline mode enters the alternate screen"
-        );
-        assert!(
-            should_switch_screen(true, false, true),
-            "closing the commit pane returns to inline mode"
-        );
-        assert!(
-            !should_switch_screen(false, true, true),
-            "a session that started in the alternate screen stays there"
-        );
-        assert!(
-            !should_switch_screen(true, true, true),
-            "an already-active alternate screen is not re-entered"
-        );
-        assert!(!history_needs_alternate_screen(Screen::Auto, 20, 7));
-        assert!(!history_needs_alternate_screen(Screen::Auto, 20, 8));
-        assert!(history_needs_alternate_screen(Screen::Auto, 20, 10));
-        assert!(
-            needs_alternate_screen(false, false, None),
-            "current terminal geometry overrides a stale history-fit flag"
-        );
-        assert!(
-            !needs_alternate_screen(false, false, Some(11)),
-            "a fitting current layout may return to inline mode"
-        );
-        assert!(
-            !history_needs_alternate_screen(Screen::Half, 20, usize::MAX),
-            "half-screen mode never switches because history grows"
-        );
-    }
-
     #[test]
     fn maps_navigation_and_control_c() {
         assert_eq!(
@@ -3699,24 +3332,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn prepares_a_reduced_selection_after_leaving_the_alternate_screen() {
-        let mut app = App::new(1);
-        app.show_commit = true;
-        app.changes_mode = Some(ChangesMode::Tree);
-        app.changes_focus = Some(ChangePane::Tree);
-
-        prepare_inline_exit(&mut app);
-
-        assert!(app.inline, "the final frame is drawn into the restored inline screen");
-        assert!(
-            !app.show_commit && app.changes_mode.is_none(),
-            "alternate-screen panels are omitted from the final frame"
-        );
-        assert_eq!(app.changes_focus, None, "the hidden panel no longer owns focus");
-        assert!(!app.show_selection_tail, "only the left selection marker remains");
-    }
-
     #[test]
     fn copies_parsed_author_bytes_without_validation() {
         let author = app::Author {
diff --git a/gix-tix/src/main.rs b/gix-tix/src/main.rs
index 4c544e70c53..ef02db214a0 100644
--- a/gix-tix/src/main.rs
+++ b/gix-tix/src/main.rs
@@ -8,7 +8,7 @@ fn main() -> Result<()> {
     let (revisions, options, help) = arguments(gix::env::args_os().skip(1))?;
     if help {
         println!(
-            "Usage: tix [--quit-on-finish] [--screen MODE] [-h|--hide REVSPEC] [REVISION]...\n\nBrowse commits reachable from HEAD or the given revisions.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n      --screen MODE   Use auto, always, or half screen mode [default: auto]\n      --help          Print help"
+            "Usage: tix [--quit-on-finish] [-h|--hide REVSPEC] [REVISION]...\n\nBrowse commits reachable from HEAD or the given revisions.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n      --help          Print help"
         );
         return Ok(());
     }
@@ -29,21 +29,6 @@ fn arguments(mut args: impl Iterator<Item = OsString>) -> Result<(Vec<OsString>,
             break;
         } else if arg == "--quit-on-finish" {
             options.quit_on_finish = true;
-        } else if arg == "--screen" {
-            let value = args.next().context("--screen requires one of: auto, always, half")?;
-            if value == "--help" {
-                help = true;
-                break;
-            }
-            options.screen = match value {
-                value if value == "auto" => gix_tix::Screen::Auto,
-                value if value == "always" => gix_tix::Screen::Always,
-                value if value == "half" => gix_tix::Screen::Half,
-                value => anyhow::bail!(
-                    "invalid --screen value {}; expected auto, always, or half",
-                    value.display()
-                ),
-            };
         } else if arg == "-h" || arg == "--hide" {
             let revision = args.next().context("-h/--hide requires a revision to hide")?;
             if revision == "--help" {
@@ -70,23 +55,12 @@ mod tests {
     #[test]
     fn separates_options_from_revisions() -> Result<()> {
         let (revisions, options, help) = arguments(
-            [
-                "--quit-on-finish",
-                "--screen",
-                "half",
-                "-h",
-                "main",
-                "--hide",
-                "tag",
-                "topic",
-                "--help",
-            ]
-            .into_iter()
-            .map(OsString::from),
+            ["--quit-on-finish", "-h", "main", "--hide", "tag", "topic", "--help"]
+                .into_iter()
+                .map(OsString::from),
         )?;
 
         assert!(options.quit_on_finish);
-        assert_eq!(options.screen, gix_tix::Screen::Half);
         assert_eq!(options.hide, ["main", "tag"], "both hide options are retained");
         assert_eq!(revisions, ["topic"], "only positional revisions remain");
         assert!(help, "--help remains available without claiming -h");
@@ -100,19 +74,6 @@ mod tests {
                 "--help wins regardless of its position"
             );
         }
-        assert_eq!(
-            arguments(std::iter::empty())?.1.screen,
-            gix_tix::Screen::Auto,
-            "auto is the default"
-        );
-        assert!(
-            arguments(["--screen"].into_iter().map(OsString::from)).is_err(),
-            "a missing screen mode is rejected"
-        );
-        assert!(
-            arguments(["--screen", "other"].into_iter().map(OsString::from)).is_err(),
-            "an unknown screen mode is rejected"
-        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 61d2f532a65..4120b58a3a2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -188,15 +188,7 @@ pub(crate) fn draw_with_worktree(
     tree_changes: Option<&Changes>,
     worktree_changes: Option<&Changes>,
 ) {
-    let [top_spacer, mut body, bottom_spacer, footer] = Layout::vertical([
-        Constraint::Length(u16::from(app.inline)),
-        Constraint::Min(0),
-        Constraint::Length(u16::from(app.inline)),
-        Constraint::Length(1),
-    ])
-    .areas(frame.area());
-    frame.render_widget(Clear, top_spacer);
-    frame.render_widget(Clear, bottom_spacer);
+    let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
     let full_body = body;
     let compared_parent = if app.changes_visible() {
         tree_changes.and_then(|changes| changes.parent.map(|parent| parent.id))
@@ -1892,20 +1884,6 @@ mod tests {
         }
         terminal.backend().assert_buffer(&expected);
 
-        app.inline = true;
-        let mut inline_terminal = Terminal::new(TestBackend::new(140, 4))?;
-        inline_terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        assert!(
-            rendered_line(&inline_terminal, 0).trim().is_empty(),
-            "inline mode separates the commits from preceding content"
-        );
-        assert!(
-            rendered_line(&inline_terminal, 2).trim().is_empty(),
-            "inline mode separates the commits from the status line"
-        );
-        assert!(rendered_line(&inline_terminal, 3).starts_with("#1"));
-        app.inline = false;
-
         let row = terminal.backend().buffer();
         assert!(
             row[(10, 0)].modifier.contains(Modifier::REVERSED),

From 56682804ea2cbac0c45e9c05f61258997cb76964 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 10 Aug 2026 12:33:38 +0200
Subject: [PATCH 035/282] change!: remove gix tix screen selection

Remove the plumbing CLI screen-mode option now that the interactive history always owns the alternate screen. The automatic and half-screen modes depended on inline rendering behavior that is being retired from gix-tix.

Stop accepting --screen for gix tix and its aliases, and remove the mode validation and translation into gix-tix. Construct the reduced gix-tix options directly from the remaining quit and hidden-revision arguments. Keep a command-line regression assertion so the removed option cannot silently return as an ignored argument.
---
 src/plumbing/main.rs        | 36 +++++++++---------------------------
 src/plumbing/options/mod.rs |  3 ---
 2 files changed, 9 insertions(+), 30 deletions(-)

diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index e672cef82ce..10010dc3db6 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -161,26 +161,13 @@ pub fn main() -> Result<()> {
         Subcommands::Tix {
             help: _,
             quit_on_finish,
-            screen,
             hide,
             revisions,
-        } => {
-            let screen = match screen.as_str() {
-                "auto" => gix_tix::Screen::Auto,
-                "always" => gix_tix::Screen::Always,
-                "half" => gix_tix::Screen::Half,
-                value => anyhow::bail!("invalid screen mode: {value}"),
-            };
-            gix_tix::run(
-                repository(Mode::Lenient)?.into_sync(),
-                revisions,
-                gix_tix::Options {
-                    quit_on_finish,
-                    hide,
-                    screen,
-                },
-            )
-        }
+        } => gix_tix::run(
+            repository(Mode::Lenient)?.into_sync(),
+            revisions,
+            gix_tix::Options { quit_on_finish, hide },
+        ),
         Subcommands::Env => prepare_and_run(
             "env",
             trace,
@@ -1880,17 +1867,12 @@ mod tests {
         };
         assert_eq!(hide, ["main", "tag"], "short and long hide options append");
         assert_eq!(revisions, ["topic"], "positional revisions remain visible tips");
-        let args = Args::try_parse_from(["gix", "tix", "--screen", "half"]).expect("the half-screen mode parses");
-        let Subcommands::Tix { screen, .. } = args.cmd else {
-            panic!("tix arguments route to tix")
-        };
-        assert_eq!(screen, "half", "the requested screen mode is retained");
         assert_eq!(
-            Args::try_parse_from(["gix", "tix", "--screen", "other"])
-                .expect_err("unknown screen modes are rejected")
+            Args::try_parse_from(["gix", "tix", "--screen", "half"])
+                .expect_err("screen selection is no longer supported")
                 .kind(),
-            clap::error::ErrorKind::InvalidValue,
-            "screen mode validation happens at the command line"
+            clap::error::ErrorKind::UnknownArgument,
+            "alternate-screen operation has no command-line mode"
         );
         assert_eq!(
             Args::try_parse_from(["gix", "tix", "--help"])
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
index c253ff11b27..7bfe8608d64 100644
--- a/src/plumbing/options/mod.rs
+++ b/src/plumbing/options/mod.rs
@@ -178,9 +178,6 @@ pub enum Subcommands {
         /// Exit once all commits and graph lanes have been computed.
         #[clap(long)]
         quit_on_finish: bool,
-        /// Choose automatic, full alternate-screen, or compact half-screen display.
-        #[clap(long, value_name = "MODE", value_parser = ["auto", "always", "half"], default_value = "auto")]
-        screen: String,
         /// Hide this revision and every commit reachable from it.
         #[clap(short = 'h', long, value_name = "REVSPEC")]
         hide: Vec<std::ffi::OsString>,

From 41336a1e50277c82158b1a7c9b451157cd047aad Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 10 Aug 2026 12:57:03 +0200
Subject: [PATCH 036/282] fix: refresh tix after reference transactions

Wait for a short quiet period after filesystem notifications before reading traversal tips, so multi-step ref updates are observed after their final rename instead of at the temporary lock-file event. This makes newly created or pushed commits appear automatically. Keep Shift+R available as an unconditional explicit refresh, and cover loose-ref notification delivery with a real watcher test.
---
 gix-tix/src/app.rs |  3 +--
 gix-tix/src/lib.rs | 60 +++++++++++++++++++++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 8 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ab4792b1b41..44a454e8856 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -695,7 +695,7 @@ impl App {
                     RefMode::None => RefMode::All,
                 };
             }
-            Action::Refresh if self.manual_refresh && matches!(self.state, State::Complete | State::Cancelled) => {
+            Action::Refresh if matches!(self.state, State::Complete | State::Cancelled) => {
                 return vec![Effect::Reload(self.show_hidden)];
             }
             Action::ToggleHidden
@@ -2419,7 +2419,6 @@ mod tests {
     #[test]
     fn refresh_reloads_only_finished_history() {
         let mut app = App::new(1);
-        app.manual_refresh = true;
         assert!(
             app.update(Action::Refresh).is_empty(),
             "a running walk cannot be replaced"
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 6bc3e3229a9..48876915bba 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -52,6 +52,7 @@ const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
 const HISTORY_STATUS_DELAY: Duration = Duration::from_millis(500);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
+const REF_EVENT_IDLE: Duration = Duration::from_millis(100);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 const WATCH_RETRY_INTERVAL: Duration = Duration::from_secs(5);
@@ -568,6 +569,7 @@ fn event_loop(
     let mut refresh_receiver: Option<mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
     let mut refresh_from_filesystem = false;
+    let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_select_top = false;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
@@ -682,12 +684,7 @@ fn event_loop(
                         rescans += usize::from(event.need_rescan());
                         if notification_is_actionable(&event) {
                             actionable += 1;
-                            refresh_pending = true;
-                            refresh_from_filesystem = true;
-                            if invalidate_worktree_changes(&mut worktree_changes) {
-                                dirty = true;
-                                urgent = true;
-                            }
+                            ref_refresh_deadline = Some(Instant::now() + REF_EVENT_IDLE);
                         }
                     }
                     Ok(Err(err)) => {
@@ -704,9 +701,18 @@ fn event_loop(
         if let Some(err) = ref_watch_error {
             tracing::warn!(error = %err, "reference watcher failed");
             ref_watcher = None;
+            ref_refresh_deadline = None;
             app.manual_refresh = true;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
+        if take_due(&mut ref_refresh_deadline, Instant::now()) {
+            refresh_pending = true;
+            refresh_from_filesystem = true;
+            if invalidate_worktree_changes(&mut worktree_changes) {
+                dirty = true;
+                urgent = true;
+            }
+        }
         if take_due(&mut watcher_retry_deadline, Instant::now()) {
             let mut retry = false;
             if ref_watcher.is_none() {
@@ -985,6 +991,8 @@ fn event_loop(
         }
         let repeat_timeout = repeat_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let watcher_timeout = ref_watcher.as_ref().map(|_| REF_EVENT_INTERVAL);
+        let ref_refresh_timeout =
+            ref_refresh_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let worktree_timeout = worktree_refresh_deadline
             .map(|deadline| deadline.saturating_duration_since(Instant::now()))
             .or_else(|| worktree_watcher.as_ref().map(|_| REF_EVENT_INTERVAL));
@@ -994,6 +1002,7 @@ fn event_loop(
         let wake_after = [
             repeat_timeout,
             watcher_timeout,
+            ref_refresh_timeout,
             worktree_timeout,
             retry_timeout,
             history_status_timeout,
@@ -2565,6 +2574,37 @@ fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::
 mod tests {
     use super::*;
 
+    #[test]
+    fn reference_watcher_observes_new_loose_refs() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = open_test_repository(fixture.path())?;
+        let watcher = start_ref_watcher(repository.git_dir(), repository.common_dir())?;
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let status = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["update-ref", "refs/heads/watched", &topic.to_hex().to_string()])
+            .status()?;
+        assert!(status.success(), "git updates a loose reference");
+
+        let deadline = Instant::now() + Duration::from_secs(5);
+        let mut paths = Vec::new();
+        while Instant::now() < deadline {
+            let event = watcher
+                .events
+                .recv_timeout(deadline.saturating_duration_since(Instant::now()))??;
+            assert!(notification_is_actionable(&event), "the reference update is actionable");
+            paths.extend(event.paths);
+            if paths.iter().any(|path| path.ends_with("refs/heads/watched")) {
+                break;
+            }
+        }
+        assert!(
+            paths.iter().any(|path| path.ends_with("refs/heads/watched")),
+            "the final loose reference is reported after its lock file: {paths:?}"
+        );
+        Ok(())
+    }
+
     #[test]
     fn caches_recent_tree_changes_by_commit_and_parent() {
         let id = |value| {
@@ -3518,5 +3558,13 @@ mod tests {
             take_due(&mut deadline, now + HISTORY_STATUS_DELAY),
             "background progress becomes visible at 500 ms"
         );
+
+        let last_event = now + Duration::from_millis(75);
+        deadline = Some(last_event + REF_EVENT_IDLE);
+        assert!(
+            !take_due(&mut deadline, now + REF_EVENT_IDLE),
+            "reference inspection waits for the final transaction event"
+        );
+        assert!(take_due(&mut deadline, last_event + REF_EVENT_IDLE));
     }
 }

From 499da05857f5238d810b3a5a8c25875eb09471ab Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 10 Aug 2026 12:02:08 +0200
Subject: [PATCH 037/282] feat: emphasize tix filesystem history changes

Present completed filesystem refreshes immediately instead of interpolating between terminal buffers. Briefly bold only new or replaced visible history rows, then settle to the ordinary target after 180ms.

Match rows by commit ID first and tree ID second so amended messages and authors retain their visual identity while a new object ID is emphasized. Keep duplicate-tree matches in display order, and load tree IDs only for changed visible commit sequences through a fresh cacheless repository.

Leave removals and unrelated branch replacements immediate because neither has a useful on-screen anchor. Make show-hidden, hide-hidden, manual refresh, worktree-only updates, navigation, and pane changes immediate as well.

Do not block refreshes, redraws, or input while emphasis is active. Any interaction clears the temporary styling, and a subsequent filesystem refresh replaces it from the last logical target.

Snapshot every distinct frame for reword and new-top-commit changes with insta. Omit unchanged hold ticks and document the cargo-insta review workflow.
---
 Cargo.lock                                    |   1 +
 gix-tix/AGENTS.md                             |   5 +
 gix-tix/Cargo.toml                            |   1 +
 gix-tix/src/animation.rs                      | 311 ++++++++++++++++++
 gix-tix/src/lib.rs                            | 237 ++++++++++++-
 ...sts__filesystem_new_top_commit_frames.snap |  16 +
 ...tion__tests__filesystem_reword_frames.snap |  14 +
 gix-tix/src/ui.rs                             |  23 +-
 8 files changed, 601 insertions(+), 7 deletions(-)
 create mode 100644 gix-tix/src/animation.rs
 create mode 100644 gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
 create mode 100644 gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap

diff --git a/Cargo.lock b/Cargo.lock
index 366b40f9ee1..96f3b55fad9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2599,6 +2599,7 @@ dependencies = [
  "directories",
  "gix",
  "gix-testtools",
+ "insta",
  "notify",
  "ratatui",
  "tracing",
diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 9ba5c27f400..9e05df11802 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -13,3 +13,8 @@
 - Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
 - The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
 - Filesystem watchers retain paths and native watcher handles, never repositories.
+
+## Filesystem emphasis snapshots
+
+- Transition tests use `insta` snapshots containing every distinct frame; unchanged hold frames are intentionally omitted.
+- Run them with `cargo insta test -p gix-tix -F sha1`; review updates with `cargo insta review`. Never edit `.snap` files manually.
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 6b4af3ca78b..ccce2b50334 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -35,6 +35,7 @@ tracing-subscriber = "0.3.17"
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
+insta = "1.46.3"
 
 [package.metadata.docs.rs]
 features = ["sha1"]
diff --git a/gix-tix/src/animation.rs b/gix-tix/src/animation.rs
new file mode 100644
index 00000000000..568d81539bc
--- /dev/null
+++ b/gix-tix/src/animation.rs
@@ -0,0 +1,311 @@
+use std::{collections::HashMap, time::Duration};
+
+use gix::ObjectId;
+use ratatui::{buffer::Buffer, layout::Rect, style::Modifier};
+
+use crate::ui::FrameLayout;
+
+const EMPHASIS_DURATION: Duration = Duration::from_millis(180);
+
+#[derive(Clone, Debug)]
+pub(crate) struct Row {
+    pub id: ObjectId,
+    pub tree: Option<ObjectId>,
+    pub y: u16,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Snapshot {
+    pub buffer: Buffer,
+    pub layout: FrameLayout,
+    pub rows: Vec<Row>,
+}
+
+impl Snapshot {
+    pub(crate) fn new(buffer: Buffer, layout: FrameLayout) -> Self {
+        let rows = layout
+            .rows
+            .iter()
+            .map(|(id, y)| Row {
+                id: *id,
+                tree: None,
+                y: *y,
+            })
+            .collect();
+        Snapshot { buffer, layout, rows }
+    }
+
+    pub(crate) fn set_trees(&mut self, trees: &HashMap<ObjectId, ObjectId>) {
+        for row in &mut self.rows {
+            row.tree = trees.get(&row.id).copied();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Emphasis {
+    target: Snapshot,
+    displayed: Buffer,
+    remaining: Duration,
+}
+
+impl Emphasis {
+    pub(crate) fn new(source: Snapshot, target: Snapshot) -> Option<Self> {
+        if source.buffer.area != target.buffer.area || source.buffer == target.buffer {
+            return None;
+        }
+        let matches = row_matches(&source.rows, &target.rows);
+        if matches.is_empty() {
+            return None;
+        }
+        let mut displayed = target.buffer.clone();
+        for (target_index, target_row) in target.rows.iter().enumerate() {
+            let changed = matches
+                .iter()
+                .find(|(_, candidate)| *candidate == target_index)
+                .is_none_or(|(source_index, _)| source.rows[*source_index].id != target_row.id);
+            if changed && !covered_by_overlay(target_row.y, &target.layout.overlays) {
+                modify_row(&mut displayed, target.layout.history, target_row.y, Modifier::BOLD);
+            }
+        }
+        (displayed != target.buffer).then_some(Emphasis {
+            target,
+            displayed,
+            remaining: EMPHASIS_DURATION,
+        })
+    }
+
+    pub(crate) fn target(&self) -> &Snapshot {
+        &self.target
+    }
+
+    pub(crate) fn displayed(&self) -> &Buffer {
+        &self.displayed
+    }
+
+    pub(crate) fn timeout(&self) -> Duration {
+        self.remaining
+    }
+
+    pub(crate) fn advance(&mut self, elapsed: Duration) -> Option<&Buffer> {
+        self.remaining = self.remaining.saturating_sub(elapsed);
+        if !self.is_complete() {
+            return None;
+        }
+        self.displayed.clone_from(&self.target.buffer);
+        Some(&self.displayed)
+    }
+
+    pub(crate) fn is_complete(&self) -> bool {
+        self.remaining == Duration::ZERO
+    }
+}
+
+fn row_matches(source: &[Row], target: &[Row]) -> Vec<(usize, usize)> {
+    let width = target.len() + 1;
+    let mut scores = vec![0u16; (source.len() + 1) * width];
+    for source_index in (0..source.len()).rev() {
+        for target_index in (0..target.len()).rev() {
+            let same = row_score(&source[source_index], &target[target_index]);
+            scores[source_index * width + target_index] = if same > 0 {
+                (same + scores[(source_index + 1) * width + target_index + 1])
+                    .max(scores[(source_index + 1) * width + target_index])
+                    .max(scores[source_index * width + target_index + 1])
+            } else {
+                scores[(source_index + 1) * width + target_index].max(scores[source_index * width + target_index + 1])
+            };
+        }
+    }
+    let mut out = Vec::new();
+    let (mut source_index, mut target_index) = (0, 0);
+    while source_index < source.len() && target_index < target.len() {
+        let same = row_score(&source[source_index], &target[target_index]);
+        if same > 0
+            && scores[source_index * width + target_index]
+                == same + scores[(source_index + 1) * width + target_index + 1]
+        {
+            out.push((source_index, target_index));
+            source_index += 1;
+            target_index += 1;
+        } else if scores[(source_index + 1) * width + target_index] >= scores[source_index * width + target_index + 1] {
+            source_index += 1;
+        } else {
+            target_index += 1;
+        }
+    }
+    out
+}
+
+fn row_score(source: &Row, target: &Row) -> u16 {
+    if source.id == target.id {
+        2
+    } else if source.tree.is_some() && source.tree == target.tree {
+        1
+    } else {
+        0
+    }
+}
+
+fn covered_by_overlay(y: u16, overlays: &[Rect]) -> bool {
+    overlays.iter().any(|area| y >= area.y && y < area.bottom())
+}
+
+fn modify_row(buffer: &mut Buffer, area: Rect, y: u16, modifier: Modifier) {
+    if y < area.y || y >= area.bottom() {
+        return;
+    }
+    for x in area.x.max(buffer.area.x)..area.right().min(buffer.area.right()) {
+        buffer[(x, y)].modifier.insert(modifier);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn id(n: u8) -> ObjectId {
+        ObjectId::from_bytes_or_panic(&[n; 20])
+    }
+
+    fn snapshot(ids: &[u8], trees: &[u8]) -> Snapshot {
+        history_snapshot(
+            &ids.iter()
+                .zip(trees)
+                .map(|(id, tree)| (*id, *tree, id.to_string()))
+                .collect::<Vec<_>>(),
+        )
+    }
+
+    fn history_snapshot(rows: &[(u8, u8, String)]) -> Snapshot {
+        let area = Rect::new(0, 0, 24, 4);
+        let mut buffer = Buffer::empty(area);
+        let rows = rows
+            .iter()
+            .enumerate()
+            .map(|(index, (id_value, tree, text))| {
+                for (x, symbol) in text.chars().take(area.width.into()).enumerate() {
+                    buffer[(x as u16, index as u16)].set_char(symbol);
+                }
+                Row {
+                    id: id(*id_value),
+                    tree: Some(id(*tree)),
+                    y: index as u16,
+                }
+            })
+            .collect();
+        Snapshot {
+            buffer,
+            layout: FrameLayout {
+                history: area,
+                ..FrameLayout::default()
+            },
+            rows,
+        }
+    }
+
+    fn distinct_frames(mut emphasis: Emphasis) -> String {
+        let first = emphasis.displayed().clone();
+        assert!(
+            emphasis
+                .advance(EMPHASIS_DURATION.saturating_sub(Duration::from_nanos(1)))
+                .is_none(),
+            "hold ticks do not produce duplicate frames"
+        );
+        let final_frame = emphasis
+            .advance(Duration::from_nanos(1))
+            .expect("the emphasis settles after its hold")
+            .clone();
+        [first, final_frame]
+            .iter()
+            .enumerate()
+            .map(|(index, frame)| format!("--- frame {index} ---\n{}", display_frame(frame)))
+            .collect::<Vec<_>>()
+            .join("\n")
+    }
+
+    fn display_frame(buffer: &Buffer) -> String {
+        let mut out = String::new();
+        for y in buffer.area.y..buffer.area.bottom() {
+            let cells = (buffer.area.x..buffer.area.right())
+                .map(|x| &buffer[(x, y)])
+                .collect::<Vec<_>>();
+            let text = cells.iter().map(|cell| cell.symbol()).collect::<String>();
+            out.push_str(text.trim_end());
+            out.push('\n');
+            let modifiers = cells
+                .iter()
+                .map(|cell| {
+                    if cell.modifier.contains(Modifier::BOLD) {
+                        'b'
+                    } else {
+                        ' '
+                    }
+                })
+                .collect::<String>();
+            if !modifiers.trim().is_empty() {
+                out.push_str("style: ");
+                out.push_str(modifiers.trim_end());
+                out.push('\n');
+            }
+        }
+        out
+    }
+
+    #[test]
+    fn rewritten_rows_match_by_tree_even_if_the_author_changed_with_the_id() {
+        let source = snapshot(&[1, 2], &[10, 20]);
+        let target = snapshot(&[3, 2], &[10, 20]);
+        assert_eq!(row_matches(&source.rows, &target.rows), [(0, 0), (1, 1)]);
+    }
+
+    #[test]
+    fn duplicate_trees_are_matched_in_relative_order() {
+        let source = snapshot(&[1, 2, 3], &[10, 10, 20]);
+        let target = snapshot(&[4, 5, 3], &[10, 10, 20]);
+        assert_eq!(row_matches(&source.rows, &target.rows), [(0, 0), (1, 1), (2, 2)]);
+    }
+
+    #[test]
+    fn removals_and_unrelated_replacements_are_immediate() {
+        let source = snapshot(&[1, 2], &[10, 20]);
+        let removal = snapshot(&[2], &[20]);
+        assert!(
+            Emphasis::new(source, removal).is_none(),
+            "a removal has no new row to emphasize"
+        );
+
+        let source = snapshot(&[1], &[10]);
+        let unrelated = snapshot(&[2], &[20]);
+        assert!(
+            Emphasis::new(source, unrelated).is_none(),
+            "an unrelated history has no visual anchor"
+        );
+    }
+
+    #[test]
+    fn filesystem_reword_frames() {
+        let source = history_snapshot(&[(1, 10, "111 old title".into()), (2, 20, "222 unchanged".into())]);
+        let target = history_snapshot(&[(3, 10, "333 new title".into()), (2, 20, "222 unchanged".into())]);
+        insta::assert_snapshot!(distinct_frames(
+            Emphasis::new(source, target).expect("a reword is emphasized")
+        ));
+    }
+
+    #[test]
+    fn filesystem_new_top_commit_frames() {
+        let source = history_snapshot(&[
+            (1, 10, "111 first".into()),
+            (2, 20, "222 second".into()),
+            (3, 30, "333 third".into()),
+        ]);
+        let target = history_snapshot(&[
+            (4, 40, "444 new commit".into()),
+            (1, 10, "111 first".into()),
+            (2, 20, "222 second".into()),
+            (3, 30, "333 third".into()),
+        ]);
+        insta::assert_snapshot!(distinct_frames(
+            Emphasis::new(source, target).expect("a new top commit is emphasized")
+        ));
+    }
+}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 48876915bba..6706fe77b13 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2,13 +2,14 @@
 
 #![forbid(unsafe_code)]
 
+mod animation;
 mod app;
 mod history;
 mod logging;
 mod ui;
 
 use std::{
-    collections::VecDeque,
+    collections::{HashMap, VecDeque},
     ffi::OsString,
     io::{self, Write},
     path::{Path, PathBuf},
@@ -131,6 +132,123 @@ struct SelectionRelationCache {
     relation: Option<SelectionRelation>,
 }
 
+#[derive(Default)]
+struct MotionState {
+    shown: Option<animation::Snapshot>,
+    pending: Option<animation::Snapshot>,
+    active: Option<animation::Emphasis>,
+    last_tick: Option<Instant>,
+}
+
+impl MotionState {
+    fn capture(&mut self) {
+        if self.pending.is_none() {
+            let source = self
+                .active
+                .as_ref()
+                .map(|emphasis| emphasis.target().clone())
+                .or_else(|| self.shown.clone());
+            if let Some(source) = source {
+                self.pending = Some(source);
+            }
+        }
+    }
+
+    fn has_pending(&self) -> bool {
+        self.pending.is_some()
+    }
+
+    fn transition_ids(&self, target: &animation::Snapshot) -> Vec<gix::ObjectId> {
+        let Some(source) = &self.pending else {
+            return Vec::new();
+        };
+        if source
+            .rows
+            .iter()
+            .map(|row| row.id)
+            .eq(target.rows.iter().map(|row| row.id))
+        {
+            return Vec::new();
+        }
+        source.rows.iter().chain(&target.rows).map(|row| row.id).collect()
+    }
+
+    fn begin(
+        &mut self,
+        target: animation::Snapshot,
+        trees: &HashMap<gix::ObjectId, gix::ObjectId>,
+        now: Instant,
+    ) -> Option<ratatui::buffer::Buffer> {
+        let Some(mut source) = self.pending.take() else {
+            self.shown = Some(target);
+            return None;
+        };
+        if source.buffer.area != target.buffer.area || source.buffer == target.buffer {
+            self.shown = Some(target);
+            self.last_tick = None;
+            return None;
+        }
+        source.set_trees(trees);
+        let mut target = target;
+        target.set_trees(trees);
+        let Some(emphasis) = animation::Emphasis::new(source, target.clone()) else {
+            self.shown = Some(target);
+            self.active = None;
+            self.last_tick = None;
+            return None;
+        };
+        let displayed = emphasis.displayed().clone();
+        self.active = Some(emphasis);
+        self.last_tick = Some(now);
+        Some(displayed)
+    }
+
+    fn timeout(&self, now: Instant) -> Option<Duration> {
+        self.active.as_ref().map(|emphasis| {
+            let since_tick = self
+                .last_tick
+                .map_or(Duration::ZERO, |last_tick| now.saturating_duration_since(last_tick));
+            emphasis.timeout().saturating_sub(since_tick)
+        })
+    }
+
+    fn advance(&mut self, now: Instant) -> Option<ratatui::buffer::Buffer> {
+        let elapsed = self
+            .last_tick
+            .replace(now)
+            .map_or(Duration::ZERO, |previous| now.saturating_duration_since(previous));
+        let emphasis = self.active.as_mut()?;
+        let frame = emphasis.advance(elapsed).cloned();
+        if emphasis.is_complete() {
+            self.shown = Some(emphasis.target().clone());
+            self.active = None;
+            self.last_tick = None;
+        }
+        frame
+    }
+
+    fn finish(&mut self) -> Option<ratatui::buffer::Buffer> {
+        let emphasis = self.active.take()?;
+        let target = emphasis.target().clone();
+        let buffer = target.buffer.clone();
+        self.shown = Some(target);
+        self.last_tick = None;
+        Some(buffer)
+    }
+
+    fn show(&mut self, target: animation::Snapshot) -> ratatui::buffer::Buffer {
+        self.active = None;
+        self.last_tick = None;
+        let buffer = target.buffer.clone();
+        self.shown = Some(target);
+        buffer
+    }
+
+    fn cancel_pending(&mut self) {
+        self.pending = None;
+    }
+}
+
 const TREE_CHANGES_CACHE_SIZE: usize = 8;
 type TreeChangesEntry = (gix::ObjectId, usize, Changes);
 
@@ -608,6 +726,7 @@ fn event_loop(
         }
     }
     let mut decorations = Decorations::new();
+    let mut motion = MotionState::default();
     draw(
         terminal,
         &mut app,
@@ -621,6 +740,7 @@ fn event_loop(
         &mut history_graph,
         &mut selection_relation,
         &mut line_diff_pool,
+        &mut motion,
     )?;
     let mut last_draw = Instant::now();
     let mut dirty = false;
@@ -884,8 +1004,14 @@ fn event_loop(
             let next = history::snapshot(&repository, &revisions, &hide)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed;
+            let from_filesystem = std::mem::take(&mut refresh_from_filesystem);
+            if tips_changed && from_filesystem {
+                motion.capture();
+            } else {
+                motion.cancel_pending();
+            }
             tracing::debug!(tips_changed, hidden_changed, "compared reference snapshot");
-            let select_top = std::mem::take(&mut refresh_from_filesystem) && tips_changed;
+            let select_top = from_filesystem && tips_changed;
             ref_snapshot = next;
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
@@ -912,6 +1038,13 @@ fn event_loop(
             app.state = State::Loading;
             tracing::info!(select_top, "started history refresh");
         }
+        let now = Instant::now();
+        if motion.timeout(now) == Some(Duration::ZERO)
+            && let Some(frame) = motion.advance(now)
+        {
+            present_buffer(terminal, &frame)?;
+            last_draw = now;
+        }
         if urgent {
             draw(
                 terminal,
@@ -926,6 +1059,7 @@ fn event_loop(
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
+                &mut motion,
             )?;
             last_draw = Instant::now();
             dirty = false;
@@ -985,6 +1119,7 @@ fn event_loop(
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
+                &mut motion,
             )?;
             last_draw = Instant::now();
             dirty = false;
@@ -999,6 +1134,7 @@ fn event_loop(
         let retry_timeout = watcher_retry_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let history_status_timeout =
             history_status_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
+        let animation_timeout = motion.timeout(Instant::now());
         let wake_after = [
             repeat_timeout,
             watcher_timeout,
@@ -1006,6 +1142,7 @@ fn event_loop(
             worktree_timeout,
             retry_timeout,
             history_status_timeout,
+            animation_timeout,
         ]
         .into_iter()
         .flatten()
@@ -1049,6 +1186,10 @@ fn event_loop(
                 (Some(action), repeats_history, true, true)
             }
             TerminalEvent::FocusLost => {
+                if let Some(frame) = motion.finish() {
+                    present_buffer(terminal, &frame)?;
+                }
+                motion.cancel_pending();
                 focused = false;
                 app.changes_suppressed = false;
                 repeat_deadline = None;
@@ -1062,12 +1203,23 @@ fn event_loop(
                 continue;
             }
             TerminalEvent::Resize(_, _) => {
+                if let Some(frame) = motion.finish() {
+                    present_buffer(terminal, &frame)?;
+                }
+                motion.cancel_pending();
                 dirty = true;
                 urgent = true;
                 continue;
             }
             _ => continue,
         };
+        if action.as_ref().is_some_and(|action| action != &Action::ForceQuit) {
+            if let Some(frame) = motion.finish() {
+                present_buffer(terminal, &frame)?;
+                last_draw = Instant::now();
+            }
+            motion.cancel_pending();
+        }
         if !focused {
             continue;
         }
@@ -1398,6 +1550,7 @@ fn draw(
     history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
+    motion: &mut MotionState,
 ) -> Result<()> {
     let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
@@ -1590,17 +1743,89 @@ fn draw(
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
     let tree_changes = tree_changes.as_ref().map(|(_, _, changes)| changes);
     let worktree_changes = worktree_changes.as_ref().map(|(_, changes)| changes);
-    terminal.draw(|frame| {
+    terminal
+        .autoresize()
+        .context("could not resize the terminal before drawing")?;
+    let layout = {
+        let mut frame = terminal.get_frame();
         ui::draw_with_worktree(
-            frame,
+            &mut frame,
             app,
             decorations,
             mailmap,
             message,
             tree_changes,
             worktree_changes,
-        );
-    })?;
+        )
+    };
+    let target = animation::Snapshot::new(terminal.current_buffer_mut().clone(), layout);
+    let ready = matches!(app.state, State::Complete | State::Cancelled);
+    let presented = if motion.has_pending() && ready {
+        let ids = motion.transition_ids(&target);
+        let trees = load_transition_trees(&fill_repository.path, fill_repository.bare, &ids);
+        motion
+            .begin(target.clone(), &trees, Instant::now())
+            .unwrap_or_else(|| target.buffer.clone())
+    } else {
+        motion.show(target)
+    };
+    terminal.current_buffer_mut().clone_from(&presented);
+    terminal
+        .apply_buffer_with_cursor(None)
+        .context("could not draw terminal frame")?;
+    Ok(())
+}
+
+fn load_transition_trees(
+    repository_path: &Path,
+    bare: bool,
+    ids: &[gix::ObjectId],
+) -> HashMap<gix::ObjectId, gix::ObjectId> {
+    if ids.is_empty() {
+        return HashMap::new();
+    }
+    let loaded = (|| -> Result<_> {
+        let mut repository = open_repository(repository_path, bare, true)?;
+        repository.object_cache_size(None);
+        let cache = repository
+            .commit_graph_if_enabled()
+            .context("could not open commit-graph for transition matching")?;
+        let mut buf = Vec::new();
+        let mut trees = HashMap::with_capacity(ids.len());
+        for id in ids {
+            let commit = match gix::traverse::commit::find(cache.as_ref(), &repository.objects, id, &mut buf) {
+                Ok(commit) => commit,
+                Err(err) => {
+                    tracing::debug!(%id, error = %err, "could not load transition commit");
+                    continue;
+                }
+            };
+            match commit.tree_id() {
+                Ok(tree) => {
+                    trees.insert(*id, tree);
+                }
+                Err(err) => tracing::debug!(%id, error = %err, "could not decode transition commit tree"),
+            }
+        }
+        Ok(trees)
+    })();
+    match loaded {
+        Ok(trees) => trees,
+        Err(err) => {
+            tracing::warn!(error = %err, "transition tree matching unavailable");
+            HashMap::new()
+        }
+    }
+}
+
+fn present_buffer(terminal: &mut ratatui::DefaultTerminal, buffer: &ratatui::buffer::Buffer) -> Result<()> {
+    if terminal.get_frame().area() != buffer.area {
+        return Ok(());
+    }
+    terminal.current_buffer_mut().clone_from(buffer);
+    terminal
+        .apply_buffer_with_cursor(None)
+        .context("could not draw animation frame")?;
     Ok(())
 }
 
diff --git a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
new file mode 100644
index 00000000000..0d05fc9416b
--- /dev/null
+++ b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
@@ -0,0 +1,16 @@
+---
+source: gix-tix/src/animation.rs
+expression: "distinct_frames(Emphasis::new(source,\ntarget).expect(\"a new top commit is emphasized\"))"
+---
+--- frame 0 ---
+444 new commit
+style: bbbbbbbbbbbbbbbbbbbbbbbb
+111 first
+222 second
+333 third
+
+--- frame 1 ---
+444 new commit
+111 first
+222 second
+333 third
diff --git a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap
new file mode 100644
index 00000000000..8fe780ebdce
--- /dev/null
+++ b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap
@@ -0,0 +1,14 @@
+---
+source: gix-tix/src/animation.rs
+expression: "distinct_frames(Emphasis::new(source,\ntarget).expect(\"a reword is emphasized\"))"
+---
+--- frame 0 ---
+333 new title
+style: bbbbbbbbbbbbbbbbbbbbbbbb
+222 unchanged
+
+
+
+--- frame 1 ---
+333 new title
+222 unchanged
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4120b58a3a2..fa9ae0bb544 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -27,6 +27,13 @@ struct ChangesPaneArea {
     outer: Rect,
 }
 
+#[derive(Clone, Debug, Default)]
+pub(crate) struct FrameLayout {
+    pub history: Rect,
+    pub overlays: Vec<Rect>,
+    pub rows: Vec<(gix::ObjectId, u16)>,
+}
+
 fn changes_pane_areas(
     area: Rect,
     max_height: u16,
@@ -187,7 +194,7 @@ pub(crate) fn draw_with_worktree(
     commit_message: Option<&BStr>,
     tree_changes: Option<&Changes>,
     worktree_changes: Option<&Changes>,
-) {
+) -> FrameLayout {
     let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
     let full_body = body;
     let compared_parent = if app.changes_visible() {
@@ -342,6 +349,11 @@ pub(crate) fn draw_with_worktree(
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
 
+    let rows = visible_rows
+        .iter()
+        .enumerate()
+        .map(|(index, row)| (row.id, body.y.saturating_add(index as u16)))
+        .collect();
     for (index, metadata) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
         let y = body.y.saturating_add(index as u16);
@@ -670,6 +682,15 @@ pub(crate) fn draw_with_worktree(
         footer_spans = vec![Span::raw(notice)];
     }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
+    FrameLayout {
+        history: body,
+        overlays: changes_panes
+            .iter()
+            .map(|pane| pane.outer)
+            .chain(commit_pane.map(|(outer, _)| outer))
+            .collect(),
+        rows,
+    }
 }
 
 fn history_position(app: &App) -> String {

From fa377d4bcf36395a9ca05d2f54bbe6bd0ea42b3c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 06:57:33 +0200
Subject: [PATCH 038/282] feat: correlate tix filesystem responses in
 diagnostics

Assign a monotonically increasing response ID when the first actionable reference or relevant worktree notification arrives. Coalesce subsequent events under that ID until the existing debounce expires, and record batch counts, event-kind counts, rescans, and semantic triggers for HEAD, index, packed refs, loose refs, Git metadata, and worktree paths.

Include up to sixteen deduplicated trigger paths and report how many additional unique paths were omitted. Recognize transaction lock files as the corresponding HEAD, index, or packed-refs trigger so the initiating Git operation remains clear.

Carry response IDs through worktree invalidation, reference comparison, history refresh, lane computation, delayed status display, and history emphasis. Attribute every filesystem-caused presentation to all accumulated reasons, allowing multiple responses and phases to identify a single coalesced frame.

Finish each response with its elapsed time, presentation count, and outcome, including superseded or interrupted emphasis and watcher failures. Keep keyboard and mouse redraws out of the trace except when they terminate an active filesystem emphasis.

Preserve existing refresh and redraw behavior so diagnostics expose the current cause-and-effect chain without changing it. Cover trigger classification, batch coalescing, bounded path collection, rescans, new response IDs after debounce, and overlapping causes in one frame.
---
 gix-tix/src/lib.rs     |  96 +++++++--
 gix-tix/src/logging.rs | 441 +++++++++++++++++++++++++++++++++++++++++
 2 files changed, 523 insertions(+), 14 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 6706fe77b13..c166d7c9bb4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -727,6 +727,7 @@ fn event_loop(
     }
     let mut decorations = Decorations::new();
     let mut motion = MotionState::default();
+    let mut filesystem_responses = logging::FilesystemResponses::default();
     draw(
         terminal,
         &mut app,
@@ -741,6 +742,7 @@ fn event_loop(
         &mut selection_relation,
         &mut line_diff_pool,
         &mut motion,
+        &mut filesystem_responses,
     )?;
     let mut last_draw = Instant::now();
     let mut dirty = false;
@@ -763,6 +765,7 @@ fn event_loop(
                         rescans += usize::from(event.need_rescan());
                         if watcher.event_is_relevant(&event) {
                             relevant += 1;
+                            filesystem_responses.observe_worktree(&event, &watcher.workdir, &watcher.index);
                             schedule_once(&mut worktree_refresh_deadline, Instant::now(), WORKTREE_EVENT_IDLE);
                         }
                     }
@@ -774,11 +777,15 @@ fn event_loop(
                 }
             }
             if received > 0 {
+                if relevant > 0 {
+                    filesystem_responses.note_worktree_batch();
+                }
                 tracing::debug!(received, relevant, rescans, "processed worktree event batch");
             }
         }
         if let Some(err) = worktree_watch_error {
             tracing::warn!(error = %err, "worktree watcher failed");
+            filesystem_responses.fail_pending_worktree();
             app.worktree_changes.error = Some(format!("worktree watch: {err}"));
             worktree_watcher = None;
             worktree_refresh_deadline = None;
@@ -788,6 +795,7 @@ fn event_loop(
         }
         if take_due(&mut worktree_refresh_deadline, Instant::now()) {
             let invalidated = invalidate_worktree_changes(&mut worktree_changes);
+            filesystem_responses.worktree_due(invalidated);
             tracing::debug!(invalidated, "worktree event deadline elapsed");
             dirty = true;
             urgent = true;
@@ -804,6 +812,7 @@ fn event_loop(
                         rescans += usize::from(event.need_rescan());
                         if notification_is_actionable(&event) {
                             actionable += 1;
+                            filesystem_responses.observe_references(&event, &repository_path, &common_dir);
                             ref_refresh_deadline = Some(Instant::now() + REF_EVENT_IDLE);
                         }
                     }
@@ -815,20 +824,28 @@ fn event_loop(
                 }
             }
             if received > 0 {
+                if actionable > 0 {
+                    filesystem_responses.note_reference_batch();
+                }
                 tracing::debug!(received, actionable, rescans, "processed reference event batch");
             }
         }
         if let Some(err) = ref_watch_error {
             tracing::warn!(error = %err, "reference watcher failed");
+            filesystem_responses.fail_pending_references();
             ref_watcher = None;
             ref_refresh_deadline = None;
             app.manual_refresh = true;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
+            let response_ids = filesystem_responses.references_due();
             refresh_pending = true;
             refresh_from_filesystem = true;
-            if invalidate_worktree_changes(&mut worktree_changes) {
+            let invalidated = invalidate_worktree_changes(&mut worktree_changes);
+            filesystem_responses.phase(&response_ids, "reference-worktree-cache-invalidation");
+            if invalidated {
+                filesystem_responses.queue_frame(&response_ids, "reference-worktree-cache-invalidation");
                 dirty = true;
                 urgent = true;
             }
@@ -878,6 +895,8 @@ fn event_loop(
         }
         if take_due(&mut history_status_deadline, Instant::now()) {
             app.deferred_history_state = None;
+            let response_ids = filesystem_responses.active_reference_ids().to_vec();
+            filesystem_responses.queue_frame(&response_ids, "delayed-history-status");
             dirty = true;
             urgent = true;
         }
@@ -909,6 +928,10 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    let response_ids = filesystem_responses.active_reference_ids().to_vec();
+                    filesystem_responses.phase(&response_ids, "lane-computation-completed");
+                    filesystem_responses.queue_frame(&response_ids, "lane-computation-completed");
+                    filesystem_responses.finish_after_frame(&response_ids, "completed");
                     history_status_deadline = None;
                     app.deferred_history_state = None;
                     selection_relation = None;
@@ -931,6 +954,9 @@ fn event_loop(
                     history_graph = Some(graph);
                     let result = result?;
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
+                    let response_ids = filesystem_responses.active_reference_ids().to_vec();
+                    filesystem_responses.phase(&response_ids, "history-refresh-completed");
+                    filesystem_responses.queue_frame(&response_ids, "history-refresh-completed");
                     decorations = result.decorations;
                     selection_relation = None;
                     app.selection_relation = None;
@@ -961,6 +987,7 @@ fn event_loop(
             && matches!(app.state, State::Complete | State::Cancelled)
         {
             let refresh_started = Instant::now();
+            let response_ids = filesystem_responses.begin_reference_refresh();
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
                 Ok(repository) => repository,
                 Err(_err) if worktree_repository_is_gone(&repository_path) => {
@@ -977,6 +1004,7 @@ fn event_loop(
                     app.set_worktree_changes_available(false);
                     worktree_watcher = None;
                     worktree_refresh_deadline = None;
+                    filesystem_responses.cancel_pending_worktree("worktree-unavailable");
                     worktree_changes = None;
                     line_diff_pool = None;
                     sync_line_diff_pool(
@@ -1010,7 +1038,12 @@ fn event_loop(
             } else {
                 motion.cancel_pending();
             }
-            tracing::debug!(tips_changed, hidden_changed, "compared reference snapshot");
+            tracing::debug!(
+                ?response_ids,
+                tips_changed,
+                hidden_changed,
+                "compared reference snapshot"
+            );
             let select_top = from_filesystem && tips_changed;
             ref_snapshot = next;
             refresh_pending = false;
@@ -1036,13 +1069,19 @@ fn event_loop(
             app.deferred_history_state = Some(app.state);
             history_status_deadline = Some(refresh_started + HISTORY_STATUS_DELAY);
             app.state = State::Loading;
-            tracing::info!(select_top, "started history refresh");
+            filesystem_responses.phase(&response_ids, "history-refresh-started");
+            tracing::info!(?response_ids, select_top, "started history refresh");
         }
         let now = Instant::now();
         if motion.timeout(now) == Some(Duration::ZERO)
             && let Some(frame) = motion.advance(now)
         {
-            present_buffer(terminal, &frame)?;
+            if present_buffer(terminal, &frame)? {
+                filesystem_responses.emphasis_finished("history-emphasis-settled", "completed");
+                filesystem_responses.frame_presented();
+            } else {
+                filesystem_responses.emphasis_aborted("terminal-area-changed");
+            }
             last_draw = now;
         }
         if urgent {
@@ -1060,6 +1099,7 @@ fn event_loop(
                 &mut selection_relation,
                 &mut line_diff_pool,
                 &mut motion,
+                &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
             dirty = false;
@@ -1120,6 +1160,7 @@ fn event_loop(
                 &mut selection_relation,
                 &mut line_diff_pool,
                 &mut motion,
+                &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
             dirty = false;
@@ -1187,7 +1228,12 @@ fn event_loop(
             }
             TerminalEvent::FocusLost => {
                 if let Some(frame) = motion.finish() {
-                    present_buffer(terminal, &frame)?;
+                    if present_buffer(terminal, &frame)? {
+                        filesystem_responses.emphasis_finished("emphasis-interrupted-by-focus", "interrupted-by-focus");
+                        filesystem_responses.frame_presented();
+                    } else {
+                        filesystem_responses.emphasis_aborted("terminal-area-changed");
+                    }
                 }
                 motion.cancel_pending();
                 focused = false;
@@ -1204,7 +1250,13 @@ fn event_loop(
             }
             TerminalEvent::Resize(_, _) => {
                 if let Some(frame) = motion.finish() {
-                    present_buffer(terminal, &frame)?;
+                    if present_buffer(terminal, &frame)? {
+                        filesystem_responses
+                            .emphasis_finished("emphasis-interrupted-by-resize", "interrupted-by-resize");
+                        filesystem_responses.frame_presented();
+                    } else {
+                        filesystem_responses.emphasis_aborted("terminal-area-changed");
+                    }
                 }
                 motion.cancel_pending();
                 dirty = true;
@@ -1215,7 +1267,12 @@ fn event_loop(
         };
         if action.as_ref().is_some_and(|action| action != &Action::ForceQuit) {
             if let Some(frame) = motion.finish() {
-                present_buffer(terminal, &frame)?;
+                if present_buffer(terminal, &frame)? {
+                    filesystem_responses.emphasis_finished("emphasis-interrupted-by-input", "interrupted-by-input");
+                    filesystem_responses.frame_presented();
+                } else {
+                    filesystem_responses.emphasis_aborted("terminal-area-changed");
+                }
                 last_draw = Instant::now();
             }
             motion.cancel_pending();
@@ -1289,6 +1346,7 @@ fn event_loop(
             } else if previous_changes_mode == Some(ChangesMode::Both) {
                 worktree_watcher = None;
                 worktree_refresh_deadline = None;
+                filesystem_responses.cancel_pending_worktree("watcher-disabled");
             }
         }
         for effect in effects {
@@ -1551,6 +1609,7 @@ fn draw(
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
     motion: &mut MotionState,
+    filesystem_responses: &mut logging::FilesystemResponses,
 ) -> Result<()> {
     let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
@@ -1763,16 +1822,25 @@ fn draw(
     let presented = if motion.has_pending() && ready {
         let ids = motion.transition_ids(&target);
         let trees = load_transition_trees(&fill_repository.path, fill_repository.bare, &ids);
-        motion
-            .begin(target.clone(), &trees, Instant::now())
-            .unwrap_or_else(|| target.buffer.clone())
+        let started = motion.begin(target.clone(), &trees, Instant::now());
+        if started.is_some() {
+            filesystem_responses.emphasis_started();
+        }
+        started.unwrap_or_else(|| target.buffer.clone())
     } else {
-        motion.show(target)
+        filesystem_responses.emphasis_finished("history-emphasis-superseded", "superseded");
+        let frame = motion.show(target);
+        if ready {
+            let response_ids = filesystem_responses.active_reference_ids().to_vec();
+            filesystem_responses.finish_after_frame(&response_ids, "completed");
+        }
+        frame
     };
     terminal.current_buffer_mut().clone_from(&presented);
     terminal
         .apply_buffer_with_cursor(None)
         .context("could not draw terminal frame")?;
+    filesystem_responses.frame_presented();
     Ok(())
 }
 
@@ -1818,15 +1886,15 @@ fn load_transition_trees(
     }
 }
 
-fn present_buffer(terminal: &mut ratatui::DefaultTerminal, buffer: &ratatui::buffer::Buffer) -> Result<()> {
+fn present_buffer(terminal: &mut ratatui::DefaultTerminal, buffer: &ratatui::buffer::Buffer) -> Result<bool> {
     if terminal.get_frame().area() != buffer.area {
-        return Ok(());
+        return Ok(false);
     }
     terminal.current_buffer_mut().clone_from(buffer);
     terminal
         .apply_buffer_with_cursor(None)
         .context("could not draw animation frame")?;
-    Ok(())
+    Ok(true)
 }
 
 fn open_repository(repository_path: &Path, bare: bool, isolated: bool) -> Result<gix::Repository> {
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index f5dba90f934..afae4c5c11c 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -1,4 +1,5 @@
 use std::{
+    collections::{BTreeMap, BTreeSet, HashMap, HashSet},
     fs,
     path::{Path, PathBuf},
     time::{Duration, SystemTime},
@@ -9,6 +10,338 @@ use tracing_subscriber::{filter::Targets, prelude::*};
 
 const FILE_PREFIX: &str = "tix.log";
 const RETENTION: Duration = Duration::from_secs(7 * 24 * 60 * 60);
+const MAX_TRIGGER_PATHS: usize = 16;
+
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+enum Trigger {
+    Head,
+    Index,
+    PackedRefs,
+    Refs,
+    Rescan,
+    Worktree,
+    GitMetadata,
+}
+
+#[derive(Clone, Copy, Debug)]
+enum WatcherKind {
+    References,
+    Worktree,
+}
+
+struct Response {
+    id: u64,
+    watcher: WatcherKind,
+    started: std::time::Instant,
+    batches: usize,
+    events: usize,
+    rescans: usize,
+    kinds: BTreeMap<&'static str, usize>,
+    triggers: BTreeSet<Trigger>,
+    seen_paths: HashSet<PathBuf>,
+    paths: Vec<PathBuf>,
+    omitted_paths: usize,
+    presentations: usize,
+}
+
+impl Response {
+    fn new(id: u64, watcher: WatcherKind) -> Self {
+        Response {
+            id,
+            watcher,
+            started: std::time::Instant::now(),
+            batches: 0,
+            events: 0,
+            rescans: 0,
+            kinds: BTreeMap::new(),
+            triggers: BTreeSet::new(),
+            seen_paths: HashSet::new(),
+            paths: Vec::new(),
+            omitted_paths: 0,
+            presentations: 0,
+        }
+    }
+
+    fn observe(&mut self, event: &notify::Event, classify: impl Fn(&Path) -> Trigger) {
+        self.events += 1;
+        self.rescans += usize::from(event.need_rescan());
+        *self.kinds.entry(event_kind(&event.kind)).or_default() += 1;
+        if event.need_rescan() {
+            self.triggers.insert(Trigger::Rescan);
+        }
+        for path in &event.paths {
+            self.triggers.insert(classify(path));
+            if !self.seen_paths.insert(path.clone()) {
+                continue;
+            }
+            if self.paths.len() < MAX_TRIGGER_PATHS {
+                self.paths.push(path.clone());
+            } else {
+                self.omitted_paths += 1;
+            }
+        }
+    }
+
+    fn log_trigger(&self) {
+        tracing::debug!(
+            response_id = self.id,
+            watcher = ?self.watcher,
+            batches = self.batches,
+            events = self.events,
+            rescans = self.rescans,
+            event_kinds = ?self.kinds,
+            triggers = ?self.triggers,
+            paths = ?self.paths,
+            omitted_paths = self.omitted_paths,
+            "filesystem UI response triggered"
+        );
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct FilesystemResponses {
+    next_id: u64,
+    responses: HashMap<u64, Response>,
+    pending_worktree: Option<u64>,
+    pending_references: Option<u64>,
+    queued_references: Vec<u64>,
+    active_references: Vec<u64>,
+    emphasis: Vec<u64>,
+    frame_causes: Vec<(u64, &'static str)>,
+    finish_after_frame: Vec<(u64, &'static str)>,
+}
+
+impl FilesystemResponses {
+    pub(crate) fn observe_worktree(&mut self, event: &notify::Event, workdir: &Path, index: &Path) -> u64 {
+        let id = self.ensure_pending(WatcherKind::Worktree);
+        self.responses
+            .get_mut(&id)
+            .expect("a pending response is registered")
+            .observe(event, |path| {
+                if path == index {
+                    Trigger::Index
+                } else if path.starts_with(workdir) {
+                    Trigger::Worktree
+                } else {
+                    Trigger::GitMetadata
+                }
+            });
+        id
+    }
+
+    pub(crate) fn observe_references(&mut self, event: &notify::Event, git_dir: &Path, common_dir: &Path) -> u64 {
+        let id = self.ensure_pending(WatcherKind::References);
+        self.responses
+            .get_mut(&id)
+            .expect("a pending response is registered")
+            .observe(event, |path| classify_reference_path(path, git_dir, common_dir));
+        id
+    }
+
+    pub(crate) fn note_worktree_batch(&mut self) {
+        self.note_batch(self.pending_worktree);
+    }
+
+    pub(crate) fn note_reference_batch(&mut self) {
+        self.note_batch(self.pending_references);
+    }
+
+    pub(crate) fn worktree_due(&mut self, invalidated: bool) -> Vec<u64> {
+        let Some(id) = self.pending_worktree.take() else {
+            return Vec::new();
+        };
+        self.log_trigger(id);
+        tracing::debug!(response_id = id, invalidated, action = "worktree-cache-invalidation");
+        self.queue_frame(&[id], "worktree-cache-invalidation");
+        self.finish_after_frame(&[id], "completed");
+        vec![id]
+    }
+
+    pub(crate) fn references_due(&mut self) -> Vec<u64> {
+        let Some(id) = self.pending_references.take() else {
+            return Vec::new();
+        };
+        self.log_trigger(id);
+        self.queued_references.push(id);
+        tracing::debug!(response_id = id, action = "reference-refresh-queued");
+        vec![id]
+    }
+
+    pub(crate) fn begin_reference_refresh(&mut self) -> Vec<u64> {
+        self.active_references = std::mem::take(&mut self.queued_references);
+        self.active_references.clone()
+    }
+
+    pub(crate) fn active_reference_ids(&self) -> &[u64] {
+        &self.active_references
+    }
+
+    pub(crate) fn phase(&self, ids: &[u64], action: &'static str) {
+        if !ids.is_empty() {
+            tracing::debug!(response_ids = ?ids, action);
+        }
+    }
+
+    pub(crate) fn queue_frame(&mut self, ids: &[u64], reason: &'static str) {
+        for id in ids {
+            if !self.frame_causes.contains(&(*id, reason)) {
+                self.frame_causes.push((*id, reason));
+            }
+        }
+    }
+
+    pub(crate) fn finish_after_frame(&mut self, ids: &[u64], outcome: &'static str) {
+        for id in ids {
+            if !self.finish_after_frame.iter().any(|(candidate, _)| candidate == id) {
+                self.finish_after_frame.push((*id, outcome));
+            }
+        }
+    }
+
+    pub(crate) fn keep_after_frame(&mut self, ids: &[u64]) {
+        self.finish_after_frame.retain(|(id, _)| !ids.contains(id));
+    }
+
+    pub(crate) fn emphasis_started(&mut self) {
+        let superseded = std::mem::take(&mut self.emphasis);
+        self.finish(&superseded, "superseded");
+        let ids = self.active_references.clone();
+        self.keep_after_frame(&ids);
+        self.queue_frame(&ids, "history-emphasis-started");
+        self.emphasis = ids;
+    }
+
+    pub(crate) fn emphasis_finished(&mut self, reason: &'static str, outcome: &'static str) {
+        let ids = std::mem::take(&mut self.emphasis);
+        self.queue_frame(&ids, reason);
+        self.finish_after_frame(&ids, outcome);
+    }
+
+    pub(crate) fn emphasis_aborted(&mut self, outcome: &'static str) {
+        let ids = std::mem::take(&mut self.emphasis);
+        self.finish(&ids, outcome);
+    }
+
+    pub(crate) fn fail_pending_worktree(&mut self) {
+        self.cancel_pending_worktree("watcher-failure");
+    }
+
+    pub(crate) fn cancel_pending_worktree(&mut self, outcome: &'static str) {
+        if let Some(id) = self.pending_worktree.take() {
+            self.log_trigger(id);
+            self.finish(&[id], outcome);
+        }
+    }
+
+    pub(crate) fn fail_pending_references(&mut self) {
+        if let Some(id) = self.pending_references.take() {
+            self.log_trigger(id);
+            self.finish(&[id], "watcher-failure");
+        }
+    }
+
+    pub(crate) fn frame_presented(&mut self) {
+        if self.frame_causes.is_empty() {
+            return;
+        }
+        let causes = std::mem::take(&mut self.frame_causes);
+        let mut ids = causes.iter().map(|(id, _)| *id).collect::<Vec<_>>();
+        ids.sort_unstable();
+        ids.dedup();
+        for id in &ids {
+            if let Some(response) = self.responses.get_mut(id) {
+                response.presentations += 1;
+            }
+        }
+        tracing::debug!(response_ids = ?ids, ?causes, "filesystem-triggered UI frame presented");
+
+        let finishing = std::mem::take(&mut self.finish_after_frame);
+        for (id, outcome) in finishing {
+            self.finish(&[id], outcome);
+        }
+    }
+
+    pub(crate) fn finish(&mut self, ids: &[u64], outcome: &'static str) {
+        for id in ids {
+            let Some(response) = self.responses.remove(id) else {
+                continue;
+            };
+            tracing::debug!(
+                response_id = response.id,
+                watcher = ?response.watcher,
+                outcome,
+                presentations = response.presentations,
+                elapsed_ms = response.started.elapsed().as_millis(),
+                "filesystem UI response finished"
+            );
+        }
+        self.active_references.retain(|id| !ids.contains(id));
+        self.emphasis.retain(|id| !ids.contains(id));
+        self.queued_references.retain(|id| !ids.contains(id));
+        self.frame_causes.retain(|(id, _)| !ids.contains(id));
+        self.finish_after_frame.retain(|(id, _)| !ids.contains(id));
+    }
+
+    fn ensure_pending(&mut self, watcher: WatcherKind) -> u64 {
+        let slot = match watcher {
+            WatcherKind::References => &mut self.pending_references,
+            WatcherKind::Worktree => &mut self.pending_worktree,
+        };
+        if let Some(id) = *slot {
+            return id;
+        }
+        self.next_id += 1;
+        let id = self.next_id;
+        self.responses.insert(id, Response::new(id, watcher));
+        *slot = Some(id);
+        id
+    }
+
+    fn log_trigger(&self, id: u64) {
+        if let Some(response) = self.responses.get(&id) {
+            response.log_trigger();
+        }
+    }
+
+    fn note_batch(&mut self, id: Option<u64>) {
+        if let Some(response) = id.and_then(|id| self.responses.get_mut(&id)) {
+            response.batches += 1;
+        }
+    }
+}
+
+fn event_kind(kind: &notify::EventKind) -> &'static str {
+    match kind {
+        notify::EventKind::Access(_) => "access",
+        notify::EventKind::Create(_) => "create",
+        notify::EventKind::Modify(_) => "modify",
+        notify::EventKind::Remove(_) => "remove",
+        notify::EventKind::Other => "other",
+        notify::EventKind::Any => "any",
+    }
+}
+
+fn classify_reference_path(path: &Path, git_dir: &Path, common_dir: &Path) -> Trigger {
+    let head = git_dir.join("HEAD");
+    let common_head = common_dir.join("HEAD");
+    let index = git_dir.join("index");
+    let packed_refs = common_dir.join("packed-refs");
+    if path == head
+        || path == head.with_extension("lock")
+        || path == common_head
+        || path == common_head.with_extension("lock")
+    {
+        Trigger::Head
+    } else if path == index || path == index.with_extension("lock") {
+        Trigger::Index
+    } else if path == packed_refs || path == packed_refs.with_extension("lock") {
+        Trigger::PackedRefs
+    } else if path.starts_with(git_dir.join("refs")) || path.starts_with(common_dir.join("refs")) {
+        Trigger::Refs
+    } else {
+        Trigger::GitMetadata
+    }
+}
 
 pub(crate) fn init() -> Result<tracing::subscriber::DefaultGuard> {
     let directory = log_directory().context("could not determine the platform log directory")?;
@@ -92,8 +425,116 @@ fn prune(directory: &Path, now: SystemTime) -> Vec<String> {
 mod tests {
     use std::{fs::File, time::UNIX_EPOCH};
 
+    use notify::event::{Flag, ModifyKind};
+
     use super::*;
 
+    fn modified(path: impl Into<PathBuf>) -> notify::Event {
+        notify::Event::new(notify::EventKind::Modify(ModifyKind::Any)).add_path(path.into())
+    }
+
+    #[test]
+    fn classifies_reference_triggers() {
+        let common = Path::new("/repo/.git");
+        let linked = common.join("worktrees/topic");
+        assert_eq!(
+            classify_reference_path(&linked.join("HEAD"), &linked, common),
+            Trigger::Head
+        );
+        assert_eq!(
+            classify_reference_path(&linked.join("HEAD.lock"), &linked, common),
+            Trigger::Head,
+            "transaction lock files retain their semantic trigger"
+        );
+        assert_eq!(
+            classify_reference_path(&linked.join("index"), &linked, common),
+            Trigger::Index
+        );
+        assert_eq!(
+            classify_reference_path(&common.join("packed-refs"), &linked, common),
+            Trigger::PackedRefs
+        );
+        assert_eq!(
+            classify_reference_path(&common.join("refs/heads/main"), &linked, common),
+            Trigger::Refs
+        );
+        assert_eq!(
+            classify_reference_path(&common.join("config"), &linked, common),
+            Trigger::GitMetadata
+        );
+    }
+
+    #[test]
+    fn coalesces_batches_and_bounds_deduplicated_trigger_paths() {
+        let common = Path::new("/repo/.git");
+        let mut responses = FilesystemResponses::default();
+        let first = responses.observe_references(&modified(common.join("HEAD")), common, common);
+        responses.note_reference_batch();
+        let second = responses.observe_references(&modified(common.join("refs/heads/main")), common, common);
+        let rescan = notify::Event::new(notify::EventKind::Other).set_flag(Flag::Rescan);
+        let third = responses.observe_references(&rescan, common, common);
+        responses.note_reference_batch();
+        assert_eq!(first, second, "events before the deadline share one response");
+        assert_eq!(first, third, "rescans join the pending response");
+        let response = responses
+            .responses
+            .get(&first)
+            .expect("the response is retained until acted upon");
+        assert_eq!(response.events, 3);
+        assert_eq!(response.batches, 2);
+        assert_eq!(response.kinds, [("modify", 2), ("other", 1)].into_iter().collect());
+        assert_eq!(
+            response.triggers,
+            [Trigger::Head, Trigger::Refs, Trigger::Rescan].into_iter().collect()
+        );
+
+        assert_eq!(responses.references_due(), [first]);
+        let next = responses.observe_references(&modified(common.join("HEAD")), common, common);
+        assert_ne!(next, first, "activity after the deadline starts another response");
+
+        let mut many = notify::Event::new(notify::EventKind::Modify(ModifyKind::Any));
+        for index in 0..MAX_TRIGGER_PATHS + 4 {
+            many = many.add_path(common.join(format!("refs/heads/{index}")));
+        }
+        many = many.add_path(common.join(format!("refs/heads/{}", MAX_TRIGGER_PATHS + 3)));
+        responses.observe_references(&many, common, common);
+        let response = responses.responses.get(&next).expect("the new response is pending");
+        assert_eq!(response.paths.len(), MAX_TRIGGER_PATHS);
+        assert_eq!(
+            response.omitted_paths, 5,
+            "only unique paths beyond the cap are counted"
+        );
+    }
+
+    #[test]
+    fn attributes_overlapping_responses_to_one_presented_frame() {
+        let common = Path::new("/repo/.git");
+        let workdir = Path::new("/repo");
+        let mut responses = FilesystemResponses::default();
+        let worktree = responses.observe_worktree(&modified(workdir.join("file")), workdir, &common.join("index"));
+        responses.worktree_due(true);
+
+        let references = responses.observe_references(&modified(common.join("HEAD")), common, common);
+        responses.references_due();
+        assert_eq!(responses.begin_reference_refresh(), [references]);
+        responses.queue_frame(&[references], "lane-computation-completed");
+        responses.finish_after_frame(&[references], "completed");
+
+        assert_eq!(
+            responses.frame_causes,
+            [
+                (worktree, "worktree-cache-invalidation"),
+                (references, "lane-computation-completed")
+            ],
+            "one frame retains both filesystem causes"
+        );
+        responses.frame_presented();
+        assert!(
+            responses.responses.is_empty(),
+            "both responses finish after the shared frame"
+        );
+    }
+
     #[test]
     fn prunes_only_expired_daily_logs() -> gix_testtools::Result {
         let directory = std::env::temp_dir().join(format!(

From 1190125b3b672fa7f576d6bb2bf2498b3a1bcb49 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 07:34:34 +0200
Subject: [PATCH 039/282] fix: avoid watching ignored tix worktree directories

Use gix directory walking to register non-recursive watches only for directories that Git status would traverse. This prevents ignored build output such as target/ from repeatedly invalidating and recomputing an unchanged worktree status.

Refresh the directory watch set when directory topology, ignore rules, or the index changes, while retaining only paths and native watcher handles between refreshes.
---
 gix-tix/src/lib.rs | 209 ++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 199 insertions(+), 10 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c166d7c9bb4..b535d1b6cf2 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -9,7 +9,7 @@ mod logging;
 mod ui;
 
 use std::{
-    collections::{HashMap, VecDeque},
+    collections::{HashMap, HashSet, VecDeque},
     ffi::OsString,
     io::{self, Write},
     path::{Path, PathBuf},
@@ -68,6 +68,7 @@ struct FillRepository {
 struct WorktreeWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
+    directories: HashSet<PathBuf>,
     workdir: PathBuf,
     dot_git: PathBuf,
     git_dir: PathBuf,
@@ -83,6 +84,45 @@ impl WorktreeWatcher {
     fn event_is_relevant(&self, event: &notify::Event) -> bool {
         worktree_event_is_relevant(event, &self.workdir, &self.dot_git, &self.git_dir, &self.index)
     }
+
+    fn watch_set_may_change(&self, event: &notify::Event) -> bool {
+        worktree_watch_set_may_change(event, &self.index, &self.directories)
+    }
+}
+
+#[derive(Default)]
+struct WorktreeDirectories {
+    root: PathBuf,
+    paths: HashSet<PathBuf>,
+}
+
+impl gix::dir::walk::Delegate for WorktreeDirectories {
+    fn emit(
+        &mut self,
+        _entry: gix::dir::EntryRef<'_>,
+        _collapsed_directory_status: Option<gix::dir::entry::Status>,
+    ) -> gix::dir::walk::Action {
+        std::ops::ControlFlow::Continue(())
+    }
+
+    fn can_recurse(
+        &mut self,
+        entry: gix::dir::EntryRef<'_>,
+        for_deletion: Option<gix::dir::walk::ForDeletionMode>,
+        worktree_root_is_repository: bool,
+    ) -> bool {
+        let recurse = entry.status.can_recurse(
+            entry.disk_kind,
+            entry.pathspec_match,
+            for_deletion,
+            worktree_root_is_repository,
+        );
+        if recurse {
+            self.paths
+                .insert(self.root.join(gix::path::from_bstr(entry.rela_path.as_ref())));
+        }
+        recurse
+    }
 }
 
 fn worktree_event_is_relevant(
@@ -99,6 +139,31 @@ fn worktree_event_is_relevant(
             }))
 }
 
+fn worktree_watch_set_may_change(event: &notify::Event, index: &Path, directories: &HashSet<PathBuf>) -> bool {
+    if event.need_rescan()
+        || event
+            .paths
+            .iter()
+            .any(|path| path == index || path.file_name().is_some_and(|name| name == ".gitignore"))
+    {
+        return true;
+    }
+    match event.kind {
+        notify::EventKind::Create(notify::event::CreateKind::Folder)
+        | notify::EventKind::Remove(notify::event::RemoveKind::Folder)
+        | notify::EventKind::Modify(notify::event::ModifyKind::Name(_)) => true,
+        notify::EventKind::Create(notify::event::CreateKind::Any | notify::event::CreateKind::Other)
+        | notify::EventKind::Any => event
+            .paths
+            .iter()
+            .any(|path| path.is_dir() || directories.contains(path)),
+        notify::EventKind::Remove(notify::event::RemoveKind::Any | notify::event::RemoveKind::Other) => {
+            event.paths.iter().any(|path| directories.contains(path))
+        }
+        _ => false,
+    }
+}
+
 fn notification_is_actionable(event: &notify::Event) -> bool {
     event.need_rescan() || !matches!(event.kind, notify::EventKind::Access(_))
 }
@@ -696,6 +761,7 @@ fn event_loop(
     let mut worktree_changes = None;
     let mut worktree_watcher: Option<WorktreeWatcher> = None;
     let mut worktree_refresh_deadline: Option<Instant> = None;
+    let mut worktree_watch_set_changed = false;
     let mut selection_relation = None;
     let mut history_graph = None;
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
@@ -765,6 +831,7 @@ fn event_loop(
                         rescans += usize::from(event.need_rescan());
                         if watcher.event_is_relevant(&event) {
                             relevant += 1;
+                            worktree_watch_set_changed |= watcher.watch_set_may_change(&event);
                             filesystem_responses.observe_worktree(&event, &watcher.workdir, &watcher.index);
                             schedule_once(&mut worktree_refresh_deadline, Instant::now(), WORKTREE_EVENT_IDLE);
                         }
@@ -789,11 +856,23 @@ fn event_loop(
             app.worktree_changes.error = Some(format!("worktree watch: {err}"));
             worktree_watcher = None;
             worktree_refresh_deadline = None;
+            worktree_watch_set_changed = false;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
             dirty = true;
             urgent = true;
         }
         if take_due(&mut worktree_refresh_deadline, Instant::now()) {
+            if std::mem::take(&mut worktree_watch_set_changed) {
+                match start_worktree_watcher(&repository_path, repository_is_bare) {
+                    Ok(watcher) => worktree_watcher = Some(watcher),
+                    Err(err) => {
+                        tracing::warn!(error = %err, "worktree watcher rebuild failed");
+                        app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                        worktree_watcher = None;
+                        schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                    }
+                }
+            }
             let invalidated = invalidate_worktree_changes(&mut worktree_changes);
             filesystem_responses.worktree_due(invalidated);
             tracing::debug!(invalidated, "worktree event deadline elapsed");
@@ -1004,6 +1083,7 @@ fn event_loop(
                     app.set_worktree_changes_available(false);
                     worktree_watcher = None;
                     worktree_refresh_deadline = None;
+                    worktree_watch_set_changed = false;
                     filesystem_responses.cancel_pending_worktree("worktree-unavailable");
                     worktree_changes = None;
                     line_diff_pool = None;
@@ -1314,6 +1394,16 @@ fn event_loop(
         let effects = app.update(action);
         if refreshes_worktree {
             invalidate_worktree_changes(&mut worktree_changes);
+            worktree_watch_set_changed = false;
+            match start_worktree_watcher(&repository_path, repository_is_bare) {
+                Ok(watcher) => worktree_watcher = Some(watcher),
+                Err(err) => {
+                    tracing::warn!(error = %err, "worktree watcher refresh failed");
+                    app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                    worktree_watcher = None;
+                    schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                }
+            }
         }
         if toggles_changes {
             sync_line_diff_pool(
@@ -1325,6 +1415,7 @@ fn event_loop(
             )?;
             if app.changes_mode == Some(ChangesMode::Both) {
                 invalidate_worktree_changes(&mut worktree_changes);
+                worktree_watch_set_changed = false;
                 match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => {
                         worktree_watcher = Some(watcher);
@@ -1346,6 +1437,7 @@ fn event_loop(
             } else if previous_changes_mode == Some(ChangesMode::Both) {
                 worktree_watcher = None;
                 worktree_refresh_deadline = None;
+                worktree_watch_set_changed = false;
                 filesystem_responses.cancel_pending_worktree("watcher-disabled");
             }
         }
@@ -1530,6 +1622,7 @@ fn start_ref_watcher(git_dir: &Path, common_dir: &Path) -> Result<RefWatcher> {
 }
 
 fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<WorktreeWatcher> {
+    let started = Instant::now();
     let repository = open_repository(repository_path, bare, false)
         .context("could not open repository for worktree watcher setup")?;
     let workdir = repository
@@ -1539,24 +1632,43 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
     let index = repository.index_path();
     let git_dir = repository.git_dir().to_owned();
     let dot_git = workdir.join(gix::discover::DOT_GIT_DIR);
+    let dirwalk_started = Instant::now();
+    let directories = worktree_watch_directories(&repository)?;
+    let dirwalk_ms = dirwalk_started.elapsed().as_millis();
+    let registration_started = Instant::now();
     let (sender, events) = mpsc::channel();
     let mut watcher = notify::recommended_watcher(move |event| {
         let _ = sender.send(event);
     })
     .context("could not initialize worktree watcher")?;
-    watcher
-        .watch(&workdir, RecursiveMode::Recursive)
-        .with_context(|| format!("could not watch worktree at {}", workdir.display()))?;
     let index_parent = index.parent().context("index path has no parent")?;
-    if !index_parent.starts_with(&workdir) {
-        watcher
-            .watch(index_parent, RecursiveMode::NonRecursive)
-            .with_context(|| format!("could not watch index at {}", index_parent.display()))?;
+    {
+        let mut paths = watcher.paths_mut();
+        for directory in &directories {
+            paths
+                .add(directory, RecursiveMode::NonRecursive)
+                .with_context(|| format!("could not watch worktree directory at {}", directory.display()))?;
+        }
+        if !directories.contains(index_parent) {
+            paths
+                .add(index_parent, RecursiveMode::NonRecursive)
+                .with_context(|| format!("could not watch index at {}", index_parent.display()))?;
+        }
+        paths.commit().context("could not apply worktree watches")?;
     }
-    tracing::info!(workdir = %workdir.display(), index = %index.display(), "watching worktree changes");
+    tracing::info!(
+        workdir = %workdir.display(),
+        index = %index.display(),
+        directories = directories.len(),
+        dirwalk_ms,
+        registration_ms = registration_started.elapsed().as_millis(),
+        setup_ms = started.elapsed().as_millis(),
+        "watching worktree changes"
+    );
     Ok(WorktreeWatcher {
         _watcher: watcher,
         events,
+        directories,
         workdir,
         dot_git,
         git_dir,
@@ -1564,6 +1676,27 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
     })
 }
 
+fn worktree_watch_directories(repository: &gix::Repository) -> Result<HashSet<PathBuf>> {
+    let root = repository
+        .workdir()
+        .context("cannot walk a bare repository")?
+        .to_owned();
+    let index = repository
+        .index_or_empty()
+        .context("could not open index for worktree watcher")?;
+    let options = repository
+        .dirwalk_options()
+        .context("could not configure worktree directory walk")?;
+    let mut directories = WorktreeDirectories {
+        root: root.clone(),
+        paths: HashSet::from([root]),
+    };
+    repository
+        .dirwalk(&index, None::<&str>, &AtomicBool::default(), options, &mut directories)
+        .context("could not enumerate worktree directories")?;
+    Ok(directories.paths)
+}
+
 fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) -> bool {
     if let Some((marker, _)) = changes {
         if *marker == usize::MAX {
@@ -3738,7 +3871,7 @@ mod tests {
 
     #[test]
     fn filters_worktree_watch_events_and_invalidates_cached_status() {
-        use notify::event::{AccessKind, Flag, ModifyKind};
+        use notify::event::{AccessKind, CreateKind, Flag, ModifyKind, RemoveKind};
 
         let workdir = Path::new("/repo");
         let dot_git = workdir.join(".git");
@@ -3777,12 +3910,68 @@ mod tests {
         assert!(worktree_event_is_relevant(&rescan, workdir, &dot_git, &git_dir, &index));
         assert!(notification_is_actionable(&rescan));
 
+        let directories = HashSet::from([workdir.join("src")]);
+        assert!(!worktree_watch_set_may_change(
+            &modified(&workdir.join("src/lib.rs")),
+            &index,
+            &directories
+        ));
+        assert!(worktree_watch_set_may_change(&modified(&index), &index, &directories));
+        assert!(worktree_watch_set_may_change(
+            &modified(&workdir.join(".gitignore")),
+            &index,
+            &directories
+        ));
+        let create_directory =
+            notify::Event::new(notify::EventKind::Create(CreateKind::Folder)).add_path(workdir.join("new"));
+        assert!(worktree_watch_set_may_change(&create_directory, &index, &directories));
+        let remove_directory =
+            notify::Event::new(notify::EventKind::Remove(RemoveKind::Folder)).add_path(workdir.join("src"));
+        assert!(worktree_watch_set_may_change(&remove_directory, &index, &directories));
+        assert!(worktree_watch_set_may_change(&rescan, &index, &directories));
+
         let mut changes = Some((0, Changes::default()));
         assert!(invalidate_worktree_changes(&mut changes));
         assert_eq!(changes.as_ref().map(|(marker, _)| *marker), Some(usize::MAX));
         assert!(!invalidate_worktree_changes(&mut changes));
     }
 
+    #[test]
+    fn worktree_watch_directories_follow_git_ignores() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let root = fixture.path();
+        std::fs::create_dir_all(root.join("visible/nested"))?;
+        std::fs::create_dir_all(root.join("visible/ignored/nested"))?;
+        std::fs::create_dir_all(root.join("target/nested"))?;
+        std::fs::write(root.join(".gitignore"), "target/\nvisible/ignored/\n")?;
+
+        let repository = open_test_repository(root)?;
+        let directories = worktree_watch_directories(&repository)?;
+        let root = repository.workdir().expect("the fixture has a worktree");
+        assert!(directories.contains(root), "the worktree root is always watched");
+        assert!(
+            directories.contains(&root.join("visible")),
+            "visible directories are watched"
+        );
+        assert!(
+            directories.contains(&root.join("visible/nested")),
+            "visible descendants are watched"
+        );
+        assert!(
+            !directories.contains(&root.join("target")),
+            "ignored directories aren't watched"
+        );
+        assert!(
+            !directories.contains(&root.join("target/nested")),
+            "ignored descendants aren't traversed"
+        );
+        assert!(
+            !directories.contains(&root.join("visible/ignored")),
+            "nested ignore rules are honored"
+        );
+        Ok(())
+    }
+
     #[test]
     fn starts_worktree_watching_for_the_combined_view() {
         assert!(worktree_watcher_needed(false, Some(ChangesMode::Both)));

From 1de283e9158be2944239996e804b21b6a3fbb1cb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 13:16:28 +0200
Subject: [PATCH 040/282] fix: ignore incomplete Git lock notifications in tix

Ignore filesystem batches that only create, write, or remove Git lock files. Keep completed rename notifications actionable even when a backend reports only the lock path, and keep events naming the actual index, HEAD, or reference target, so atomic updates still refresh reliably without read-only Git commands causing needless history and status work.

Label an empty worktree changes block as clean in green so its otherwise empty status remains explicit.
---
 gix-tix/src/lib.rs | 33 +++++++++++++++++++++++++++------
 gix-tix/src/ui.rs  | 15 +++++++++++----
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b535d1b6cf2..ff996d684db 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -165,7 +165,18 @@ fn worktree_watch_set_may_change(event: &notify::Event, index: &Path, directorie
 }
 
 fn notification_is_actionable(event: &notify::Event) -> bool {
-    event.need_rescan() || !matches!(event.kind, notify::EventKind::Access(_))
+    event.need_rescan()
+        || (!matches!(event.kind, notify::EventKind::Access(_))
+            && (event.paths.is_empty()
+                || matches!(
+                    event.kind,
+                    notify::EventKind::Modify(notify::event::ModifyKind::Name(_))
+                )
+                || event.paths.iter().any(|path| {
+                    !path
+                        .file_name()
+                        .is_some_and(|name| name.as_encoded_bytes().ends_with(b".lock"))
+                })))
 }
 
 fn worktree_watcher_needed(repository_is_bare: bool, mode: Option<ChangesMode>) -> bool {
@@ -3014,19 +3025,22 @@ mod tests {
 
         let deadline = Instant::now() + Duration::from_secs(5);
         let mut paths = Vec::new();
+        let watched = repository.git_dir().join("refs/heads/watched");
         while Instant::now() < deadline {
             let event = watcher
                 .events
                 .recv_timeout(deadline.saturating_duration_since(Instant::now()))??;
-            assert!(notification_is_actionable(&event), "the reference update is actionable");
+            if !notification_is_actionable(&event) {
+                continue;
+            }
             paths.extend(event.paths);
-            if paths.iter().any(|path| path.ends_with("refs/heads/watched")) {
+            if watched.is_file() {
                 break;
             }
         }
         assert!(
-            paths.iter().any(|path| path.ends_with("refs/heads/watched")),
-            "the final loose reference is reported after its lock file: {paths:?}"
+            watched.is_file(),
+            "the completed loose-reference transaction is actionable: {paths:?}"
         );
         Ok(())
     }
@@ -3871,7 +3885,7 @@ mod tests {
 
     #[test]
     fn filters_worktree_watch_events_and_invalidates_cached_status() {
-        use notify::event::{AccessKind, CreateKind, Flag, ModifyKind, RemoveKind};
+        use notify::event::{AccessKind, CreateKind, Flag, ModifyKind, RemoveKind, RenameMode};
 
         let workdir = Path::new("/repo");
         let dot_git = workdir.join(".git");
@@ -3906,6 +3920,13 @@ mod tests {
             &access, workdir, &dot_git, &git_dir, &index
         ));
         assert!(!notification_is_actionable(&access));
+        let lock_only = modified(&git_dir.join("index.lock"));
+        assert!(!notification_is_actionable(&lock_only));
+        let completed_lock_rename = notify::Event::new(notify::EventKind::Modify(ModifyKind::Name(RenameMode::Any)))
+            .add_path(git_dir.join("index.lock"));
+        assert!(notification_is_actionable(&completed_lock_rename));
+        let completed_lock_update = lock_only.add_path(index.clone());
+        assert!(notification_is_actionable(&completed_lock_update));
         let rescan = notify::Event::new(notify::EventKind::Other).set_flag(Flag::Rescan);
         assert!(worktree_event_is_relevant(&rescan, workdir, &dot_git, &git_dir, &index));
         assert!(notification_is_actionable(&rescan));
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index fa9ae0bb544..784cd59bb3b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -914,6 +914,11 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
                 .map_or_else(|| "-------".into(), |row| row.id.to_hex_with_len(7).to_string());
             vec![Span::raw(format!("─ Tree {id} ── "))]
         }
+        ChangePane::Worktree if changes.paths.is_empty() => vec![
+            Span::raw("─ Worktree "),
+            Span::styled("clean", color(Color::Green)),
+            Span::raw(" ── "),
+        ],
         ChangePane::Worktree => vec![Span::raw("─ Worktree ── ")],
     };
     let counts: Vec<_> = match pane {
@@ -2976,10 +2981,12 @@ mod tests {
                 Some(&Changes::default()),
             );
         })?;
-        assert!(
-            (0..8).any(|y| rendered_line(&terminal, y).contains("Worktree ──")),
-            "an enabled clean worktree remains visible as an empty block"
-        );
+        let (clean_y, clean_header) = (0..8)
+            .map(|y| (y, rendered_line(&terminal, y)))
+            .find(|(_, line)| line.contains("Worktree clean"))
+            .expect("an enabled clean worktree remains visible as an empty block");
+        let clean_x = clean_header.find("clean").expect("clean label") as u16;
+        assert_eq!(terminal.backend().buffer()[(clean_x, clean_y)].fg, Color::Green);
         assert!(
             !(0..8).any(|y| rendered_line(&terminal, y).contains("+0") || rendered_line(&terminal, y).contains("-0")),
             "a clean worktree omits empty diff counts"

From 40433c8d7cc150948344b69471c89e6556f64fe0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 13:59:29 +0200
Subject: [PATCH 041/282] feat: open whole-commit diffs from tix history

Make Enter on a history row display the selected commit against its active comparison parent. Reuse the existing file-diff preparation so attributes, binary handling, external diff commands, configured pagers, and the built-in viewer behave consistently with changed-path diffs.

Prefix whole-commit output with the selected row identity and a Git-style diffstat in tree order. Show each changed path with its line total and a scaled additions/deletions graph, followed by the comparison parent, per-kind file totals, and aggregate line counts. Mirror the history mailmap and email display, and derive all line counts from the diff already being prepared.

Show the summary and internal patch before per-path external diff drivers. Allow Enter to continue into those drivers while q or Escape returns directly to history.
---
 gix-tix/src/app.rs |   8 +-
 gix-tix/src/lib.rs | 336 +++++++++++++++++++++++++++++++++++++++------
 gix-tix/src/ui.rs  | 270 +++++++++++++++++++++++++++++++-----
 3 files changed, 535 insertions(+), 79 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 44a454e8856..1beb1baa1bb 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -300,6 +300,7 @@ pub(crate) enum Effect {
     CopyAuthor(&'static Author),
     Reload(bool),
     OpenDiff(ChangePane, usize),
+    OpenCommitDiff(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -746,6 +747,11 @@ impl App {
                 changes.error = None;
                 return vec![Effect::OpenDiff(pane, changes.selected)];
             }
+            Action::OpenDiff => {
+                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                    return vec![Effect::OpenCommitDiff(id)];
+                }
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -2211,7 +2217,7 @@ mod tests {
         app.update(Action::ToggleChanges);
         app.update(Action::ToggleChanges);
         assert_eq!(app.changes_focus, None, "closing the panel returns focus to history");
-        assert!(app.update(Action::OpenDiff).is_empty());
+        assert_eq!(app.update(Action::OpenDiff), vec![Effect::OpenCommitDiff(id(1))]);
         assert_eq!(app.tree_changes.selected, 0);
         assert_eq!(app.tree_changes.offset, 0);
         assert_eq!(app.tree_changes.horizontal_offset, 0);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index ff996d684db..46d32889513 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -622,8 +622,19 @@ enum FileDiff {
     BuiltIn(BuiltInDiff),
 }
 
+enum PreparedFileDiff {
+    External(gix::diff::blob::platform::prepare_diff_command::Command, LineCounts),
+    BuiltIn(BuiltInDiff, LineCounts),
+}
+
+struct CommitDiff {
+    external: Vec<gix::diff::blob::platform::prepare_diff_command::Command>,
+    internal: FileDiff,
+}
+
 pub(crate) struct BuiltInDiff {
     title: BString,
+    summary: Option<Vec<Line<'static>>>,
     lines: Vec<BString>,
     max_width: usize,
 }
@@ -637,12 +648,36 @@ impl BuiltInDiff {
             .unwrap_or_default();
         BuiltInDiff {
             title,
+            summary: None,
             lines,
             max_width,
         }
     }
 
+    fn with_summary(mut self, summary: Vec<Line<'static>>) -> Self {
+        self.max_width = self
+            .max_width
+            .max(summary.iter().map(Line::width).max().unwrap_or_default());
+        self.summary = Some(summary);
+        self
+    }
+
+    fn display_line_count(&self) -> usize {
+        self.lines.len() + self.summary.as_ref().map_or(0, |summary| summary.len() + 1)
+    }
+
     fn write_to(&self, mut out: impl Write) -> io::Result<()> {
+        if let Some(summary) = &self.summary {
+            out.write_all(&self.title)?;
+            out.write_all(b"\n")?;
+            for line in summary {
+                for span in &line.spans {
+                    out.write_all(span.content.as_bytes())?;
+                }
+                out.write_all(b"\n")?;
+            }
+            out.write_all(b"\n")?;
+        }
         for line in &self.lines {
             out.write_all(line)?;
             out.write_all(b"\n")?;
@@ -1480,21 +1515,33 @@ fn event_loop(
                         .and_then(|(change, path)| {
                             prepare_file_diff(&repository_path, repository_is_bare, change, path)
                         })
-                        .and_then(|diff| match diff {
-                            FileDiff::External(command) => {
-                                run_external_diff(terminal, command, enhanced_keyboard).map(|()| false)
-                            }
-                            FileDiff::Pager { command, diff } => {
-                                run_pager(terminal, command, &diff, enhanced_keyboard).map(|()| false)
-                            }
-                            FileDiff::BuiltIn(diff) => show_builtin_diff(terminal, &diff),
-                        });
+                        .and_then(|diff| show_file_diff(terminal, diff, enhanced_keyboard));
                     match result {
                         Ok(true) => app.focus_history(),
                         Err(err) => app.changes_mut(pane).error = Some(format!("{err:#}")),
                         Ok(false) => {}
                     }
                 }
+                Effect::OpenCommitDiff(id) => {
+                    let title = app
+                        .rows
+                        .iter()
+                        .find(|row| row.id == id)
+                        .map(|row| {
+                            ui::commit_diff_title(row, app.title(row), &mailmap, app.use_mailmap, app.show_emails)
+                        })
+                        .context("selected commit is no longer available")?;
+                    let cached = tree_changes.as_ref().filter(|(cached_id, _, _)| *cached_id == id);
+                    let parent = cached.map_or(0, |(_, parent, _)| *parent);
+                    let cached = cached.map(|(_, _, changes)| changes);
+                    let result = prepare_commit_diff(&repository_path, repository_is_bare, id, parent, cached, title)
+                        .and_then(|diff| show_commit_diff(terminal, diff, enhanced_keyboard));
+                    match result {
+                        Ok(true) => app.focus_history(),
+                        Err(err) => app.notice = Some(format!("diff: {err:#}")),
+                        Ok(false) => {}
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -2105,11 +2152,78 @@ fn prepare_file_diff(repository_path: &Path, bare: bool, change: &FileChange, pa
     prepare_file_diff_with_repository(&repository, change, path)
 }
 
+fn prepare_commit_diff(
+    repository_path: &Path,
+    bare: bool,
+    id: gix::ObjectId,
+    requested_parent: usize,
+    cached: Option<&Changes>,
+    title: BString,
+) -> Result<CommitDiff> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository for commit diff")?;
+    repository.object_cache_size(OBJECT_CACHE_SIZE);
+    prepare_commit_diff_with_repository(&repository, id, requested_parent, cached, title)
+}
+
+fn prepare_commit_diff_with_repository(
+    repository: &gix::Repository,
+    id: gix::ObjectId,
+    requested_parent: usize,
+    cached: Option<&Changes>,
+    title: BString,
+) -> Result<CommitDiff> {
+    let loaded = cached
+        .is_none()
+        .then(|| load_changes_without_lines(repository, id, requested_parent))
+        .transpose()?;
+    let changes = cached
+        .or(loaded.as_ref())
+        .context("commit diff changes were neither cached nor loaded")?;
+    let mut external = Vec::new();
+    let mut lines = Vec::new();
+    let mut lines_added = 0u64;
+    let mut lines_removed = 0u64;
+    let mut line_counts = Vec::with_capacity(changes.paths.len());
+    for (change, path) in changes.diffs.iter().zip(&changes.paths) {
+        let counts = match prepare_file_diff_content(repository, change, path, true)? {
+            PreparedFileDiff::External(command, counts) => {
+                external.push(command);
+                counts
+            }
+            PreparedFileDiff::BuiltIn(diff, counts) => {
+                lines.extend(diff.lines);
+                counts
+            }
+        };
+        if let Some((added, removed)) = counts {
+            lines_added += u64::from(added);
+            lines_removed += u64::from(removed);
+        }
+        line_counts.push(counts);
+    }
+    let summary = ui::commit_diff_summary(changes, &line_counts, lines_added, lines_removed);
+    let internal = prepare_pager(repository, BuiltInDiff::new(title, lines).with_summary(summary))?;
+    Ok(CommitDiff { external, internal })
+}
+
 fn prepare_file_diff_with_repository(
     repository: &gix::Repository,
     change: &FileChange,
     path: &PathChange,
 ) -> Result<FileDiff> {
+    match prepare_file_diff_content(repository, change, path, false)? {
+        PreparedFileDiff::External(command, _) => Ok(FileDiff::External(command)),
+        PreparedFileDiff::BuiltIn(diff, _) => prepare_pager(repository, diff),
+    }
+}
+
+fn prepare_file_diff_content(
+    repository: &gix::Repository,
+    change: &FileChange,
+    path: &PathChange,
+    count_lines: bool,
+) -> Result<PreparedFileDiff> {
     if let FileChange::Unavailable(message) = change {
         anyhow::bail!("{message}");
     }
@@ -2149,15 +2263,33 @@ fn prepare_file_diff_with_repository(
     let prepared = resources.prepare_diff().context("could not prepare selected diff")?;
     match prepared.operation {
         gix::diff::blob::platform::prepare_diff::Operation::ExternalCommand { command } => {
+            let counts = count_lines
+                .then(|| {
+                    let input = prepared.interned_input();
+                    let diff = gix::diff::blob::diff_with_slider_heuristics(
+                        repository.diff_algorithm().context("could not obtain diff algorithm")?,
+                        &input,
+                    );
+                    Ok::<_, anyhow::Error>((diff.count_additions(), diff.count_removals()))
+                })
+                .transpose()?;
             let command = command.to_owned();
             prepare_external_diff(repository, &resources, command)
+                .map(|command| PreparedFileDiff::External(command, counts))
         }
         gix::diff::blob::platform::prepare_diff::Operation::InternalDiff { algorithm } => {
             if let Some(command) = global_command {
-                return prepare_external_diff(repository, &resources, command);
+                let counts = count_lines.then(|| {
+                    let input = prepared.interned_input();
+                    let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &input);
+                    (diff.count_additions(), diff.count_removals())
+                });
+                return prepare_external_diff(repository, &resources, command)
+                    .map(|command| PreparedFileDiff::External(command, counts));
             }
             let input = prepared.interned_input();
             let diff = gix::diff::blob::diff_with_slider_heuristics(algorithm, &input);
+            let counts = Some((diff.count_additions(), diff.count_removals()));
             let rendered = gix::diff::blob::UnifiedDiff::new(
                 &diff,
                 &input,
@@ -2166,10 +2298,13 @@ fn prepare_file_diff_with_repository(
             )
             .consume()
             .context("could not render selected diff")?;
-            prepare_pager(repository, built_in_diff(path, change, Some(rendered), false))
+            Ok(PreparedFileDiff::BuiltIn(
+                built_in_diff(path, change, Some(rendered), false),
+                counts,
+            ))
         }
         gix::diff::blob::platform::prepare_diff::Operation::SourceOrDestinationIsBinary => {
-            prepare_pager(repository, built_in_diff(path, change, None, true))
+            Ok(PreparedFileDiff::BuiltIn(built_in_diff(path, change, None, true), None))
         }
     }
 }
@@ -2200,19 +2335,17 @@ fn prepare_external_diff(
     repository: &gix::Repository,
     resources: &gix::diff::blob::Platform,
     command: BString,
-) -> Result<FileDiff> {
-    Ok(FileDiff::External(
-        resources
-            .prepare_diff_command(
-                command,
-                repository
-                    .command_context()
-                    .context("could not prepare external diff environment")?,
-                0,
-                1,
-            )
-            .context("could not prepare external diff command")?,
-    ))
+) -> Result<gix::diff::blob::platform::prepare_diff_command::Command> {
+    resources
+        .prepare_diff_command(
+            command,
+            repository
+                .command_context()
+                .context("could not prepare external diff environment")?,
+            0,
+            1,
+        )
+        .context("could not prepare external diff command")
 }
 
 fn built_in_diff(path: &PathChange, change: &FileChange, rendered: Option<BString>, binary: bool) -> BuiltInDiff {
@@ -2280,6 +2413,28 @@ fn built_in_diff(path: &PathChange, change: &FileChange, rendered: Option<BStrin
     )
 }
 
+fn show_file_diff(terminal: &mut ratatui::DefaultTerminal, diff: FileDiff, enhanced_keyboard: bool) -> Result<bool> {
+    match diff {
+        FileDiff::External(command) => run_external_diff(terminal, command, enhanced_keyboard).map(|()| false),
+        FileDiff::Pager { command, diff } => run_pager(terminal, command, &diff, enhanced_keyboard).map(|()| false),
+        FileDiff::BuiltIn(diff) => show_builtin_diff(terminal, &diff),
+    }
+}
+
+fn show_commit_diff(
+    terminal: &mut ratatui::DefaultTerminal,
+    diff: CommitDiff,
+    enhanced_keyboard: bool,
+) -> Result<bool> {
+    if show_file_diff(terminal, diff.internal, enhanced_keyboard)? {
+        return Ok(true);
+    }
+    for command in diff.external {
+        run_external_diff(terminal, command, enhanced_keyboard)?;
+    }
+    Ok(false)
+}
+
 fn run_external_diff(
     terminal: &mut ratatui::DefaultTerminal,
     mut command: gix::diff::blob::platform::prepare_diff_command::Command,
@@ -2396,7 +2551,7 @@ fn show_builtin_diff(terminal: &mut ratatui::DefaultTerminal, diff: &BuiltInDiff
     loop {
         let size = terminal.size().context("could not determine diff viewport")?;
         let page = usize::from(size.height.saturating_sub(2)).max(1);
-        let max = diff.lines.len().saturating_sub(page);
+        let max = diff.display_line_count().saturating_sub(page);
         let horizontal_page = usize::from(size.width).max(1);
         let horizontal_max = diff.max_width.saturating_sub(horizontal_page);
         offset = offset.min(max);
@@ -2448,6 +2603,24 @@ fn load_changes(
     id: gix::ObjectId,
     requested_parent: usize,
     line_diff_pool: &mut LineDiffPool,
+) -> Result<Changes> {
+    let mut out = load_changes_without_lines(repository, id, requested_parent)?;
+    let diffs = std::mem::take(&mut out.diffs);
+    for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
+        path.lines = lines;
+        if let Some((insertions, removals)) = lines {
+            out.lines_added += u64::from(insertions);
+            out.lines_removed += u64::from(removals);
+        }
+        out.diffs.push(change);
+    }
+    Ok(out)
+}
+
+fn load_changes_without_lines(
+    repository: &gix::Repository,
+    id: gix::ObjectId,
+    requested_parent: usize,
 ) -> Result<Changes> {
     let commit = repository.find_commit(id).context("could not load changed paths")?;
     let parents: Vec<_> = commit.parent_ids().collect();
@@ -2477,7 +2650,6 @@ fn load_changes(
         }),
         ..Changes::default()
     };
-    let mut diffs = Vec::new();
     for change in changes {
         use gix::object::tree::diff::ChangeDetached;
         let (kind, source, path, is_tree) = match &change {
@@ -2526,15 +2698,7 @@ fn load_changes(
             path,
             lines: None,
         });
-        diffs.push(FileChange::Tree(change));
-    }
-    for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
-        path.lines = lines;
-        if let Some((insertions, removals)) = lines {
-            out.lines_added += u64::from(insertions);
-            out.lines_removed += u64::from(removals);
-        }
-        out.diffs.push(change);
+        out.diffs.push(FileChange::Tree(change));
     }
     Ok(out)
 }
@@ -3345,12 +3509,8 @@ mod tests {
             );
         }
 
-        let topic = load_changes(
-            &repository,
-            repository.rev_parse_single("topic")?.detach(),
-            0,
-            line_diff_pool,
-        )?;
+        let topic_id = repository.rev_parse_single("topic")?.detach();
+        let topic = load_changes(&repository, topic_id, 0, line_diff_pool)?;
         assert_eq!(
             topic.paths,
             [
@@ -3372,6 +3532,85 @@ mod tests {
             "parallel line diffs retain tree-diff order and status"
         );
         assert_eq!((topic.lines_added, topic.lines_removed), (2, 0));
+        let title: BString = format!("{} author topic", topic_id.to_hex_with_len(7)).into();
+        let commit_diff = prepare_commit_diff_with_repository(&repository, topic_id, 0, None, title.clone())?;
+        assert!(commit_diff.external.is_empty());
+        let FileDiff::BuiltIn(diff) = commit_diff.internal else {
+            unreachable!("an isolated repository uses the built-in commit viewer")
+        };
+        assert_eq!(diff.title, title);
+        let summary = diff
+            .summary
+            .as_ref()
+            .expect("whole-commit diffs have a summary")
+            .last()
+            .expect("the aggregate follows path statistics")
+            .spans
+            .iter()
+            .map(|span| span.content.as_ref())
+            .collect::<String>();
+        assert!(
+            summary.contains("A 2 · +2"),
+            "the existing diff pass supplies aggregate counts"
+        );
+        let topic_position = diff
+            .lines
+            .iter()
+            .position(|line| line == "+++ b/topic")
+            .expect("the first path is present");
+        let extra_position = diff
+            .lines
+            .iter()
+            .position(|line| line == "+++ b/topic-extra")
+            .expect("the second path is present");
+        assert!(
+            topic_position < extra_position,
+            "whole-commit patches retain tree-diff order"
+        );
+        let empty =
+            prepare_commit_diff_with_repository(&repository, topic_id, 0, Some(&Changes::default()), title.clone())?;
+        let FileDiff::BuiltIn(empty) = empty.internal else {
+            unreachable!("empty commits retain the built-in viewer")
+        };
+        assert!(empty.lines.is_empty(), "an empty commit opens an empty patch");
+        assert!(
+            empty
+                .summary
+                .expect("empty commits have a summary")
+                .iter()
+                .flat_map(|line| &line.spans)
+                .any(|span| span.content.contains("No changes")),
+            "empty commits explain the absent patch"
+        );
+
+        let pager_diff =
+            prepare_commit_diff_with_repository(&pager_repository, topic_id, 0, Some(&topic), title.clone())?;
+        assert!(pager_diff.external.is_empty());
+        let FileDiff::Pager { diff, .. } = pager_diff.internal else {
+            unreachable!("one configured pager receives the aggregate commit patch")
+        };
+        let mut streamed = Vec::new();
+        diff.write_to(&mut streamed)?;
+        assert!(
+            streamed.starts_with(
+                format!("{title}\n topic       | 1 +\n topic-extra | 1 +\nroot · A 2 · +2 \n\n").as_bytes()
+            ),
+            "the pager receives path statistics and the aggregate before the patch"
+        );
+        let external_diff =
+            prepare_commit_diff_with_repository(&external_repository, topic_id, 0, Some(&topic), title.clone())?;
+        assert_eq!(
+            external_diff.external.len(),
+            2,
+            "external diff commands remain per-path"
+        );
+        let FileDiff::BuiltIn(summary) = external_diff.internal else {
+            unreachable!("an all-external commit still shows its summary")
+        };
+        assert!(
+            summary.lines.is_empty(),
+            "external patches aren't duplicated internally"
+        );
 
         let merge = repository.rev_parse_single("main")?.detach();
         let first_parent = load_changes(&repository, merge, 0, line_diff_pool)?;
@@ -3415,6 +3654,19 @@ mod tests {
             }],
             "later parents can be selected independently"
         );
+        let second_parent_diff =
+            prepare_commit_diff_with_repository(&repository, merge, 1, Some(&second_parent), "merge title".into())?;
+        let FileDiff::BuiltIn(diff) = second_parent_diff.internal else {
+            unreachable!("an isolated repository uses the built-in commit viewer")
+        };
+        assert!(
+            diff.summary
+                .expect("merge diff has a summary")
+                .iter()
+                .flat_map(|line| &line.spans)
+                .any(|span| span.content.contains("vs parent 2/2")),
+            "the commit viewer identifies the selected merge parent"
+        );
         assert_eq!(
             load_changes(&repository, merge, 2, line_diff_pool)?.parent,
             first_parent.parent,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 784cd59bb3b..6e365fe248d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -143,7 +143,7 @@ pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset:
         Paragraph::new(diff.title.to_str_lossy()).style(Style::default().add_modifier(Modifier::BOLD)),
         header,
     );
-    let lines = diff
+    let mut lines = diff
         .lines
         .iter()
         .map(|line| {
@@ -161,6 +161,9 @@ pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset:
             Line::styled(line.to_str_lossy(), style)
         })
         .collect::<Vec<_>>();
+    if let Some(summary) = &diff.summary {
+        lines.splice(0..0, summary.iter().cloned().chain(std::iter::once(Line::default())));
+    }
     frame.render_widget(
         Paragraph::new(Text::from(lines)).scroll((
             u16::try_from(offset).unwrap_or(u16::MAX),
@@ -602,6 +605,9 @@ pub(crate) fn draw_with_worktree(
         "{}{status} · ↑↓/jk move · h/l pan",
         history_position(app)
     ))];
+    if app.changes_focus.is_none() {
+        footer_spans.push(Span::raw(" · Enter diff"));
+    }
     if app.tree_changes_visible || app.worktree_changes_visible {
         footer_spans.push(match app.focus_feedback.take() {
             Some(destination) => Span::raw(format!(" · Tab → {destination}")),
@@ -905,6 +911,111 @@ fn path_change_color(change: &crate::app::PathChange) -> Color {
     }
 }
 
+pub(crate) fn commit_diff_title(
+    row: &CommitRow,
+    title: &BStr,
+    mailmap: &gix::mailmap::Snapshot,
+    use_mailmap: bool,
+    show_emails: bool,
+) -> BString {
+    let author = author_label(row.author, mailmap, use_mailmap, show_emails && !row.author.is_bot());
+    let author = if row.author.is_bot() {
+        format!("[{author}]")
+    } else {
+        author
+    };
+    let mut out: BString = format!("{} {author} ", row.id.to_hex_with_len(7)).into();
+    out.extend_from_slice(title);
+    out
+}
+
+pub(crate) fn commit_diff_summary(
+    changes: &Changes,
+    line_counts: &[Option<(u32, u32)>],
+    lines_added: u64,
+    lines_removed: u64,
+) -> Vec<Line<'static>> {
+    let paths = changes
+        .paths
+        .iter()
+        .map(|change| match &change.source {
+            Some(source) => format!("{} -> {}", source.to_str_lossy(), change.path.to_str_lossy()),
+            None => change.path.to_str_lossy().into_owned(),
+        })
+        .collect::<Vec<_>>();
+    let path_width = paths
+        .iter()
+        .map(|path| Line::from(path.as_str()).width())
+        .max()
+        .unwrap_or_default();
+    let count_width = line_counts
+        .iter()
+        .map(|counts| {
+            counts.map_or(3, |(added, removed)| {
+                (u64::from(added) + u64::from(removed)).to_string().len()
+            })
+        })
+        .max()
+        .unwrap_or_default();
+    let max_changes = line_counts
+        .iter()
+        .flatten()
+        .map(|(added, removed)| u64::from(*added) + u64::from(*removed))
+        .max()
+        .unwrap_or_default();
+    let graph_width = max_changes.min(40);
+    let mut lines = paths
+        .into_iter()
+        .zip(line_counts)
+        .map(|(path, counts)| {
+            let padding = " ".repeat(path_width.saturating_sub(Line::from(path.as_str()).width()));
+            let mut spans = vec![Span::raw(format!(" {path}{padding} | "))];
+            match counts {
+                Some((added, removed)) => {
+                    let total = u64::from(*added) + u64::from(*removed);
+                    spans.push(Span::raw(format!("{total:>count_width$} ")));
+                    let scaled = |count: u32| {
+                        (u64::from(count) * graph_width / max_changes.max(1)).max(u64::from(count > 0)) as usize
+                    };
+                    spans.push(Span::styled("+".repeat(scaled(*added)), color(Color::Green)));
+                    spans.push(Span::styled("-".repeat(scaled(*removed)), color(Color::LightRed)));
+                }
+                None => spans.push(Span::raw(format!("{:>count_width$}", "Bin"))),
+            }
+            Line::from(spans)
+        })
+        .collect::<Vec<_>>();
+    let mut spans = match changes.parent {
+        Some(parent) if parent.total > 1 => vec![Span::styled(
+            format!(
+                "vs parent {}/{} {} · ",
+                parent.index + 1,
+                parent.total,
+                parent.id.to_hex_with_len(7)
+            ),
+            color(COMPARED_PARENT_COLOR),
+        )],
+        Some(parent) => vec![Span::styled(
+            format!("vs parent {} · ", parent.id.to_hex_with_len(7)),
+            color(COMPARED_PARENT_COLOR),
+        )],
+        None => vec![Span::styled("root · ", color(COMPARED_PARENT_COLOR))],
+    };
+    if changes.paths.is_empty() {
+        spans.push(Span::styled("No changes", Style::default().add_modifier(Modifier::DIM)));
+    } else {
+        append_change_aggregate(
+            &mut spans,
+            tree_change_counts(changes),
+            changes.paths.len(),
+            lines_added,
+            lines_removed,
+        );
+    }
+    lines.push(Line::from(spans));
+    lines
+}
+
 fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'static> {
     let mut spans = match pane {
         ChangePane::Tree => {
@@ -922,24 +1033,7 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
         ChangePane::Worktree => vec![Span::raw("─ Worktree ── ")],
     };
     let counts: Vec<_> = match pane {
-        ChangePane::Tree => {
-            let mut counts = Vec::new();
-            for kind in [
-                ChangeKind::Added,
-                ChangeKind::Modified,
-                ChangeKind::Deleted,
-                ChangeKind::Renamed,
-                ChangeKind::Copied,
-                ChangeKind::TypeChanged,
-            ] {
-                let count = changes.paths.iter().filter(|change| change.kind == kind).count();
-                if count == 0 {
-                    continue;
-                }
-                counts.push((kind.letter().to_string(), count, change_color(kind)));
-            }
-            counts
-        }
+        ChangePane::Tree => tree_change_counts(changes),
         ChangePane::Worktree => {
             let staged = changes
                 .paths
@@ -956,8 +1050,42 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
             .collect()
         }
     };
+    append_change_aggregate(
+        &mut spans,
+        counts,
+        changes.paths.len(),
+        changes.lines_added,
+        changes.lines_removed,
+    );
+    Line::from(spans)
+}
+
+fn tree_change_counts(changes: &Changes) -> Vec<(String, usize, Color)> {
+    [
+        ChangeKind::Added,
+        ChangeKind::Modified,
+        ChangeKind::Deleted,
+        ChangeKind::Renamed,
+        ChangeKind::Copied,
+        ChangeKind::TypeChanged,
+    ]
+    .into_iter()
+    .filter_map(|kind| {
+        let count = changes.paths.iter().filter(|change| change.kind == kind).count();
+        (count > 0).then(|| (kind.letter().to_string(), count, change_color(kind)))
+    })
+    .collect()
+}
+
+fn append_change_aggregate(
+    spans: &mut Vec<Span<'static>>,
+    counts: Vec<(String, usize, Color)>,
+    total: usize,
+    lines_added: u64,
+    lines_removed: u64,
+) {
     let has_counts = !counts.is_empty();
-    let show_total = has_counts && (counts.len() != 1 || counts[0].1 != changes.paths.len());
+    let show_total = has_counts && (counts.len() != 1 || counts[0].1 != total);
     for (index, (label, count, count_color)) in counts.into_iter().enumerate() {
         if index > 0 {
             spans.push(Span::raw(" + "));
@@ -965,29 +1093,21 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
         spans.push(Span::styled(format!("{label} {count}"), color(count_color)));
     }
     if show_total {
-        spans.push(Span::raw(format!(
-            "{}= {}",
-            if has_counts { " " } else { "" },
-            changes.paths.len()
-        )));
+        spans.push(Span::raw(format!("{}= {}", if has_counts { " " } else { "" }, total)));
     }
-    if changes.lines_added > 0 || changes.lines_removed > 0 {
+    if lines_added > 0 || lines_removed > 0 {
         spans.push(Span::raw(" · "));
-        if changes.lines_added > 0 {
-            spans.push(Span::styled(format!("+{}", changes.lines_added), color(Color::Green)));
+        if lines_added > 0 {
+            spans.push(Span::styled(format!("+{lines_added}"), color(Color::Green)));
         }
-        if changes.lines_removed > 0 {
-            if changes.lines_added > 0 {
+        if lines_removed > 0 {
+            if lines_added > 0 {
                 spans.push(Span::raw(" "));
             }
-            spans.push(Span::styled(
-                format!("-{}", changes.lines_removed),
-                color(Color::LightRed),
-            ));
+            spans.push(Span::styled(format!("-{lines_removed}"), color(Color::LightRed)));
         }
         spans.push(Span::raw(" "));
     }
-    Line::from(spans)
 }
 
 fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, notes: &[BString], offset: usize) -> usize {
@@ -1649,6 +1769,83 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renders_and_streams_compact_commit_diff_summaries() -> Result<(), Box<dyn std::error::Error>> {
+        let row = Commit {
+            id: gix::ObjectId::Sha1([1; 20]),
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: 0..0,
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mailmap =
+            gix::mailmap::Snapshot::from_bytes(b"mapped author <mapped@example.com> author <author@example.com>\n");
+        let title = commit_diff_title(&row, b"subject".as_bstr(), &mailmap, true, false);
+        assert_eq!(title, "0101010 mapped author subject");
+        assert_eq!(
+            commit_diff_title(&row, b"subject".as_bstr(), &mailmap, true, true),
+            "0101010 mapped author <mapped@example.com> subject"
+        );
+        let changes = Changes {
+            paths: vec![
+                crate::app::PathChange {
+                    kind: ChangeKind::Added,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: "new".into(),
+                    lines: None,
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Modified,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: "old".into(),
+                    lines: None,
+                },
+            ],
+            ..Changes::default()
+        };
+        let diff = BuiltInDiff::new(
+            title.clone(),
+            ["--- a/old", "+++ b/old"].into_iter().map(Into::into).collect(),
+        )
+        .with_summary(commit_diff_summary(&changes, &[Some((2, 0)), Some((1, 1))], 3, 1));
+        let mut terminal = Terminal::new(TestBackend::new(64, 9))?;
+
+        terminal.draw(|frame| draw_file_diff(frame, &diff, 0, 0))?;
+
+        assert_eq!(rendered_line(&terminal, 0).trim(), title);
+        assert_eq!(rendered_line(&terminal, 1).trim(), "new | 2 ++");
+        assert_eq!(rendered_line(&terminal, 2).trim(), "old | 2 +-");
+        let summary = "root · A 1 + M 1 = 2 · +3 -1";
+        assert_eq!(rendered_line(&terminal, 3).trim(), summary);
+        let buffer = terminal.backend().buffer();
+        let summary_x = |needle| {
+            summary[..summary.find(needle).expect("summary term is present")]
+                .chars()
+                .count() as u16
+        };
+        assert_eq!(buffer[(0, 3)].fg, COMPARED_PARENT_COLOR);
+        assert_eq!(buffer[(summary_x("A 1"), 3)].fg, Color::Green);
+        assert_eq!(buffer[(summary_x("-1"), 3)].fg, Color::LightRed);
+        assert_eq!(buffer[(9, 1)].fg, Color::Green);
+        assert_eq!(buffer[(10, 2)].fg, Color::LightRed);
+        assert_eq!(rendered_line(&terminal, 4).trim(), "");
+        assert_eq!(rendered_line(&terminal, 5).trim(), "--- a/old");
+
+        let mut streamed = Vec::new();
+        diff.write_to(&mut streamed)?;
+        assert_eq!(
+            streamed,
+            b"0101010 mapped author subject\n new | 2 ++\n old | 2 +-\nroot \xc2\xb7 A 1 + M 1 = 2 \xc2\xb7 +3 -1 \n\n--- a/old\n+++ b/old\n"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_grouped_attributions_and_bot_names() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
@@ -1875,7 +2072,8 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · ↑↓/jk move · h/l pan · [ align · o commit · c changes · v view · y copy · q quit";
+        let footer_text =
+            "#1 · ↑↓/jk move · h/l pan · Enter diff · [ align · o commit · c changes · v view · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {

From a428db4bfa54b72eefebd88977d97eff343a2e9b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 14:16:36 +0200
Subject: [PATCH 042/282] feat: highlight unseen filesystem redraws in tix

Replace the main status separators with prominent orange commit-style discs when a filesystem-attributed frame is presented while the terminal is unfocused. Keep the indication across later redraws and restore the normal separators immediately when terminal focus returns.
---
 gix-tix/src/app.rs     |  2 ++
 gix-tix/src/lib.rs     | 27 ++++++++++++++++++++++++-
 gix-tix/src/logging.rs |  7 +++++++
 gix-tix/src/ui.rs      | 45 ++++++++++++++++++++++++++++++++++++++++++
 4 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 1beb1baa1bb..838a6ec2b53 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -355,6 +355,7 @@ pub(crate) struct App {
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
     pub(crate) notice: Option<String>,
+    pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
@@ -420,6 +421,7 @@ impl App {
             copy_feedback: None,
             focus_feedback: None,
             notice: None,
+            unseen_filesystem_redraw: false,
             history_display_expanded: false,
             estimated_lane_width: 0,
             horizontal_offset: 0,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 46d32889513..35e13f86c44 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -179,6 +179,10 @@ fn notification_is_actionable(event: &notify::Event) -> bool {
                 })))
 }
 
+fn unseen_filesystem_redraw(current: bool, focused: bool, filesystem_frame: bool) -> bool {
+    !focused && (current || filesystem_frame)
+}
+
 fn worktree_watcher_needed(repository_is_bare: bool, mode: Option<ChangesMode>) -> bool {
     !repository_is_bare && mode == Some(ChangesMode::Both)
 }
@@ -840,6 +844,7 @@ fn event_loop(
     let mut decorations = Decorations::new();
     let mut motion = MotionState::default();
     let mut filesystem_responses = logging::FilesystemResponses::default();
+    let mut focused = true;
     draw(
         terminal,
         &mut app,
@@ -854,13 +859,13 @@ fn event_loop(
         &mut selection_relation,
         &mut line_diff_pool,
         &mut motion,
+        focused,
         &mut filesystem_responses,
     )?;
     let mut last_draw = Instant::now();
     let mut dirty = false;
     let mut urgent = false;
     let mut history_finished = false;
-    let mut focused = true;
     let mut repeat_deadline: Option<Instant> = None;
     let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
@@ -1225,6 +1230,7 @@ fn event_loop(
                 &mut selection_relation,
                 &mut line_diff_pool,
                 &mut motion,
+                focused,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1286,6 +1292,7 @@ fn event_loop(
                 &mut selection_relation,
                 &mut line_diff_pool,
                 &mut motion,
+                focused,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1372,6 +1379,10 @@ fn event_loop(
             }
             TerminalEvent::FocusGained => {
                 focused = true;
+                if app.unseen_filesystem_redraw {
+                    dirty = true;
+                    urgent = true;
+                }
                 continue;
             }
             TerminalEvent::Resize(_, _) => {
@@ -1800,12 +1811,18 @@ fn draw(
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
     motion: &mut MotionState,
+    focused: bool,
     filesystem_responses: &mut logging::FilesystemResponses,
 ) -> Result<()> {
     let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
         return Ok(());
     }
+    app.unseen_filesystem_redraw = unseen_filesystem_redraw(
+        app.unseen_filesystem_redraw,
+        focused,
+        filesystem_responses.has_queued_frame(),
+    );
     app.viewport_rows = app.viewport_rows.min(render_rows.max(1));
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
@@ -3175,6 +3192,14 @@ fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::
 mod tests {
     use super::*;
 
+    #[test]
+    fn retains_unseen_filesystem_redraws_until_focus_returns() {
+        assert!(!unseen_filesystem_redraw(false, false, false));
+        assert!(unseen_filesystem_redraw(false, false, true));
+        assert!(unseen_filesystem_redraw(true, false, false));
+        assert!(!unseen_filesystem_redraw(true, true, true));
+    }
+
     #[test]
     fn reference_watcher_observes_new_loose_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index afae4c5c11c..a591bf44d24 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -198,6 +198,10 @@ impl FilesystemResponses {
         }
     }
 
+    pub(crate) fn has_queued_frame(&self) -> bool {
+        !self.frame_causes.is_empty()
+    }
+
     pub(crate) fn keep_after_frame(&mut self, ids: &[u64]) {
         self.finish_after_frame.retain(|(id, _)| !ids.contains(id));
     }
@@ -511,8 +515,10 @@ mod tests {
         let common = Path::new("/repo/.git");
         let workdir = Path::new("/repo");
         let mut responses = FilesystemResponses::default();
+        assert!(!responses.has_queued_frame());
         let worktree = responses.observe_worktree(&modified(workdir.join("file")), workdir, &common.join("index"));
         responses.worktree_due(true);
+        assert!(responses.has_queued_frame());
 
         let references = responses.observe_references(&modified(common.join("HEAD")), common, common);
         responses.references_due();
@@ -529,6 +535,7 @@ mod tests {
             "one frame retains both filesystem causes"
         );
         responses.frame_presented();
+        assert!(!responses.has_queued_frame());
         assert!(
             responses.responses.is_empty(),
             "both responses finish after the shared frame"
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 6e365fe248d..0b8e34c8b97 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -18,6 +18,7 @@ use crate::{
 
 const COMPARED_PARENT_COLOR: Color = Color::Cyan;
 const COMMIT_PANE_WIDTH: u16 = 84;
+const FILESYSTEM_NOTIFICATION_COLOR: Color = Color::Rgb(255, 165, 0);
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
@@ -687,6 +688,9 @@ pub(crate) fn draw_with_worktree(
     if let Some(notice) = &app.notice {
         footer_spans = vec![Span::raw(notice)];
     }
+    if app.unseen_filesystem_redraw {
+        footer_spans = notification_discs(footer_spans);
+    }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
     FrameLayout {
         history: body,
@@ -1266,6 +1270,22 @@ fn toggle(label: &'static str, enabled: bool) -> Span<'static> {
     )
 }
 
+fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
+    let mut out = Vec::with_capacity(spans.len());
+    for span in spans {
+        let style = span.style;
+        for (index, text) in span.content.split('·').enumerate() {
+            if index > 0 {
+                out.push(Span::styled("●", style.fg(FILESYSTEM_NOTIFICATION_COLOR)));
+            }
+            if !text.is_empty() {
+                out.push(Span::styled(text.to_owned(), style));
+            }
+        }
+    }
+    out
+}
+
 #[derive(Clone, Copy)]
 struct MetadataOptions {
     show_committer_date: bool,
@@ -2123,6 +2143,31 @@ mod tests {
             "completed work cannot be cancelled"
         );
 
+        app.unseen_filesystem_redraw = true;
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
+        for (x, _) in footer_text
+            .chars()
+            .enumerate()
+            .filter(|(_, character)| *character == '·')
+        {
+            assert_eq!(
+                terminal.backend().buffer()[(x as u16, 1)].symbol(),
+                "●",
+                "status separators become prominent notification discs"
+            );
+            assert_eq!(
+                terminal.backend().buffer()[(x as u16, 1)].fg,
+                FILESYSTEM_NOTIFICATION_COLOR,
+                "every status separator marks an unseen filesystem redraw"
+            );
+        }
+        assert_eq!(
+            terminal.backend().buffer()[(0, 1)].fg,
+            Color::Reset,
+            "notification coloring does not affect status text"
+        );
+        app.unseen_filesystem_redraw = false;
+
         app.notice = Some("worktree removed; using common repository".into());
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert_eq!(

From 20ad3639cc0ce9359c0c710a377f29aec1aa8dd4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 11 Aug 2026 16:51:33 +0200
Subject: [PATCH 043/282] feat: shade the tix commit panel

Replace the commit message panel border with a subtle background derived from the terminal theme. Query the terminal background once at startup, shift it by one sixteenth toward the opposite luminance extreme, and retain the default background when detection is unavailable.
---
 Cargo.lock         | 33 ++++++++++++++++++++++++++++++
 gix-tix/Cargo.toml |  1 +
 gix-tix/src/app.rs |  2 ++
 gix-tix/src/lib.rs | 51 +++++++++++++++++++++++++++++++++++++++++++++-
 gix-tix/src/ui.rs  | 43 +++++++++++++++++++++++++++++++++-----
 5 files changed, 124 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 96f3b55fad9..75e9dc3f559 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2602,6 +2602,7 @@ dependencies = [
  "insta",
  "notify",
  "ratatui",
+ "terminal-colorsaurus",
  "tracing",
  "tracing-appender",
  "tracing-subscriber",
@@ -5220,6 +5221,32 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "terminal-colorsaurus"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a46bb5364467da040298c573c8a95dbf9a512efc039630409a03126e3703e90"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "memchr",
+ "mio",
+ "terminal-trx",
+ "windows-sys 0.61.2",
+ "xterm-color",
+]
+
+[[package]]
+name = "terminal-trx"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3f27d9a8a177e57545481faec87acb45c6e854ed1e5a3658ad186c106f38ed"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "terminal_size"
 version = "0.4.4"
@@ -6320,6 +6347,12 @@ dependencies = [
  "rustix",
 ]
 
+[[package]]
+name = "xterm-color"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7008a9d8ba97a7e47d9b2df63fcdb8dade303010c5a7cd5bf2469d4da6eba673"
+
 [[package]]
 name = "xz2"
 version = "0.1.7"
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index ccce2b50334..9f4572fed21 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -29,6 +29,7 @@ directories = "6.0.0"
 gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command", "status"] }
 notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
+terminal-colorsaurus = "1.0.3"
 tracing = "0.1.37"
 tracing-appender = "0.2.4"
 tracing-subscriber = "0.3.17"
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 838a6ec2b53..67183355f08 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -345,6 +345,7 @@ pub(crate) struct App {
     pub(crate) worktree_changes: ChangesView,
     pub(crate) changes_parent: usize,
     pub(crate) commit_offset: usize,
+    pub(crate) commit_pane_background: Option<(u8, u8, u8)>,
     commit_page: usize,
     commit_max: usize,
     pub(crate) show_selection_tail: bool,
@@ -411,6 +412,7 @@ impl App {
             worktree_changes: ChangesView::default(),
             changes_parent: 0,
             commit_offset: 0,
+            commit_pane_background: None,
             commit_page: 1,
             commit_max: 0,
             show_selection_tail: true,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 35e13f86c44..5a48d9d1fa7 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -57,6 +57,7 @@ const REF_EVENT_IDLE: Duration = Duration::from_millis(100);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 const WATCH_RETRY_INTERVAL: Duration = Duration::from_secs(5);
+const THEME_QUERY_TIMEOUT: Duration = Duration::from_millis(100);
 
 struct FillRepository {
     path: PathBuf,
@@ -699,6 +700,34 @@ pub struct Options {
     pub hide: Vec<OsString>,
 }
 
+fn detect_commit_pane_background() -> Option<(u8, u8, u8)> {
+    let mut options = terminal_colorsaurus::QueryOptions::default();
+    options.timeout = THEME_QUERY_TIMEOUT;
+    match terminal_colorsaurus::background_color(options) {
+        Ok(background) => {
+            let color = background.scale_to_8bit();
+            let shaded = shade_terminal_background(color, background.perceived_lightness() <= 0.5);
+            tracing::debug!(?color, ?shaded, "detected terminal background");
+            Some(shaded)
+        }
+        Err(err) => {
+            tracing::debug!(error = %err, "terminal background detection unavailable");
+            None
+        }
+    }
+}
+
+fn shade_terminal_background((red, green, blue): (u8, u8, u8), dark: bool) -> (u8, u8, u8) {
+    let shade = |channel: u8| {
+        if dark {
+            channel + (u8::MAX - channel) / 16
+        } else {
+            channel - channel / 16
+        }
+    };
+    (shade(red), shade(green), shade(blue))
+}
+
 /// Run the interactive commit graph for `repository`.
 pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, options: Options) -> Result<()> {
     let _log_guard = match logging::init() {
@@ -713,12 +742,22 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
         hidden_revision_count = options.hide.len(),
         "starting tix"
     );
+    let commit_pane_background = detect_commit_pane_background();
     let mut terminal = ratatui::try_init().context("could not initialize terminal")?;
     let enhanced_keyboard = terminal::supports_keyboard_enhancement().unwrap_or(false);
     let keyboard_setup = enable_input(terminal.backend_mut(), enhanced_keyboard);
     let result = keyboard_setup
         .context("could not enable enhanced keyboard events")
-        .and_then(|()| event_loop(&mut terminal, repository, revisions, options, enhanced_keyboard));
+        .and_then(|()| {
+            event_loop(
+                &mut terminal,
+                repository,
+                revisions,
+                options,
+                enhanced_keyboard,
+                commit_pane_background,
+            )
+        });
     let keyboard_restore = disable_input(terminal.backend_mut(), enhanced_keyboard);
     let restore = ratatui::try_restore().context("could not restore terminal");
     let lane_time = result?;
@@ -758,6 +797,7 @@ fn event_loop(
     revisions: Vec<OsString>,
     options: Options,
     enhanced_keyboard: bool,
+    commit_pane_background: Option<(u8, u8, u8)>,
 ) -> Result<Option<Duration>> {
     let Options { quit_on_finish, hide } = options;
     let mut repository_path = repository.git_dir().to_owned();
@@ -794,6 +834,7 @@ fn event_loop(
     );
 
     let mut app = App::new(1);
+    app.commit_pane_background = commit_pane_background;
     if recovered_at_startup {
         app.notice = Some("worktree removed; using the common repository without worktree changes".into());
     }
@@ -3192,6 +3233,14 @@ fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::
 mod tests {
     use super::*;
 
+    #[test]
+    fn shades_terminal_background_by_one_sixteenth() {
+        assert_eq!(shade_terminal_background((0, 0, 0), true), (15, 15, 15));
+        assert_eq!(shade_terminal_background((255, 255, 255), false), (240, 240, 240));
+        assert_eq!(shade_terminal_background((32, 64, 128), true), (45, 75, 135));
+        assert_eq!(shade_terminal_background((32, 64, 128), false), (30, 60, 120));
+    }
+
     #[test]
     fn retains_unseen_filesystem_redraws_until_focus_returns() {
         assert!(!unseen_filesystem_redraw(false, false, false));
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 0b8e34c8b97..f5a16461add 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -568,7 +568,11 @@ pub(crate) fn draw_with_worktree(
     }
     if let Some((outer, area)) = commit_pane {
         frame.render_widget(Clear, outer);
-        frame.render_widget(Block::new().borders(Borders::LEFT), outer);
+        if let Some((red, green, blue)) = app.commit_pane_background {
+            frame
+                .buffer_mut()
+                .set_style(outer, Style::default().bg(Color::Rgb(red, green, blue)));
+        }
         let max_offset = if let Some(message) = commit_message {
             let notes = app
                 .selected
@@ -2440,6 +2444,7 @@ mod tests {
     #[test]
     fn toggles_the_full_commit_message_in_a_padded_half_width_pane() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(3);
+        app.commit_pane_background = Some((15, 16, 17));
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
@@ -2474,8 +2479,23 @@ mod tests {
         );
         assert_eq!(
             terminal.backend().buffer()[(60, 0)].symbol(),
-            "│",
-            "the pane has a left border"
+            " ",
+            "the pane starts with padding instead of a border"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(60, 0)].bg,
+            Color::Rgb(15, 16, 17),
+            "the commit pane has the derived terminal-background shade"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(62, 0)].bg,
+            Color::Rgb(15, 16, 17),
+            "the shade extends behind the commit message"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(59, 0)].bg,
+            Color::Reset,
+            "the history background is unchanged"
         );
         assert_eq!(
             terminal.backend().buffer()[(62, 2)].symbol(),
@@ -2494,6 +2514,11 @@ mod tests {
             " ",
             "closing the pane removes the commit body"
         );
+        assert_eq!(
+            terminal.backend().buffer()[(62, 3)].bg,
+            Color::Reset,
+            "closing the pane removes its background shade"
+        );
 
         app.update(Action::ToggleCommit);
         let mut wide_terminal = Terminal::new(TestBackend::new(200, 6))?;
@@ -2536,6 +2561,7 @@ mod tests {
     fn pages_overflowing_commit_messages_and_hides_the_status_when_they_fit() -> Result<(), Box<dyn std::error::Error>>
     {
         let mut app = App::new(4);
+        app.commit_pane_background = Some((15, 16, 17));
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
@@ -2695,6 +2721,7 @@ mod tests {
     #[test]
     fn shows_changed_paths_in_a_bottom_pane_below_the_summary() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(6);
+        app.commit_pane_background = Some((15, 16, 17));
         app.extend_commits(vec![
             Commit {
                 id: gix::ObjectId::Sha1([1; 20]),
@@ -3105,7 +3132,12 @@ mod tests {
                 .collect::<String>()
                 .contains("Tree")
         );
-        assert_eq!(terminal.backend().buffer()[(60, 7)].symbol(), "│");
+        assert_eq!(terminal.backend().buffer()[(60, 7)].symbol(), " ");
+        assert_eq!(
+            terminal.backend().buffer()[(60, 7)].bg,
+            Color::Rgb(15, 16, 17),
+            "the shaded commit pane separates the overlays without a border"
+        );
         assert_eq!(
             app.viewport_rows, 7,
             "history remains bounded above the highest overlay"
@@ -3129,7 +3161,8 @@ mod tests {
             ChangesLayout::SideBySide,
             "sufficient remaining width still permits side-by-side changes"
         );
-        assert_eq!(wide_terminal.backend().buffer()[(156, 7)].symbol(), "│");
+        assert_eq!(wide_terminal.backend().buffer()[(156, 7)].symbol(), " ");
+        assert_eq!(wide_terminal.backend().buffer()[(156, 7)].bg, Color::Rgb(15, 16, 17));
         Ok(())
     }
 

From 6833803afe1a4e7d76cddd3dfa46c14b23ef03eb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 05:12:38 +0200
Subject: [PATCH 044/282] feat: reword the newest commit in tix

Allow r to edit the top-most selectable commit using the Git-selected editor and a structured author, committer, date, comment-prefix, and message document. Offer missing GPT 5.6 Assisted-by and Co-authored-by trailers as semicolon-prefixed comments that users may opt into by removing the prefix, without repeating trailer keys already present regardless of their values.

Apply Git-compatible comment and whitespace cleanup after editing, with a configurable non-empty line prefix that defaults to a semicolon and only matches at column zero.

Recreate the commit with configured signing when enabled, then atomically retarget direct references that still point at the old commit while excluding tags and remote-tracking references. A detached HEAD is updated as well.

Keep repositories short-lived around editor invocation so tix retains no object database handles while idle.
---
 gix-tix/src/app.rs    |  34 ++++
 gix-tix/src/lib.rs    |  77 +++++++-
 gix-tix/src/reword.rs | 439 ++++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/ui.rs     |   6 +-
 4 files changed, 552 insertions(+), 4 deletions(-)
 create mode 100644 gix-tix/src/reword.rs

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 67183355f08..a46a03b5bc8 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -282,6 +282,7 @@ pub(crate) enum Action {
     ToggleChangesFocus,
     CycleChangesParent,
     OpenDiff,
+    Reword,
     VerifySignatures,
     Cancel,
     Copy,
@@ -301,6 +302,7 @@ pub(crate) enum Effect {
     Reload(bool),
     OpenDiff(ChangePane, usize),
     OpenCommitDiff(ObjectId),
+    Reword(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -756,6 +758,11 @@ impl App {
                     return vec![Effect::OpenCommitDiff(id)];
                 }
             }
+            Action::Reword if self.can_reword() => {
+                return vec![Effect::Reword(
+                    self.rows[self.selected.expect("reword requires a selection")].id,
+                )];
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -1197,6 +1204,17 @@ impl App {
         (0..self.rows.len()).find(|index| !self.is_row_hidden(*index))
     }
 
+    pub(crate) fn can_reword(&self) -> bool {
+        self.state == State::Complete && self.reword_shortcut_visible()
+    }
+
+    pub(crate) fn reword_shortcut_visible(&self) -> bool {
+        self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.selected.is_some()
+            && self.selected == self.first_selectable()
+    }
+
     fn last_selectable(&self) -> Option<usize> {
         (0..self.rows.len()).rev().find(|index| !self.is_row_hidden(*index))
     }
@@ -1844,6 +1862,22 @@ mod tests {
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
     }
 
+    #[test]
+    fn only_the_newest_completed_history_row_can_be_reworded() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        assert!(!app.can_reword(), "loading history cannot be reworded");
+        complete(&mut app);
+        assert_eq!(app.update(Action::Reword), vec![Effect::Reword(id(2))]);
+
+        app.update(Action::MoveDown);
+        assert!(
+            !app.can_reword(),
+            "a commit with a visible descendant cannot be reworded"
+        );
+        assert!(app.update(Action::Reword).is_empty());
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 5a48d9d1fa7..f541a2514ce 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -6,6 +6,7 @@ mod animation;
 mod app;
 mod history;
 mod logging;
+mod reword;
 mod ui;
 
 use std::{
@@ -845,6 +846,7 @@ fn event_loop(
     let mut refresh_from_filesystem = false;
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_select_top = false;
+    let mut refresh_select_top_requested = false;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
@@ -1216,7 +1218,7 @@ fn event_loop(
                 hidden_changed,
                 "compared reference snapshot"
             );
-            let select_top = from_filesystem && tips_changed;
+            let select_top = std::mem::take(&mut refresh_select_top_requested) || from_filesystem && tips_changed;
             ref_snapshot = next;
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
@@ -1594,6 +1596,21 @@ fn event_loop(
                         Ok(false) => {}
                     }
                 }
+                Effect::Reword(id) => {
+                    match reword_commit(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
+                        Ok(Some(new_id)) => {
+                            app.notice = Some(format!(
+                                "reworded {} as {}",
+                                id.to_hex_with_len(7),
+                                new_id.to_hex_with_len(7)
+                            ));
+                            refresh_select_top_requested = true;
+                            refresh_pending = true;
+                        }
+                        Ok(None) => {}
+                        Err(err) => app.notice = Some(format!("reword: {err:#}")),
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -2493,6 +2510,58 @@ fn show_commit_diff(
     Ok(false)
 }
 
+fn reword_commit(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    id: gix::ObjectId,
+    enhanced_keyboard: bool,
+) -> Result<Option<gix::ObjectId>> {
+    let (editor, document) = {
+        let mut repository =
+            open_repository(repository_path, bare, false).context("could not open repository before editing commit")?;
+        repository.object_cache_size(None);
+        reword::document(&repository, id)?
+    };
+    let mut tempfile = gix::tempfile::new(
+        std::env::temp_dir(),
+        gix::tempfile::ContainingDirectory::Exists,
+        gix::tempfile::AutoRemove::Tempfile,
+    )
+    .context("could not create commit message file")?
+    .take()
+    .context("commit message file disappeared")?;
+    tempfile
+        .write_all(&document)
+        .context("could not write commit message file")?;
+    tempfile.flush().context("could not flush commit message file")?;
+
+    if editor != ":" {
+        with_suspended_terminal(terminal, enhanced_keyboard, || {
+            let status = Command::from(
+                gix::command::prepare(&editor)
+                    .arg(tempfile.path())
+                    .command_may_be_shell_script_allow_manual_argument_splitting(),
+            )
+            .status()
+            .with_context(|| format!("could not launch Git editor {}", editor.to_string_lossy()))?;
+            if !status.success() {
+                anyhow::bail!("Git editor {} exited with {status}", editor.to_string_lossy());
+            }
+            Ok(())
+        })?;
+    }
+    let edited = std::fs::read(tempfile.path()).context("could not read edited commit message")?;
+    if edited == document {
+        return Ok(None);
+    }
+
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
+    repository.object_cache_size(None);
+    reword::apply(&repository, id, &edited)
+}
+
 fn run_external_diff(
     terminal: &mut ratatui::DefaultTerminal,
     mut command: gix::diff::blob::platform::prepare_diff_command::Command,
@@ -3164,6 +3233,7 @@ fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) ->
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
+        KeyCode::Char('r') => Some(Action::Reword),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
@@ -3991,7 +4061,10 @@ mod tests {
         assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
+            Some(Action::Reword)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
diff --git a/gix-tix/src/reword.rs b/gix-tix/src/reword.rs
new file mode 100644
index 00000000000..809d1df86de
--- /dev/null
+++ b/gix-tix/src/reword.rs
@@ -0,0 +1,439 @@
+use anyhow::{Context, Result};
+use gix::{
+    bstr::{BString, ByteSlice},
+    refs::{
+        Category, Target,
+        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+    },
+};
+
+const AUTHOR: &[u8] = b"Author: ";
+const AUTHOR_DATE: &[u8] = b"AuthorDate: ";
+const COMMITTER: &[u8] = b"Committer: ";
+const COMMITTER_DATE: &[u8] = b"CommitterDate: ";
+const COMMENT_CHAR: &[u8] = b"CommentChar: ";
+const DEFAULT_COMMENT_CHAR: &[u8] = b";";
+const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
+const CO_AUTHORED_BY: &[u8] = b"Co-authored-by: GPT 5.6 <codex@openai.com>";
+
+struct Edit<'a> {
+    author: &'a [u8],
+    author_time: gix::date::Time,
+    committer: &'a [u8],
+    committer_time: gix::date::Time,
+    message: BString,
+}
+
+pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
+    let editor = repo.editor().context("no Git editor is available")?;
+    let mut commit = repo
+        .find_commit(id)
+        .context("could not find commit to reword")?
+        .decode()
+        .context("could not decode commit to reword")?
+        .into_owned()
+        .context("could not own commit to reword")?;
+    commit.committer.time = gix::date::Time::now_local_or_utc();
+
+    let mut out = Vec::new();
+    write_actor(&mut out, AUTHOR, &commit.author);
+    write_date(&mut out, AUTHOR_DATE, commit.author.time)?;
+    write_actor(&mut out, COMMITTER, &commit.committer);
+    write_date(&mut out, COMMITTER_DATE, commit.committer.time)?;
+    out.extend_from_slice(COMMENT_CHAR);
+    out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+    out.push(b'\n');
+    out.push(b'\n');
+    out.extend_from_slice(&commit.message);
+    if !out.ends_with(b"\n") {
+        out.push(b'\n');
+    }
+    let suggestions = missing_agent_trailers(&commit.message);
+    if suggestions.iter().any(Option::is_some) {
+        if !out.ends_with(b"\n\n") {
+            out.push(b'\n');
+        }
+        for trailer in suggestions.into_iter().flatten() {
+            out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+            out.extend_from_slice(trailer);
+            out.push(b'\n');
+        }
+    }
+    Ok((editor, out))
+}
+
+fn missing_agent_trailers(message: &[u8]) -> [Option<&'static [u8]>; 2] {
+    let mut has_assisted_by = false;
+    let mut has_co_authored_by = false;
+    if let Some(body) = gix::objs::commit::MessageRef::from_bytes(message).body() {
+        for trailer in body.trailers() {
+            has_assisted_by |= trailer.is_assisted_by();
+            has_co_authored_by |= trailer.is_co_authored_by();
+        }
+    }
+    [
+        (!has_assisted_by).then_some(ASSISTED_BY),
+        (!has_co_authored_by).then_some(CO_AUTHORED_BY),
+    ]
+}
+
+pub(crate) fn apply(repo: &gix::Repository, old_id: gix::ObjectId, edited: &[u8]) -> Result<Option<gix::ObjectId>> {
+    let edit = parse(edited)?;
+    if edit.message.is_empty() {
+        anyhow::bail!("the edited commit message is empty");
+    }
+
+    let refs = matching_references(repo, old_id)?;
+    if refs.is_empty() {
+        anyhow::bail!("no mutable reference points to the commit anymore");
+    }
+
+    let mut commit = repo
+        .find_commit(old_id)
+        .context("could not find commit after editing")?
+        .decode()
+        .context("could not decode commit after editing")?
+        .into_owned()
+        .context("could not own commit after editing")?;
+    commit.author = actor(edit.author, edit.author_time, "author")?;
+    commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
+    commit.message = edit.message;
+    commit.extra_headers.retain(|(name, _)| {
+        name.as_slice() != gix::objs::commit::SIGNATURE_FIELD_NAME.as_bytes()
+            && name.as_slice() != gix::objs::commit::SIGNATURE_FIELD_NAME_SHA256.as_bytes()
+    });
+    if let Some(options) = repo
+        .commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?
+    {
+        commit = commit.sign(options).context("could not sign reworded commit")?;
+    }
+    let new_id = repo
+        .write_object(&commit)
+        .context("could not write reworded commit")?
+        .detach();
+    if new_id == old_id {
+        return Ok(None);
+    }
+
+    let log_message = gix::reference::log::message("commit", commit.message.as_bstr(), commit.parents.len());
+    let edits = refs.into_iter().map(|name| RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: log_message.clone(),
+            },
+            expected: PreviousValue::MustExistAndMatch(Target::Object(old_id)),
+            new: Target::Object(new_id),
+        },
+        name,
+        deref: false,
+    });
+    let mut time_buf = gix::date::parse::TimeBuf::default();
+    repo.edit_references_as(edits, Some(commit.committer.to_ref(&mut time_buf)))
+        .context("could not update references to the reworded commit")?;
+    Ok(Some(new_id))
+}
+
+fn write_actor(out: &mut Vec<u8>, label: &[u8], actor: &gix::actor::Signature) {
+    out.extend_from_slice(label);
+    out.extend_from_slice(&actor.name);
+    out.extend_from_slice(b" <");
+    out.extend_from_slice(&actor.email);
+    out.extend_from_slice(b">\n");
+}
+
+fn write_date(out: &mut Vec<u8>, label: &[u8], time: gix::date::Time) -> Result<()> {
+    out.extend_from_slice(label);
+    out.extend_from_slice(
+        time.format(gix::date::time::format::ISO8601)
+            .context("could not format commit date")?
+            .as_bytes(),
+    );
+    out.push(b'\n');
+    Ok(())
+}
+
+fn parse(input: &[u8]) -> Result<Edit<'_>> {
+    let mut parts = input.splitn(7, |byte| *byte == b'\n');
+    let author = header(parts.next(), AUTHOR)?;
+    let author_time = date(header(parts.next(), AUTHOR_DATE)?, "author")?;
+    let committer = header(parts.next(), COMMITTER)?;
+    let committer_time = date(header(parts.next(), COMMITTER_DATE)?, "committer")?;
+    let comment_char = header(parts.next(), COMMENT_CHAR)?;
+    if comment_char.contains(&b'\r') {
+        anyhow::bail!("CommentChar must not contain a line ending");
+    }
+    if parts.next().map(trim_cr) != Some(&[][..]) {
+        anyhow::bail!("expected an empty line after the commit headers");
+    }
+    let message = cleanup_message(parts.next().context("the commit message is missing")?, comment_char);
+    Ok(Edit {
+        author,
+        author_time,
+        committer,
+        committer_time,
+        message,
+    })
+}
+
+fn cleanup_message(input: &[u8], comment_char: &[u8]) -> BString {
+    let mut out = Vec::new();
+    let mut empty_lines = 0;
+    for line in input.lines_with_terminator() {
+        let line = trim_cr(line.strip_suffix(b"\n").unwrap_or(line));
+        if line.starts_with(comment_char) {
+            continue;
+        }
+        let line = &line[..line
+            .iter()
+            .rposition(|byte| !byte.is_ascii_whitespace())
+            .map_or(0, |pos| pos + 1)];
+        if line.is_empty() {
+            empty_lines += 1;
+            continue;
+        }
+        if !out.is_empty() && empty_lines > 0 {
+            out.push(b'\n');
+        }
+        empty_lines = 0;
+        out.extend_from_slice(line);
+        out.push(b'\n');
+    }
+    out.into()
+}
+
+fn header<'a>(line: Option<&'a [u8]>, prefix: &[u8]) -> Result<&'a [u8]> {
+    trim_cr(line.context("a commit header is missing")?)
+        .strip_prefix(prefix)
+        .filter(|value| !value.is_empty())
+        .with_context(|| format!("expected a non-empty {} header", prefix[..prefix.len() - 2].as_bstr()))
+}
+
+fn trim_cr(line: &[u8]) -> &[u8] {
+    line.strip_suffix(b"\r").unwrap_or(line)
+}
+
+fn date(value: &[u8], field: &str) -> Result<gix::date::Time> {
+    let value = std::str::from_utf8(value).with_context(|| format!("{field} date is not UTF-8"))?;
+    gix::date::parse(value, None)
+        .map_err(|err| anyhow::Error::new(err.into_error()))
+        .with_context(|| format!("could not parse {field} date"))
+}
+
+fn actor(value: &[u8], time: gix::date::Time, field: &str) -> Result<gix::actor::Signature> {
+    let parsed = gix::actor::SignatureRef::from_bytes(value)
+        .with_context(|| format!("could not parse {field} identity"))?
+        .trim();
+    if parsed.name.is_empty() || parsed.email.is_empty() || !parsed.time.is_empty() {
+        anyhow::bail!("{field} must be written as Name <email>");
+    }
+    Ok(gix::actor::Signature {
+        name: parsed.name.into(),
+        email: parsed.email.into(),
+        time,
+    })
+}
+
+fn matching_references(repo: &gix::Repository, id: gix::ObjectId) -> Result<Vec<gix::refs::FullName>> {
+    let mut out = Vec::new();
+    for reference in repo.references()?.all()? {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => anyhow::bail!("could not inspect references pointing to commit: {err}"),
+        };
+        if !matches!(
+            reference.name().category(),
+            Some(Category::Tag | Category::RemoteBranch)
+        ) && reference.try_id().is_some_and(|target| target.as_ref() == id)
+        {
+            out.push(reference.name().to_owned());
+        }
+    }
+    if let Some(head) = repo.try_find_reference("HEAD")?
+        && head.try_id().is_some_and(|target| target.as_ref() == id)
+    {
+        out.push(head.name().to_owned());
+    }
+    Ok(out)
+}
+
+fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
+    loop {
+        if err
+            .downcast_ref::<std::io::Error>()
+            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
+        {
+            return true;
+        }
+        let Some(source) = err.source() else { return false };
+        err = source;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use super::*;
+
+    #[test]
+    fn parses_the_edit_document() -> gix_testtools::Result {
+        let input = b"Author: A U Thor <author@example.com>\n\
+                      AuthorDate: 2026-08-12 10:20:30 +0200\n\
+                      Committer: C O Mitter <committer@example.com>\n\
+                      CommitterDate: 2026-08-12 11:20:30 +0200\n\
+                      CommentChar: ;\n\
+                      \n\
+                      title\n\nbody\n";
+        let edit = parse(input)?;
+        assert_eq!(
+            edit.author, b"A U Thor <author@example.com>",
+            "the author identity is preserved"
+        );
+        assert_eq!(edit.author_time.offset, 7200, "the author timezone is parsed");
+        assert_eq!(
+            edit.committer, b"C O Mitter <committer@example.com>",
+            "the committer identity is preserved"
+        );
+        assert_eq!(edit.committer_time.offset, 7200, "the committer timezone is parsed");
+        assert_eq!(
+            edit.message, b"title\n\nbody\n",
+            "the message is preserved byte-for-byte"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn document_does_not_repeat_existing_agent_trailers() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let repository = gix::open_opts(
+            fixture,
+            gix::open::Options::isolated().config_overrides(["core.editor=:".to_owned()]),
+        )?;
+        let topic = repository.find_reference("refs/heads/topic")?.id().detach();
+        let (editor, document) = document(&repository, topic)?;
+        assert_eq!(editor, ":", "the configured editor is returned");
+        assert!(
+            document
+                .windows(b"CommentChar: ;\n\n".len())
+                .any(|line| line == b"CommentChar: ;\n\n"),
+            "the template declares its default comment prefix"
+        );
+        assert!(
+            !document
+                .windows(b";Assisted-by:".len())
+                .any(|line| line == b";Assisted-by:")
+                && !document
+                    .windows(b";Co-authored-by:".len())
+                    .any(|line| line == b";Co-authored-by:"),
+            "existing trailer keys suppress model-specific suggestions regardless of their values"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn offers_only_missing_agent_trailer_keys() {
+        assert_eq!(
+            missing_agent_trailers(b"title\n\nASSISTED-BY: another agent\n"),
+            [None, Some(CO_AUTHORED_BY)],
+            "trailer keys are matched case-insensitively and independently of their values"
+        );
+        assert_eq!(
+            missing_agent_trailers(b"title\n\nco-AUTHORED-by: Someone <someone@example.com>\n"),
+            [Some(ASSISTED_BY), None],
+            "either missing trailer remains available for opt-in"
+        );
+    }
+
+    #[test]
+    fn cleanup_honors_git_style_comment_prefixes_and_opted_in_trailers() -> gix_testtools::Result {
+        let input = b"Author: A <a@example.com>\n\
+                      AuthorDate: 2026-08-12 10:20:30 +0200\n\
+                      Committer: C <c@example.com>\n\
+                      CommitterDate: 2026-08-12 11:20:30 +0200\n\
+                      CommentChar: //\n\
+                      \n\
+                      \nsubject  \n\n\ninline // stays  \n // indented stays\n//removed\n\nAssisted-by: GPT 5.6\n//Co-authored-by: GPT 5.6 <codex@openai.com>\n";
+        assert_eq!(
+            parse(input)?.message,
+            b"subject\n\ninline // stays\n // indented stays\n\nAssisted-by: GPT 5.6\n".as_bstr(),
+            "only column-zero comments are removed and Git whitespace cleanup is applied"
+        );
+
+        let empty_comment = input.replacen(b"CommentChar: //", b"CommentChar: ", 1);
+        assert!(parse(&empty_comment).is_err(), "the comment prefix cannot be empty");
+        Ok(())
+    }
+
+    #[test]
+    fn rewrites_direct_refs_except_tags_and_remotes_and_signs_when_enabled() -> gix_testtools::Result {
+        if !gix_testtools::signature::program_available("ssh-keygen") {
+            return Ok(());
+        }
+        let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let old_id = gix::open(fixture.path())?.head_id()?.detach();
+        let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
+            Command::new("git").arg("-C").arg(fixture.path()).args(args).status()
+        };
+        for name in ["refs/patches/reword", "refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert!(
+                git(&["update-ref", name, &old_id.to_string()])?.success(),
+                "the test reference is created"
+            );
+        }
+
+        let repository = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "commit.gpgSign=true".to_owned(),
+                "gpg.format=ssh".to_owned(),
+                format!("user.signingKey={}", key.display()),
+                format!(
+                    "gpg.ssh.allowedSignersFile={}",
+                    gix_testtools::signature::fixture("ssh-allowed-signers").display()
+                ),
+            ]),
+        )?;
+        let edited = b"Author: New Author <new-author@example.com>\n\
+                       AuthorDate: 2026-08-12 10:20:30 +0200\n\
+                       Committer: New Committer <new-committer@example.com>\n\
+                       CommitterDate: 2026-08-12 11:20:30 +0200\n\
+                       CommentChar: ;\n\
+                       \n\
+                       rewritten title\n\nrewritten body\n\nAssisted-by: GPT 5.6\n;Co-authored-by: GPT 5.6 <codex@openai.com>\n";
+        let new_id = apply(&repository, old_id, edited)?.expect("the edited commit differs");
+        let commit = repository.find_commit(new_id)?;
+        let decoded = commit.decode()?;
+        assert_eq!(
+            decoded.message,
+            b"rewritten title\n\nrewritten body\n\nAssisted-by: GPT 5.6\n".as_bstr()
+        );
+        assert_eq!(decoded.author()?.name, b"New Author".as_bstr());
+        assert!(
+            commit
+                .verify_signature()?
+                .expect("configured signing adds a signature")
+                .is_valid(),
+            "the rewritten commit has a valid configured signature"
+        );
+        for name in ["refs/heads/main", "refs/patches/reword"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                new_id,
+                "{name} follows the rewrite"
+            );
+        }
+        for name in ["refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                old_id,
+                "{name} is not rewritten"
+            );
+        }
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index f5a16461add..f63d55f6563 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -612,6 +612,9 @@ pub(crate) fn draw_with_worktree(
     ))];
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · Enter diff"));
+        if app.reword_shortcut_visible() {
+            footer_spans.push(Span::raw(" · r reword"));
+        }
     }
     if app.tree_changes_visible || app.worktree_changes_visible {
         footer_spans.push(match app.focus_feedback.take() {
@@ -2096,8 +2099,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text =
-            "#1 · ↑↓/jk move · h/l pan · Enter diff · [ align · o commit · c changes · v view · y copy · q quit";
+        let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · r reword · [ align · o commit · c changes · v view · y copy · q quit";
         let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {

From 24e6995136357059a5d2d6de5e790f5074b44c76 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 11:13:13 +0200
Subject: [PATCH 045/282] feat: mark HEAD and dirty worktrees in tix

Replace the HEAD commit disk with @ while retaining signature-state and selection coloring, so its position remains visible independently of reference label settings.

When displayed worktree changes are non-empty, place D in the left marker column on HEAD. Keep > on a separately selected commit and restore the normal marker when the worktree pane is not rendered.
---
 gix-tix/src/ui.rs | 157 +++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 143 insertions(+), 14 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index f63d55f6563..d0aba8b5934 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -239,6 +239,10 @@ pub(crate) fn draw_with_worktree(
             )
         }),
     );
+    let worktree_dirty = worktree_changes.is_some_and(|changes| !changes.paths.is_empty())
+        && changes_panes
+            .iter()
+            .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0);
     if app.changes_visible() {
         app.set_changes_layout(
             changes_layout,
@@ -362,6 +366,11 @@ pub(crate) fn draw_with_worktree(
         let lane = lanes.lane(index);
         let y = body.y.saturating_add(index as u16);
         let selected = app.selected == Some(start + index);
+        let head = decorations.get(&visible_rows[index].id).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Head)
+        });
         let metadata_width = metadata.width();
         let signature_color = signature_color(visible_rows[index].signature);
         let highlight = if selected && app.show_selection_tail {
@@ -375,7 +384,14 @@ pub(crate) fn draw_with_worktree(
             color(highlight).add_modifier(Modifier::REVERSED)
         });
         frame.render_widget(
-            Paragraph::new(if selected { "> " } else { "  " }).style(style),
+            Paragraph::new(if head && worktree_dirty {
+                "D "
+            } else if selected {
+                "> "
+            } else {
+                "  "
+            })
+            .style(if selected { style } else { Style::default() }),
             Rect::new(body.x, y, body.width.min(2), 1),
         );
 
@@ -392,6 +408,7 @@ pub(crate) fn draw_with_worktree(
                 graph_offset,
                 highlight,
                 visible_rows[index].signature,
+                head,
             );
             let aligned = Rect::new(
                 content.x.saturating_add(align_width as u16),
@@ -416,6 +433,7 @@ pub(crate) fn draw_with_worktree(
                 horizontal_offset,
                 highlight,
                 visible_rows[index].signature,
+                head,
             );
         }
         let lane_offset = if align_metadata {
@@ -1512,6 +1530,7 @@ fn color_graph(
     offset: usize,
     highlight: Option<Color>,
     signature: SignatureState,
+    head: bool,
 ) {
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
@@ -1524,7 +1543,11 @@ fn color_graph(
         } else {
             graph_style(offset.saturating_add(x) / 2)
         };
-        frame.buffer_mut()[(area.x + x as u16, area.y)].set_style(style);
+        let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
+        if head && symbol == '●' {
+            cell.set_symbol("@");
+        }
+        cell.set_style(style);
     }
 }
 
@@ -2100,7 +2123,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
         let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · r reword · [ align · o commit · c changes · v view · y copy · q quit";
-        let selected_line = "> ● 0101010 (HEAD) 1970-01-01 mapped author subject";
+        let selected_line = "> @ 0101010 (HEAD) 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
@@ -2221,6 +2244,10 @@ mod tests {
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(!rendered_row(&terminal).contains("HEAD"), "no refs hides regular refs");
+        assert!(
+            rendered_row(&terminal).starts_with("> @"),
+            "HEAD keeps its graph marker"
+        );
         assert!(
             !rendered_row(&terminal).contains("refs/patches"),
             "no refs hides special refs"
@@ -2367,29 +2394,35 @@ mod tests {
     }
 
     #[test]
-    fn colors_commit_disks_by_signature_state() -> Result<(), Box<dyn std::error::Error>> {
+    fn colors_commit_markers_by_signature_state() -> Result<(), Box<dyn std::error::Error>> {
         let states = [
             (SignatureState::Unsigned, Color::Blue),
             (SignatureState::Unverified, Color::Rgb(255, 165, 0)),
             (SignatureState::Verified, Color::Green),
             (SignatureState::Failed, Color::LightRed),
         ];
-        let mut terminal = Terminal::new(TestBackend::new(2, states.len() as u16))?;
+        let mut terminal = Terminal::new(TestBackend::new(4, states.len() as u16))?;
         terminal.draw(|frame| {
             for (y, (state, _)) in states.iter().enumerate() {
-                color_graph(
-                    frame,
-                    Rect::new(0, y as u16, 2, 1),
-                    "●─",
-                    0,
-                    Some(signature_color(*state)),
-                    *state,
-                );
+                for (x, head) in [(0, false), (2, true)] {
+                    frame.render_widget(Paragraph::new("●─"), Rect::new(x, y as u16, 2, 1));
+                    color_graph(
+                        frame,
+                        Rect::new(x, y as u16, 2, 1),
+                        "●─",
+                        0,
+                        Some(signature_color(*state)),
+                        *state,
+                        head,
+                    );
+                }
             }
         })?;
 
         for (y, (_, expected)) in states.iter().enumerate() {
-            for x in 0..2 {
+            assert_eq!(terminal.backend().buffer()[(0, y as u16)].symbol(), "●");
+            assert_eq!(terminal.backend().buffer()[(2, y as u16)].symbol(), "@");
+            for x in 0..4 {
                 let cell = &terminal.backend().buffer()[(x, y as u16)];
                 assert_eq!(cell.fg, *expected);
                 assert!(cell.modifier.contains(Modifier::REVERSED));
@@ -2398,6 +2431,102 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn marks_dirty_head_independently_of_history_selection() -> Result<(), Box<dyn std::error::Error>> {
+        let head = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(5);
+        app.extend_commits(
+            [head, gix::ObjectId::Sha1([2; 20])]
+                .into_iter()
+                .map(|id| Commit {
+                    id,
+                    parent_ids: Default::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: "subject".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        let decorations = Decorations::from([(
+            head,
+            vec![Decoration {
+                name: "HEAD".into(),
+                kind: DecorationKind::Head,
+            }],
+        )]);
+        let dirty = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group: ChangeGroup::Unstaged,
+                source: None,
+                path: "dirty".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
+
+        app.selected = Some(1);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&dirty),
+            );
+        })?;
+        assert!(rendered_line(&terminal, 0).starts_with("D @"));
+        assert!(rendered_line(&terminal, 1).starts_with("> ●"));
+        assert_eq!(terminal.backend().buffer()[(0, 0)].modifier, Modifier::empty());
+        assert!(
+            terminal.backend().buffer()[(0, 1)]
+                .modifier
+                .contains(Modifier::REVERSED)
+        );
+
+        app.selected = Some(0);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&dirty),
+            );
+        })?;
+        assert!(rendered_line(&terminal, 0).starts_with("D @"));
+        assert!(
+            terminal.backend().buffer()[(0, 0)]
+                .modifier
+                .contains(Modifier::REVERSED)
+        );
+
+        app.changes_mode = Some(ChangesMode::Tree);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&dirty),
+            );
+        })?;
+        assert!(rendered_line(&terminal, 0).starts_with("> @"));
+        Ok(())
+    }
+
     #[test]
     fn shows_signature_action_only_while_actionable() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);

From 2d917f7da6049cf41c00254c5b5e5f535f184989 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 11:20:04 +0200
Subject: [PATCH 046/282] Document the gix-tix behavioral contract

Capture the final behavior assembled by the tix patch stack: history traversal and projection, visual states and attribution, keyboard and Shift navigation, overlay layout, tree and worktree changes, diff presentation, signature verification, rewording, filesystem refresh and recovery, diagnostics, and bounded-resource requirements.

Make the local agent instructions require user-visible, lifecycle, performance, and resource-ownership changes to update the specification and its regression coverage in the same semantic patch.
---
 gix-tix/AGENTS.md |   6 +
 gix-tix/spec.md   | 331 ++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 337 insertions(+)
 create mode 100644 gix-tix/spec.md

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 9e05df11802..ea79bb28845 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -1,5 +1,11 @@
 # gix-tix invariants
 
+## Behavioral specification
+
+- Keep `spec.md` synchronized with every user-visible, lifecycle, performance,
+  or resource-ownership change to tix. Update the specification and its
+  regression coverage in the same semantic patch as the implementation.
+
 ## Commit authorship
 
 - A commit created or materially rewritten by an AI agent must use that agent's own name and email as its author. Do not silently inherit the repository owner's configured identity.
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
new file mode 100644
index 00000000000..e734095b376
--- /dev/null
+++ b/gix-tix/spec.md
@@ -0,0 +1,331 @@
+# gix-tix specification
+
+This document describes the intended behavior of `tix` on this branch. It is the
+behavioral contract for future changes; implementation details belong here only
+when they preserve responsiveness, bounded memory, Git compatibility, or resource
+lifetime.
+
+## Purpose and invocation
+
+`tix` is a minimal, `tig`-inspired commit-history browser optimized for large
+repositories. It must remain useful on histories as large as the Linux kernel
+without trading responsiveness for metadata that is not visible.
+
+- `tix [REVISION]...` shows commits reachable from the supplied revisions, or
+  from `HEAD` when none are supplied.
+- `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
+  option may be repeated.
+- `--quit-on-finish` exits after traversal and lane computation, for measurement
+  and non-interactive use.
+- Revisions must resolve and peel to commits. Invalid or non-commit revisions are
+  errors.
+- The UI always owns the alternate screen. Raw mode, focus reporting, mouse
+  capture, and enhanced keyboard reporting are restored on every exit path.
+- `Ctrl-C` exits immediately from any normal tix focus. `q` quits from history;
+  `q` or `Escape` in a focused changes block returns focus to history.
+
+## History model
+
+### Traversal and projection
+
+- Traversal streams commits before graph-lane computation finishes. The footer
+  reports the number received while loading and switches to the selected row
+  number after completion. Rows are numbered from the bottom, so the oldest row
+  is `#1` and the newest row is `#N`.
+- Commit topology, commit time, and generation are loaded through the same
+  commit-graph-or-ODB lookup model as `gix-traverse`. A small object cache avoids
+  repeated ODB decoding during a walk.
+- Metadata already decoded from ODB is retained. Metadata omitted because a
+  commit came from the commit-graph is populated lazily for visible rows.
+- The persistent graph is append-only and index-addressed, with one compact copy
+  of each commit and flat parent edges. View refreshes project rows from this
+  cache and stop walking when complete cached ancestry is reached.
+- Local branch targets are reverse-indexed. Configured upstream targets are added
+  as internal traversal tips so ahead/behind calculations have complete ancestry
+  without a second repository walk.
+- Shallow boundaries are honored. Parent topology needed by future projections,
+  hidden expansion, and ahead/behind calculations must not be pruned with the
+  currently visible lane graph.
+
+### Hidden history
+
+- Hidden ancestry is removed from the selectable view by default. Direct parents
+  that connect visible history to hidden history remain as boundary rows.
+- Boundary rows retain graph styling but use terminal-default colors, are dimmed,
+  and cannot be selected, paged to, copied, signature-verified, restored as a
+  selection, or entered by Shift navigation.
+- When hidden revisions are configured, references are hidden by default so
+  metadata remains aligned.
+- `v`, then `h`, toggles the full hidden projection. Toggling preserves the
+  selected commit when it still exists and otherwise selects the newest
+  selectable row.
+
+### Row content and visual states
+
+- A row contains graph lanes, a seven-character object ID, optional references,
+  committer date, author and attribution information, markers, and title.
+- The commit marker is blue when unsigned, orange when signed but unverified or
+  being verified, green when verified, and bright red when verification fails.
+- The current `HEAD` commit uses `@` instead of the normal commit disc and keeps
+  the same signature and selection coloring. It remains visible when textual
+  reference labels are hidden.
+- The selected row uses `>` at the left. If the displayed worktree block is dirty,
+  `D` is shown at the `HEAD` row instead; a separately selected row retains `>`.
+- Selection inversion covers the left marker, graph, commit marker, and hash.
+  Its graph background is derived from the commit-marker color. The selected
+  row's right-hand tail and contextual information always have blank margins and
+  never invert an adjacent character.
+- A compared merge parent is cyan, including its commit marker, and its hash is
+  inverted.
+- Rows outside active Shift reachability are dimmed. When a changes block has
+  focus, history is dimmed but its contextual selection information and main
+  status line remain prominent.
+
+### Metadata and attribution
+
+- Mailmap resolution is enabled by default and is obtained from a non-isolated
+  repository.
+- Recognized attribution trailers are `Co-authored-by`, `Assisted-by`,
+  `Reviewed-by`, `Acked-by`, `Tested-by`, and `Signed-off-by`.
+- Every displayed `Assisted-by` value is classified as an agent. Agent names are
+  bracketed and agent emails are never displayed.
+- Attribution keys with identical displayed actor lists are grouped, for example
+  `Co, A: [GPT 5.6]`.
+- Actors whose email ends in `@users.noreply.github.com` are italicized.
+- Full-actor mode shows author emails and attribution actors but hides the commit
+  title. Classified agent emails remain hidden.
+- A commit message containing `--- agent` or `<!-- agent -->` receives a bright
+  purple `[A]` before its title.
+- A commit with notes in the configured notes ref receives a matching `[N]`.
+  Notes are loaded lazily for visible commits.
+
+### Selection context
+
+- When tree changes are displayed, non-zero insertion and deletion counts for
+  the selected commit appear immediately before the right selection tail.
+- When a selected commit is pointed to by local refs, display at most one
+  deterministic relationship. Prefer a configured-upstream relation as
+  `⇡ahead⇣behind`; otherwise, when hidden ancestry exists, show the visible-only
+  count as `⇡N`.
+- Relationship walks use the in-memory graph, stop once no further distinction
+  can be made, and cache completed results. They must never reopen a repository
+  merely because selection moved.
+
+## Interaction
+
+### Navigation and display controls
+
+| Key | Behavior |
+| --- | --- |
+| `j`/Down, `k`/Up | Move one selectable row or changed path. |
+| Mouse/trackpad vertical scroll | Move history by the coalesced scroll distance; move paths when a changes block is focused. |
+| `h`/`l` | Pan history or the focused changes block horizontally. |
+| `Ctrl-u`/`Ctrl-d` | Move half a page. |
+| `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
+| `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
+| `[` | Toggle graph/metadata alignment. |
+| `v` | Toggle the history-display key group. Pressing `v` again closes it. |
+| `v d` | Toggle committer dates. |
+| `v e` | Toggle full actors/emails and titles. |
+| `v n` | Cycle all attribution, author only, and no names, skipping inert states. |
+| `v t` | Toggle attribution trailers. |
+| `v m` | Toggle mailmap resolution. |
+| `v r` | Cycle all, normal, and no reference labels. |
+| `v h` | Show or hide configured hidden ancestry. |
+| `Shift-R` | Explicitly refresh the revision view and visible worktree status. |
+| `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
+| `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
+| `s` | Verify signed, unverified commits currently visible on screen. |
+
+The display group remains open for consecutive display changes and closes on
+navigation or another recognized command. `[` and overlay controls remain direct
+shortcuts.
+
+### Held Shift ancestry mode
+
+- On terminals that report modifier press and release events, pressing Shift in
+  focused history anchors navigation at the selected commit. Releasing Shift
+  restores ordinary navigation.
+- `j` and `k` then visit only commits reachable through the selected rail; other
+  rows are dimmed.
+- A non-merge anchor follows all of its ancestry. A merge anchor initially uses
+  its second parent, excluding first-parent ancestry except shared fork points.
+- `h` and `l` cycle the merge anchor's parents instead of panning. The chosen
+  parent is numbered beside the junction marker. Later merges on the chosen rail
+  traverse all their parents normally.
+- Reachability is computed only after traversal and lane computation complete.
+  Shift is ignored while another changes block has focus or while the terminal
+  itself is unfocused.
+
+## Overlay views
+
+Overlay views paint over history without changing metadata alignment. Selection
+is bounded above the top-most changes block: moving down at that boundary scrolls
+history so the selected row stays visible. The commit view reserves right-side
+space first; changes blocks adapt within the remaining history width.
+
+### Commit message
+
+- `o` or `]` toggles the commit view on the right. It uses at most half the
+  terminal and reserves 80 content columns when space permits.
+- The panel has a minimally shaded background derived from the detected terminal
+  background, with the default background as fallback.
+- The title begins on the first content row and is bold. Body text follows, then
+  each note with a bold purple `Notes` prefix, then aligned trailers.
+- Overflow is page-scrollable and gets a distinct pane status line only when
+  scrolling is possible.
+
+### Tree and worktree changes
+
+- Changes start enabled as `Tree + Worktree`. `c` cycles `Tree + Worktree` →
+  `Tree` → hidden. Bare repositories omit the worktree mode.
+- Each block has a top border carrying its compact summary. Tree summaries show
+  the selected short hash; worktree summaries distinguish staged and unstaged
+  counts. Kind totals, total files when non-redundant, and non-zero line totals
+  are color-coded. An empty enabled worktree says `Worktree clean` in green.
+- Tree paths preserve tree-diff order. Worktree paths show staged entries first in
+  green and unstaged/untracked/conflicted entries second in bright red, sorted by
+  raw path within each group.
+- Path kinds are `A`, `M`, `D`, `R`, `C`, `T`, and `U`. The selected path is
+  subtly inverted and appends its already-computed non-zero line counts.
+- Blocks are side by side when both condensed titles fit, otherwise Worktree is
+  stacked above Tree. A shared vertical divider joins side-by-side blocks. Blocks
+  size to content but together use no more than half the terminal.
+- If paths overflow, the final row reports the remaining line count and updates
+  while scrolling. A single path is never replaced by overflow text.
+- `Tab` cycles focus in visual order through visible changes blocks and history.
+  Inactive blocks, including paths and borders, are dimmed. Only the focused
+  block shows its distinct status line.
+- `p` cycles the comparison parent while Tree has focus. Merge commits are
+  compared to one parent at a time; root commits compare against an empty tree.
+- Repeated history keys and vertical mouse bursts temporarily hide changes
+  overlays. They return after 75 ms of navigation idle, with the same path
+  selection and viewport where possible.
+- Tree diff results, detached diff resources, and line counts use a bounded MRU
+  while changes remain enabled. Worktree results are cached separately and
+  invalidated by relevant filesystem events.
+- Per-file line information is computed once in an `available_parallelism`
+  worker pool that exists only while changes are enabled.
+
+### Diffs
+
+- `Enter` in history opens the whole selected commit against the active parent.
+  `Enter` in a focused changes block opens only its selected path.
+- A whole-commit diff starts with commit identity and a Git-style per-path
+  diffstat in diff order, followed by parent/root, kind totals, and aggregate line
+  totals. It then shows the internal patch and invokes any per-path external diff
+  drivers.
+- Diff preparation honors Git attributes, text conversion, binary detection,
+  external diff commands, and the configured `core.pager` pipeline.
+- Binary, submodule, conflicted, and otherwise unavailable file diffs do not
+  launch an inappropriate pager; the changes status line reports the reason.
+- The built-in viewer takes over the alternate screen and supports the same
+  vertical and horizontal navigation keys. `Enter` advances from a whole-commit
+  internal diff to external drivers; `q` or `Escape` returns to tix.
+- External programs run with the terminal suspended and restored afterward.
+  Broken-pipe writes are accepted. If a pager exits within 250 ms, its already
+  displayed output is retained until a keypress so short output remains readable.
+
+## Signature verification and rewording
+
+### Signatures
+
+- Presence of `gpgsig` or `gpgsig-sha256` marks a commit as signed but
+  unverified; history loading does not validate signatures eagerly.
+- The `s` hint appears only while the viewport has work to verify and disappears
+  after success. Verification uses Git-compatible repository configuration.
+- Failures show their count with a bright-red marker. Moving the history
+  selection resets failed visible states to unverified so verification can be
+  retried.
+
+### Reword
+
+- `r` is available only after history completion and only on the newest
+  selectable row, where tix assumes the commit has no displayed descendants.
+- The configured Git editor receives a document containing `Author`,
+  `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
+  message. Author identity and time are retained; committer time defaults to now.
+- `CommentChar` is a non-empty single-line byte prefix, defaults to `;`, and is
+  recognized only at column zero. Parsing removes those lines and applies
+  Git-style whitespace cleanup.
+- Missing `Assisted-by: GPT 5.6` and
+  `Co-authored-by: GPT 5.6 <codex@openai.com>` trailers are offered as commented
+  opt-ins. A case-insensitive existing trailer key suppresses its suggestion,
+  regardless of value.
+- An unchanged editor document is a no-op. Otherwise tix recreates the commit,
+  signs it when commit-signing configuration is enabled, and atomically retargets
+  mutable local refs that pointed directly at the old commit. Tags and
+  remote-tracking refs remain unchanged; a detached `HEAD` is retargeted.
+- Editor, signing, parsing, writing, or reference-update failures are shown in
+  the main status line and do not leave a repository retained by the UI.
+
+## Refresh, focus, and diagnostics
+
+- Native reference watchers observe `HEAD`, loose and packed refs, and the direct
+  or symbolic refs used by view and hide revspecs. Missing refs during an atomic
+  update are transient; malformed or inaccessible refs remain errors.
+- Ref changes that affect view or hidden tips trigger an incremental history
+  refresh. Decoration-only changes avoid traversal. Filesystem-driven traversal
+  changes select the newest selectable row; manual refresh and display toggles
+  preserve selection when possible.
+- The worktree watcher exists only while the combined worktree block is enabled.
+  It observes the index and ignore-aware directories that Git status would walk,
+  using non-recursive registrations so ignored build trees do not generate work.
+- Access-only and incomplete `.lock` activity are ignored. Completed atomic
+  renames, index/HEAD updates, relevant worktree paths, and backend rescan requests
+  invalidate the appropriate cache.
+- Worktree updates retain the history selection and restore changed-path
+  selection by raw path and relative viewport position. They never select the
+  newest commit merely because status changed.
+- Event batches are bounded and coalesced. Worktree status waits 75 ms of quiet;
+  reference transactions wait for their final update. Watchers retry after
+  failure while still needed.
+- Refresh status remains hidden for 500 ms so quick background work does not
+  flicker the footer.
+- A filesystem history refresh is presented immediately. New or replaced visible
+  rows are bold for 180 ms, matched first by commit ID and then by tree ID so
+  rewords retain visual identity. Removals, unrelated replacements, manual
+  actions, hidden toggles, and worktree-only updates are immediate without
+  emphasis. Input, focus changes, and resizing end emphasis immediately.
+- While the terminal is unfocused, filesystem-attributed redraws replace footer
+  separators with persistent orange discs. Focus restores normal separators.
+- Filesystem responses receive correlated IDs in daily tracing logs, including
+  semantic trigger, coalesced paths, phases, presentation count, elapsed time,
+  and outcome. Logs use the platform application-log directory, retain seven
+  days, and are best-effort.
+- If a linked worktree disappears, tix lexically normalizes and enters the common
+  repository, reopens it as bare, drops worktree state, keeps tree/history views
+  live, and reports recovery in the status line. If recovery fails, terminal state
+  is restored and the contextual error is returned.
+
+## Resource and responsiveness invariants
+
+- No `gix::Repository`, commit-graph, object platform, notes platform, or other
+  repository-owning value may remain in idle application/event-loop state.
+- View population opens a fresh non-isolated repository so mailmap, notes, diff
+  drivers, pagers, signing, and other Git configuration are current. It starts
+  without an object cache; bounded diff operations may enable one temporarily and
+  disable it again before any navigation reuse. Detached display data is retained.
+- One fill repository may be shared by commit, tree, worktree, and metadata loads
+  during continuous key-repeat or mouse navigation. It is dropped after the
+  75 ms idle boundary.
+- Traversal and incremental refresh workers may use a bounded object cache and
+  must drop their repository when finished. Lane, verification, and line-diff
+  workers exist only for active work and do not form persistent pools.
+- Redraw is reactive and capped at approximately 60 frames per second while
+  streaming. Mouse events are drained and coalesced in bounded batches so input
+  storms cannot starve the main loop.
+- Main status remains readable regardless of pane focus. Errors are surfaced in
+  the nearest relevant status line; diagnostics never replace user-visible
+  errors.
+
+## Regression coverage
+
+- Unit tests cover navigation, projections, pane layout, status summaries,
+  selection restoration, watcher classification, cached graph walks, diff
+  preparation, signatures, rewording, and terminal rendering.
+- Filesystem row emphasis uses `insta` snapshots containing every distinct frame;
+  unchanged hold frames are omitted. Run `cargo insta test -p gix-tix -F sha1`
+  and review with `cargo insta review`; never edit snapshots manually.
+- Behavior changes to this specification require corresponding tests and an
+  update to this document in the same semantic patch.

From 1b53cfff47e6e1807041de5c3fd9ec3cdc36948d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 11:23:15 +0200
Subject: [PATCH 047/282] feat: use a Markdown buffer for tix rewording

Give the temporary commit-edit document an .md suffix so editors can select Markdown syntax highlighting while retaining automatic cleanup and the existing Git-selected editor flow.

Record the filename contract in the tix specification.
---
 gix-tix/spec.md    | 3 ++-
 gix-tix/src/lib.rs | 4 ++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e734095b376..7e4b199c6b8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -244,7 +244,8 @@ space first; changes blocks adapt within the remaining history width.
   selectable row, where tix assumes the commit has no displayed descendants.
 - The configured Git editor receives a document containing `Author`,
   `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
-  message. Author identity and time are retained; committer time defaults to now.
+  message in a temporary `.md` file for syntax highlighting. Author identity and
+  time are retained; committer time defaults to now.
 - `CommentChar` is a non-empty single-line byte prefix, defaults to `;`, and is
   recognized only at column zero. Parsing removes those lines and applies
   Git-style whitespace cleanup.
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index f541a2514ce..0ed87c54105 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2523,8 +2523,8 @@ fn reword_commit(
         repository.object_cache_size(None);
         reword::document(&repository, id)?
     };
-    let mut tempfile = gix::tempfile::new(
-        std::env::temp_dir(),
+    let mut tempfile = gix::tempfile::writable_at(
+        std::env::temp_dir().join(format!("tix-reword-{}.md", std::process::id())),
         gix::tempfile::ContainingDirectory::Exists,
         gix::tempfile::AutoRemove::Tempfile,
     )

From acfef7e642f296e8497c790a1fc1ec175eace50a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 13:58:44 +0200
Subject: [PATCH 048/282] feat: add time-travel checkouts to tix

Let t detach HEAD at the selected commit through git checkout while preserving descendants that would otherwise disappear behind namespaced refs/tix/pins references.

Discover applicable pins for detached HEAD even with explicit revisions, follow symbolic branch targets as they advance, and return through a selected pin by restoring its branch or detached commit before removing it. Use the cached history graph to decide whether the old tip needs protection and discard provisional pins when existing view tips already retain it.

Keep malformed, dangling, and non-commit pins out of history, surface checkout failures without forcing local changes, refresh history and worktree state after success, and document the lifecycle and UI contract.
---
 gix-tix/spec.md            |  23 +++
 gix-tix/src/app.rs         |  25 +++
 gix-tix/src/history.rs     | 175 ++++++++++++++++--
 gix-tix/src/lib.rs         |  29 ++-
 gix-tix/src/time_travel.rs | 363 +++++++++++++++++++++++++++++++++++++
 gix-tix/src/ui.rs          |  69 +++++++
 6 files changed, 671 insertions(+), 13 deletions(-)
 create mode 100644 gix-tix/src/time_travel.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7e4b199c6b8..acbc8ef57ce 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -136,11 +136,34 @@ without trading responsiveness for metadata that is not visible.
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
+| `t` | Time-travel to the selected commit, or return through its tix pin. |
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. `[` and overlay controls remain direct
 shortcuts.
 
+### Time-travel
+
+- On a completed, focused history in a worktree repository, `t` on a non-`HEAD`
+  row runs `git checkout --detach <commit>` without forcing local changes.
+- If the selected commit is known to be an ancestor of the previous `HEAD`, tix
+  retains descendants that would otherwise leave the view with a
+  `refs/tix/pins/<suffix>` ref. Pins use at least four alphanumeric characters;
+  generated pins start with eight hexadecimal characters from the saved commit.
+- A pin is symbolic when the previous `HEAD` named a local branch, so later branch
+  advances move the pinned tip. An already detached `HEAD` receives a direct pin.
+- While `HEAD` is detached, applicable pins augment implicit and explicit revision
+  tips when their ancestry contains `HEAD`. Unrelated, dangling, malformed, and
+  non-commit pins do not enter the view or its decorations. Normal hidden-revision
+  exclusions still apply.
+- Applicable pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
+  tip checks out its underlying branch, or its direct commit in detached mode,
+  then removes that one pin. Multiple matching pins prefer symbolic targets and
+  then lexical ref-name order.
+- Checkout failures retain the original `HEAD` and remove any newly created
+  provisional pin. Successful travel preserves the selected row, refreshes
+  history directly, and invalidates worktree status.
+
 ### Held Shift ancestry mode
 
 - On terminals that report modifier press and release events, pressing Shift in
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index a46a03b5bc8..2db09a7a43b 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -283,6 +283,7 @@ pub(crate) enum Action {
     CycleChangesParent,
     OpenDiff,
     Reword,
+    TimeTravel,
     VerifySignatures,
     Cancel,
     Copy,
@@ -303,6 +304,7 @@ pub(crate) enum Effect {
     OpenDiff(ChangePane, usize),
     OpenCommitDiff(ObjectId),
     Reword(ObjectId),
+    TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -763,6 +765,11 @@ impl App {
                     self.rows[self.selected.expect("reword requires a selection")].id,
                 )];
             }
+            Action::TimeTravel if self.time_travel_shortcut_visible() => {
+                return vec![Effect::TimeTravel(
+                    self.rows[self.selected.expect("time-travel requires a selection")].id,
+                )];
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -1215,6 +1222,13 @@ impl App {
             && self.selected == self.first_selectable()
     }
 
+    pub(crate) fn time_travel_shortcut_visible(&self) -> bool {
+        self.worktree_changes_available
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.selected.is_some()
+    }
+
     fn last_selectable(&self) -> Option<usize> {
         (0..self.rows.len()).rev().find(|index| !self.is_row_hidden(*index))
     }
@@ -1878,6 +1892,17 @@ mod tests {
         assert!(app.update(Action::Reword).is_empty());
     }
 
+    #[test]
+    fn time_travel_requires_completed_history_and_a_worktree() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row(1)]);
+        assert!(app.update(Action::TimeTravel).is_empty());
+        complete(&mut app);
+        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
+        app.set_worktree_changes_available(false);
+        assert!(app.update(Action::TimeTravel).is_empty());
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 3e743f8bb58..2e494e750a3 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -29,6 +29,7 @@ pub(crate) struct Decoration {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum DecorationKind {
     Head,
+    Pin,
     Local,
     Remote,
     Tag,
@@ -38,6 +39,15 @@ pub(crate) enum DecorationKind {
 
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
+pub(crate) const PIN_PREFIX: &[u8] = b"refs/tix/pins/";
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Pin {
+    pub name: gix::refs::FullName,
+    pub target: gix::refs::Target,
+    pub id: ObjectId,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct SelectionRef {
     pub name: BString,
@@ -152,6 +162,24 @@ impl HistoryGraph {
         &self.parents[range.start as usize..range.end as usize]
     }
 
+    pub(crate) fn is_ancestor(&self, ancestor: ObjectId, descendant: ObjectId) -> bool {
+        let (Some(ancestor), Some(descendant)) = (self.index(ancestor), self.index(descendant)) else {
+            return false;
+        };
+        let mut seen = vec![false; self.commits.len()];
+        let mut pending = vec![descendant];
+        while let Some(index) = pending.pop() {
+            if index == ancestor {
+                return true;
+            }
+            if std::mem::replace(&mut seen[index.as_usize()], true) {
+                continue;
+            }
+            pending.extend_from_slice(self.parents(index));
+        }
+        false
+    }
+
     fn parent_ids(&self, index: CommitIndex) -> gix::traverse::commit::ParentIds {
         self.parents(index).iter().map(|parent| self.id(*parent)).collect()
     }
@@ -546,9 +574,10 @@ impl HistoryGraph {
             }
         }
         self.tracking = tracking;
+        let decorations = decorations(repo, &refs.pins)?;
         Ok(Refresh {
             refs,
-            decorations: decorations(repo)?,
+            decorations,
             commits: LoadedCommits { rows, attributions },
         })
     }
@@ -560,6 +589,7 @@ pub(crate) struct RefSnapshot {
     pub hidden: HashMap<BString, gix::refs::Target>,
     pub view_tips: Vec<ObjectId>,
     pub hidden_tips: Vec<ObjectId>,
+    pub pins: Vec<Pin>,
 }
 
 #[derive(Debug)]
@@ -732,15 +762,17 @@ pub(crate) fn load(
     cancelled: &AtomicBool,
     mut emit: impl FnMut(Event) -> bool,
 ) -> Result<()> {
-    let Some(tips) = resolve_tips(repo, revisions)? else {
-        emit(Event::Decorations(decorations(repo)?));
+    let refs = snapshot(repo, revisions, hidden_revisions)?;
+    let tips = refs.view_tips;
+    if tips.is_empty() {
+        emit(Event::Decorations(decorations(repo, &refs.pins)?));
         emit(Event::VisibleComplete);
         emit(Event::Complete(HistoryGraph::default()));
         return Ok(());
-    };
-    let hidden_tips = resolve_revisions(repo, hidden_revisions, "hidden ")?;
+    }
+    let hidden_tips = refs.hidden_tips;
 
-    if !emit(Event::Decorations(decorations(repo)?)) {
+    if !emit(Event::Decorations(decorations(repo, &refs.pins)?)) {
         return Ok(());
     }
     let shallow: HashSet<_> = repo
@@ -954,14 +986,101 @@ pub(crate) fn load(
 }
 
 pub(crate) fn snapshot(repo: &gix::Repository, revisions: &[OsString], hidden: &[OsString]) -> Result<RefSnapshot> {
+    snapshot_ignoring_pin(repo, revisions, hidden, None)
+}
+
+pub(crate) fn snapshot_ignoring_pin(
+    repo: &gix::Repository,
+    revisions: &[OsString],
+    hidden: &[OsString],
+    ignored_pin: Option<&BStr>,
+) -> Result<RefSnapshot> {
+    let pins = applicable_pins(repo)?
+        .into_iter()
+        .filter(|pin| ignored_pin != Some(pin.name.as_bstr()))
+        .collect::<Vec<_>>();
+    let mut view = referenced_refs(repo, revisions)?;
+    for pin in &pins {
+        insert_ref_chain(repo, pin.name.as_bstr(), &mut view)?;
+    }
+    let mut view_tips = resolve_tips(repo, revisions)?.unwrap_or_default();
+    view_tips.extend(pins.iter().map(|pin| pin.id));
+    let mut seen = HashSet::new();
+    view_tips.retain(|id| seen.insert(*id));
     Ok(RefSnapshot {
-        view: referenced_refs(repo, revisions)?,
+        view,
         hidden: referenced_refs(repo, hidden)?,
-        view_tips: resolve_tips(repo, revisions)?.unwrap_or_default(),
+        view_tips,
         hidden_tips: resolve_revisions(repo, hidden, "hidden ")?,
+        pins,
     })
 }
 
+pub(crate) fn all_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
+    let mut out = Vec::new();
+    let references = repo.references().context("could not open references")?;
+    for reference in references
+        .prefixed(PIN_PREFIX.as_bstr())
+        .context("could not iterate tix pins")?
+    {
+        let mut reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read tix pin: {err}")),
+        };
+        let suffix = reference.name().as_bstr().strip_prefix(PIN_PREFIX).unwrap_or_default();
+        if suffix.len() < 4 || !suffix.iter().all(u8::is_ascii_alphanumeric) {
+            tracing::warn!(name = %reference.name(), "ignoring malformed tix pin");
+            continue;
+        }
+        let name = reference.name().to_owned();
+        let target = reference.target().into_owned();
+        let id = match reference.peel_to_id() {
+            Ok(id) => id.detach(),
+            Err(err) => {
+                tracing::warn!(name = %name, error = %err, "ignoring unresolved tix pin");
+                continue;
+            }
+        };
+        match repo.find_header(id) {
+            Ok(header) if header.kind() == gix::object::Kind::Commit => {}
+            Ok(_) => {
+                tracing::warn!(name = %name, "ignoring tix pin that does not resolve to a commit");
+                continue;
+            }
+            Err(err) => {
+                tracing::warn!(name = %name, error = %err, "ignoring unreadable tix pin target");
+                continue;
+            }
+        }
+        out.push(Pin { name, target, id });
+    }
+    out.sort_by(|a, b| a.name.cmp(&b.name));
+    Ok(out)
+}
+
+pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
+    let head = repo.head().context("could not read HEAD while resolving tix pins")?;
+    if !head.is_detached() {
+        return Ok(Vec::new());
+    }
+    let Some(head) = head.id().map(gix::Id::detach) else {
+        return Ok(Vec::new());
+    };
+    all_pins(repo)?
+        .into_iter()
+        .filter_map(|pin| match repo.merge_base(head, pin.id) {
+            Ok(base) => Some(Ok((base.as_ref() == head).then_some(pin))),
+            Err(gix::repository::merge_base::Error::NotFound { .. }) => None,
+            Err(err) => Some(Err(err).context("could not determine tix pin reachability")),
+        })
+        .filter_map(|result| match result {
+            Ok(pin) => pin.map(Ok),
+            Err(err) => Some(Err(err)),
+        })
+        .collect()
+}
+
 fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {
     let implicit_head = OsString::from("HEAD");
     let revisions = if revisions.is_empty() {
@@ -1155,8 +1274,9 @@ impl Authors {
     }
 }
 
-pub(crate) fn decorations(repo: &gix::Repository) -> Result<Decorations> {
+pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin]) -> Result<Decorations> {
     let mut out = Decorations::new();
+    let pins: HashSet<_> = pins.iter().map(|pin| pin.name.as_bstr()).collect();
     for reference in repo
         .references()
         .context("could not open references")?
@@ -1168,6 +1288,10 @@ pub(crate) fn decorations(repo: &gix::Repository) -> Result<Decorations> {
             Err(err) if is_missing_ref(&*err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
+        let pin_suffix = reference.name().as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
+        if pin_suffix.is_some() && !pins.contains(reference.name().as_bstr()) {
+            continue;
+        }
         let mut kind = decoration_kind(reference.name().as_bstr());
         if kind == DecorationKind::Tag {
             let annotated = match reference.try_id() {
@@ -1182,7 +1306,10 @@ pub(crate) fn decorations(repo: &gix::Repository) -> Result<Decorations> {
             continue;
         };
         let id = id.detach();
-        let mut name = reference.name().shorten().to_owned();
+        let mut name = pin_suffix.map_or_else(
+            || reference.name().shorten().to_owned(),
+            |suffix| format!("pin:{}", suffix.to_str_lossy()).into(),
+        );
         if matches!(kind, DecorationKind::Tag | DecorationKind::AnnotatedTag) {
             name.insert_str(0, "tag: ");
         }
@@ -1216,7 +1343,9 @@ fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
 }
 
 fn decoration_kind(name: &[u8]) -> DecorationKind {
-    if name.starts_with(b"refs/heads/") {
+    if name.starts_with(PIN_PREFIX) {
+        DecorationKind::Pin
+    } else if name.starts_with(b"refs/heads/") {
         DecorationKind::Local
     } else if name.starts_with(b"refs/tags/") {
         DecorationKind::Tag
@@ -1739,6 +1868,7 @@ mod tests {
 
     #[test]
     fn classifies_reference_kinds() {
+        assert_eq!(decoration_kind(b"refs/tix/pins/abcd"), DecorationKind::Pin);
         assert_eq!(decoration_kind(b"refs/heads/main"), DecorationKind::Local);
         assert_eq!(decoration_kind(b"refs/tags/v1"), DecorationKind::Tag);
         assert_eq!(decoration_kind(b"refs/remotes/origin/main"), DecorationKind::Remote);
@@ -1746,6 +1876,29 @@ mod tests {
         assert_eq!(decoration_kind(b"refs/stash"), DecorationKind::Special);
     }
 
+    #[test]
+    fn ignores_malformed_and_non_commit_pins() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let head = repo.head_id()?.detach();
+        let blob = repo.write_blob(b"not a commit")?.detach();
+        repo.reference(
+            "refs/tix/pins/a",
+            head,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test malformed pin",
+        )?;
+        repo.reference(
+            "refs/tix/pins/abcd",
+            blob,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test non-commit pin",
+        )?;
+
+        assert!(all_pins(&repo)?.is_empty(), "invalid pins never enter history");
+        Ok(())
+    }
+
     #[test]
     fn interns_raw_author_identities() {
         let mut authors = Authors::default();
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 0ed87c54105..40619db8acf 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -7,6 +7,7 @@ mod app;
 mod history;
 mod logging;
 mod reword;
+mod time_travel;
 mod ui;
 
 use std::{
@@ -1611,6 +1612,26 @@ fn event_loop(
                         Err(err) => app.notice = Some(format!("reword: {err:#}")),
                     }
                 }
+                Effect::TimeTravel(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = history_graph
+                        .as_ref()
+                        .context("time-travel requires a completed history graph")
+                        .and_then(|graph| {
+                            time_travel::perform(&repository_path, repository_is_bare, id, graph, &revisions)
+                        });
+                    match result {
+                        Ok(Some(notice)) => {
+                            tracing::info!(selected = %id, %notice, "completed time-travel action");
+                            app.notice = Some(notice);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Ok(None) => {}
+                        Err(err) => app.notice = Some(format!("time-travel: {err:#}")),
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -3234,6 +3255,7 @@ fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) ->
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
         KeyCode::Char('r') => Some(Action::Reword),
+        KeyCode::Char('t') => Some(Action::TimeTravel),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
@@ -3549,7 +3571,7 @@ mod tests {
             },
         )?;
         let mut graph = graph.expect("history traversal returns its graph");
-        let refs = graph.selection_refs(topic, &history::decorations(&repository)?);
+        let refs = graph.selection_refs(topic, &history::decorations(&repository, &[])?);
         assert_eq!(refs[0].upstream, Some(Some(main)));
         assert_eq!(
             graph.selection_relation(topic, &refs, &[]),
@@ -4059,12 +4081,15 @@ mod tests {
         assert_eq!(action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
             Some(Action::Reword)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)),
+            Some(Action::TimeTravel)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
diff --git a/gix-tix/src/time_travel.rs b/gix-tix/src/time_travel.rs
new file mode 100644
index 00000000000..2fe5f2efc8c
--- /dev/null
+++ b/gix-tix/src/time_travel.rs
@@ -0,0 +1,363 @@
+use std::{ffi::OsString, path::Path, process::Command};
+
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::ByteSlice,
+    refs::{
+        Target,
+        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+    },
+};
+
+use crate::{history, open_repository};
+
+pub(crate) fn perform(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    graph: &history::HistoryGraph,
+    revisions: &[OsString],
+) -> Result<Option<String>> {
+    let repository =
+        open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
+    let workdir = repository
+        .workdir()
+        .context("time-travel requires a worktree")?
+        .to_owned();
+    let head = repository.head().context("could not read HEAD before time-travel")?;
+    let Some(head_id) = head.id().map(gix::Id::detach) else {
+        anyhow::bail!("cannot time-travel from an unborn HEAD");
+    };
+    if selected == head_id {
+        return Ok(None);
+    }
+    if let Some(pin) = selected_pin(&repository, selected)? {
+        drop(repository);
+        checkout_pin(&workdir, &pin)?;
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not reopen repository after returning from time-travel")?;
+        return Ok(Some(match delete_pin(&repository, &pin) {
+            Ok(()) => format!("returned from {}", pin_label(&pin)),
+            Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
+        }));
+    }
+    let saved_target = head
+        .referent_name()
+        .map(|name| Target::Symbolic(name.to_owned()))
+        .unwrap_or(Target::Object(head_id));
+    let provisional = graph
+        .is_ancestor(selected, head_id)
+        .then(|| create_or_reuse_pin(&repository, saved_target, head_id))
+        .transpose()?;
+    drop(repository);
+
+    if let Err(checkout) = checkout_detached(&workdir, selected) {
+        if let Some((pin, true)) = &provisional {
+            let cleanup = open_repository(repository_path, bare, false)
+                .context("could not reopen repository to remove a provisional pin")
+                .and_then(|repository| delete_pin(&repository, pin));
+            if let Err(cleanup) = cleanup {
+                return Err(checkout.context(format!(
+                    "checkout failed and {} could not be removed: {cleanup:#}",
+                    pin_label(pin)
+                )));
+            }
+        }
+        return Err(checkout);
+    }
+
+    let mut notice = format!("time-travelled to {}", selected.to_hex_with_len(7));
+    if let Some((pin, true)) = provisional {
+        let repository =
+            open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
+        let snapshot = history::snapshot_ignoring_pin(&repository, revisions, &[], Some(pin.name.as_bstr()))?;
+        if snapshot
+            .view_tips
+            .iter()
+            .copied()
+            .any(|tip| contains(&repository, head_id, tip))
+        {
+            if let Err(err) = delete_pin(&repository, &pin) {
+                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
+            }
+        } else {
+            notice = format!("{notice}; saved {}", pin_label(&pin));
+        }
+    }
+    Ok(Some(notice))
+}
+
+fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
+    let mut pins: Vec<_> = history::applicable_pins(repository)?
+        .into_iter()
+        .filter(|pin| pin.id == selected)
+        .collect();
+    pins.sort_by(|a, b| {
+        a.target
+            .try_name()
+            .is_none()
+            .cmp(&b.target.try_name().is_none())
+            .then_with(|| a.name.cmp(&b.name))
+    });
+    Ok(pins.into_iter().next())
+}
+
+fn create_or_reuse_pin(repository: &gix::Repository, target: Target, id: ObjectId) -> Result<(history::Pin, bool)> {
+    let pins = history::all_pins(repository)?;
+    if let Some(pin) = pins.iter().find(|pin| pin.target == target) {
+        return Ok((pin.clone(), false));
+    }
+    let hex = id.to_hex().to_string();
+    let mut suffix_len = 8.min(hex.len());
+    let mut number = 2;
+    let name = loop {
+        let suffix = if suffix_len <= hex.len() {
+            hex[..suffix_len].to_owned()
+        } else {
+            let suffix = format!("{hex}{number}");
+            number += 1;
+            suffix
+        };
+        let name: gix::refs::FullName = format!("{}{}", String::from_utf8_lossy(history::PIN_PREFIX), suffix)
+            .try_into()
+            .context("generated an invalid tix pin name")?;
+        if repository
+            .try_find_reference(name.as_ref())
+            .context("could not check for a colliding tix pin")?
+            .is_none()
+        {
+            break name;
+        }
+        if suffix_len < hex.len() {
+            suffix_len += 1;
+        } else {
+            suffix_len = hex.len() + 1;
+        }
+    };
+    repository
+        .edit_references_as(
+            [RefEdit {
+                change: Change::Update {
+                    log: LogChange {
+                        mode: RefLog::AndReference,
+                        force_create_reflog: false,
+                        message: "tix time-travel".into(),
+                    },
+                    expected: PreviousValue::MustNotExist,
+                    new: target.clone(),
+                },
+                name: name.clone(),
+                deref: false,
+            }],
+            None,
+        )
+        .context("could not create tix pin")?;
+    Ok((history::Pin { name, target, id }, true))
+}
+
+fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
+    repository
+        .edit_references_as(
+            [RefEdit {
+                change: Change::Delete {
+                    expected: PreviousValue::MustExistAndMatch(pin.target.clone()),
+                    log: RefLog::AndReference,
+                },
+                name: pin.name.clone(),
+                deref: false,
+            }],
+            None,
+        )
+        .context("could not remove tix pin")?;
+    Ok(())
+}
+
+fn checkout_pin(workdir: &Path, pin: &history::Pin) -> Result<()> {
+    match pin.target.try_name() {
+        Some(name) => {
+            let branch = name
+                .as_bstr()
+                .strip_prefix(b"refs/heads/")
+                .context("a symbolic tix pin does not point to a local branch")?;
+            checkout(
+                workdir,
+                [
+                    OsString::from("--no-guess"),
+                    gix::path::from_bstr(branch.as_bstr()).into_owned().into_os_string(),
+                ],
+            )
+        }
+        None => checkout_detached(workdir, pin.id),
+    }
+}
+
+fn checkout_detached(workdir: &Path, id: ObjectId) -> Result<()> {
+    checkout(
+        workdir,
+        [OsString::from("--detach"), OsString::from(id.to_hex().to_string())],
+    )
+}
+
+fn checkout(workdir: &Path, args: impl IntoIterator<Item = OsString>) -> Result<()> {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .arg("checkout")
+        .args(args)
+        .output()
+        .context("could not launch git checkout")?;
+    if output.status.success() {
+        return Ok(());
+    }
+    let stderr = output.stderr.trim().to_str_lossy();
+    if stderr.is_empty() {
+        anyhow::bail!("git checkout failed with {}", output.status)
+    }
+    anyhow::bail!("git checkout failed with {}: {}", output.status, stderr)
+}
+
+fn contains(repository: &gix::Repository, ancestor: ObjectId, descendant: ObjectId) -> bool {
+    ancestor == descendant
+        || repository
+            .merge_base(ancestor, descendant)
+            .is_ok_and(|base| base.as_ref() == ancestor)
+}
+
+fn pin_label(pin: &history::Pin) -> String {
+    format!(
+        "pin:{}",
+        pin.name
+            .as_bstr()
+            .strip_prefix(history::PIN_PREFIX)
+            .unwrap_or(pin.name.as_bstr())
+            .to_str_lossy()
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::atomic::AtomicBool;
+
+    use super::*;
+
+    fn loaded_graph(repository: &gix::Repository, revisions: &[OsString]) -> Result<history::HistoryGraph> {
+        let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+            history::Authors::default(),
+        ));
+        let mut graph = None;
+        history::load(repository, revisions, &[], &authors, &AtomicBool::new(false), |event| {
+            if let history::Event::Complete(value) = event {
+                graph = Some(value);
+            }
+            true
+        })?;
+        graph.context("history traversal did not produce a graph")
+    }
+
+    #[test]
+    fn travels_with_symbolic_and_direct_pins_and_returns() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = gix::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        assert!(graph.is_ancestor(root, main), "the selected root is known ancestry");
+        assert!(history::all_pins(&repository)?.is_empty());
+        assert_eq!(
+            open_repository(&repository_path, false, false)?.head_id()?.detach(),
+            main
+        );
+        assert!(!contains(&repository, main, root));
+        drop(repository);
+
+        let notice = perform(&repository_path, false, root, &graph, &[])?.context("time-travel changed HEAD")?;
+        assert!(notice.contains("saved pin:"), "{notice}");
+        let repository = gix::open(fixture.path())?;
+        assert!(repository.head()?.is_detached(), "travel detaches HEAD");
+        assert_eq!(repository.head_id()?.detach(), root);
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the lost branch tip gets one pin");
+        assert_eq!(
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(b"refs/heads/main".as_bstr())
+        );
+        assert_eq!(pins[0].id, main);
+        assert!(history::snapshot(&repository, &[], &[])?.view_tips.contains(&main));
+
+        repository
+            .find_reference("refs/heads/main")?
+            .set_target_id(topic, "advance pinned branch")?;
+        let advanced = history::snapshot(&repository, &[], &[])?;
+        assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
+        drop(repository);
+
+        perform(&repository_path, false, topic, &graph, &[])?;
+        let repository = gix::open(fixture.path())?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "returning through a symbolic pin reattaches HEAD"
+        );
+        assert!(history::all_pins(&repository)?.is_empty(), "the used pin is removed");
+
+        let detach = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["checkout", "--detach", &main.to_hex().to_string()])
+            .status()?;
+        assert!(detach.success());
+        let graph = loaded_graph(&gix::open(fixture.path())?, &[])?;
+        perform(&repository_path, false, root, &graph, &[])?;
+        let pin = history::all_pins(&gix::open(fixture.path())?)?
+            .pop()
+            .context("direct pin is present")?;
+        assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
+        perform(&repository_path, false, main, &graph, &[])?;
+        let repository = gix::open(fixture.path())?;
+        assert!(
+            repository.head()?.is_detached(),
+            "a direct pin returns to detached HEAD"
+        );
+        assert_eq!(repository.head_id()?.detach(), main);
+        assert!(history::all_pins(&repository)?.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn explicit_tips_avoid_redundant_pins_and_failed_checkouts_clean_up() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = gix::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let revisions = [OsString::from("main")];
+        let graph = loaded_graph(&repository, &revisions)?;
+        drop(repository);
+
+        perform(&repository_path, false, root, &graph, &revisions)?;
+        assert!(
+            history::all_pins(&gix::open(fixture.path())?)?.is_empty(),
+            "an explicit tip already retains the former HEAD"
+        );
+
+        let checkout = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["checkout", "--no-guess", "main"])
+            .status()?;
+        assert!(checkout.success());
+        std::fs::write(fixture.path().join("main"), "dirty\n")?;
+        let err = perform(&repository_path, false, root, &graph, &[]).expect_err("Git rejects a conflicting checkout");
+        assert!(format!("{err:#}").contains("git checkout failed"));
+        let repository = gix::open(fixture.path())?;
+        assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
+        assert!(
+            history::all_pins(&repository)?.is_empty(),
+            "the provisional pin is removed"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index d0aba8b5934..3ba9eeb12a6 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -630,6 +630,30 @@ pub(crate) fn draw_with_worktree(
     ))];
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · Enter diff"));
+        if app.time_travel_shortcut_visible()
+            && decorations
+                .values()
+                .flatten()
+                .any(|decoration| decoration.kind == DecorationKind::Head)
+            && let Some(selected) = app.selected.and_then(|index| app.rows.get(index))
+        {
+            let selected_refs = decorations.get(&selected.id).map(Vec::as_slice).unwrap_or_default();
+            if !selected_refs
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Head)
+            {
+                footer_spans.push(Span::raw(
+                    if selected_refs
+                        .iter()
+                        .any(|decoration| decoration.kind == DecorationKind::Pin)
+                    {
+                        " · t return"
+                    } else {
+                        " · t travel"
+                    },
+                ));
+            }
+        }
         if app.reword_shortcut_visible() {
             footer_spans.push(Span::raw(" · r reword"));
         }
@@ -1511,6 +1535,7 @@ fn author_label(
 fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
+        DecorationKind::Pin => Style::default().fg(Color::Blue),
         DecorationKind::Local => Style::default().fg(Color::Cyan),
         DecorationKind::Remote => Style::default().fg(Color::Yellow),
         DecorationKind::Tag => Style::default().fg(Color::Magenta),
@@ -2317,6 +2342,50 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn advertises_travel_and_return_for_non_head_rows() -> Result<(), Box<dyn std::error::Error>> {
+        let selected = gix::ObjectId::Sha1([1; 20]);
+        let head = gix::ObjectId::Sha1([2; 20]);
+        let mut app = App::new(2);
+        app.extend_commits(vec![Commit {
+            id: selected,
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        complete(&mut app);
+        let mut decorations = Decorations::from([
+            (
+                selected,
+                vec![Decoration {
+                    name: "pin:01010101".into(),
+                    kind: DecorationKind::Pin,
+                }],
+            ),
+            (
+                head,
+                vec![Decoration {
+                    name: "HEAD".into(),
+                    kind: DecorationKind::Head,
+                }],
+            ),
+        ]);
+        let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(rendered_row(&terminal).contains("pin:01010101"));
+        assert!(rendered_line(&terminal, 1).contains("t return"));
+
+        decorations.remove(&selected);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(rendered_line(&terminal, 1).contains("t travel"));
+        Ok(())
+    }
+
     #[test]
     fn removes_the_copied_fields_color_from_only_the_selected_row_for_one_frame()
     -> Result<(), Box<dyn std::error::Error>> {

From d0f11cd835cdb007380aa18d7f891b135a7612f2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 14:27:23 +0200
Subject: [PATCH 049/282] feat: show other worktree checkouts in tix

Decorate commits checked out by other main or linked worktrees with light-blue name@ labels, replacing the ordinary branch label. Keep the checkout from which tix was opened represented by the graph @ marker and its ordinary local reference, and use directory basenames for other detached worktrees. Keep other-worktree labels visible on the selected row when references are hidden.

Add -w/--worktrees to include every successfully resolved worktree HEAD, including the current checkout, alongside implicit or explicit traversal tips without weakening hidden-revision exclusions. Discover worktrees from their private Git metadata so stale checkout directories remain useful, while malformed, unborn, or inaccessible entries are logged and skipped.

Watch linked HEAD and worktree membership changes so decorations and optional tips stay current, while ignoring unrelated linked indexes, logs, and metadata. Document the behavior and cover current, attached, detached, stale, malformed, hidden-reference, CLI, and watcher cases.
---
 gix-tix/spec.md            |  21 ++-
 gix-tix/src/history.rs     | 305 ++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs         | 153 +++++++++++++++++--
 gix-tix/src/logging.rs     |  16 ++
 gix-tix/src/main.rs        |  31 +++-
 gix-tix/src/time_travel.rs |  45 ++++--
 gix-tix/src/ui.rs          | 117 +++++++++++---
 7 files changed, 614 insertions(+), 74 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index acbc8ef57ce..6125d0f8538 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -15,6 +15,9 @@ without trading responsiveness for metadata that is not visible.
   from `HEAD` when none are supplied.
 - `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
+- `-w/--worktrees` adds every successfully resolved main and linked worktree
+  `HEAD` to the visible traversal tips, in addition to implicit or explicit
+  revisions. Hidden revisions still exclude matching ancestry.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
 - Revisions must resolve and peel to commits. Invalid or non-commit revisions are
@@ -68,7 +71,15 @@ without trading responsiveness for metadata that is not visible.
   being verified, green when verified, and bright red when verification fails.
 - The current `HEAD` commit uses `@` instead of the normal commit disc and keeps
   the same signature and selection coloring. It remains visible when textual
-  reference labels are hidden.
+  reference labels are hidden, and textual `HEAD` is never rendered alongside it.
+- Local branches checked out in other worktrees are displayed as `short-name@`
+  in light blue instead of their plain branch decoration. Other detached
+  worktrees use their checkout directory basename. The current worktree is
+  represented by the commit's `@` marker and ordinary local reference; identical
+  labels are deduplicated.
+- When reference labels are hidden, worktree labels are visible only on the
+  selected row. Stale, malformed, unborn, and otherwise unreadable worktree
+  entries are skipped without failing history loading.
 - The selected row uses `>` at the left. If the displayed worktree block is dirty,
   `D` is shown at the `HEAD` row instead; a separately selected row retains `>`.
 - Selection inversion covers the left marker, graph, commit marker, and hash.
@@ -285,9 +296,11 @@ space first; changes blocks adapt within the remaining history width.
 
 ## Refresh, focus, and diagnostics
 
-- Native reference watchers observe `HEAD`, loose and packed refs, and the direct
-  or symbolic refs used by view and hide revspecs. Missing refs during an atomic
-  update are transient; malformed or inaccessible refs remain errors.
+- Native reference watchers observe `HEAD`, loose and packed refs, linked-worktree
+  HEAD and membership changes, and the direct or symbolic refs used by view and
+  hide revspecs. Linked indexes, logs, locks, and unrelated metadata do not
+  trigger history refreshes. Missing refs during an atomic update are transient;
+  malformed or inaccessible ordinary refs remain errors.
 - Ref changes that affect view or hidden tips trigger an incremental history
   refresh. Decoration-only changes avoid traversal. Filesystem-driven traversal
   changes select the newest selectable row; manual refresh and display toggles
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 2e494e750a3..477a618df13 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -30,6 +30,8 @@ pub(crate) struct Decoration {
 pub(crate) enum DecorationKind {
     Head,
     Pin,
+    WorktreeBranch,
+    WorktreeDetached,
     Local,
     Remote,
     Tag,
@@ -48,6 +50,14 @@ pub(crate) struct Pin {
     pub id: ObjectId,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct WorktreeCheckout {
+    pub id: ObjectId,
+    pub name: BString,
+    pub reference: Option<gix::refs::FullName>,
+    pub is_current: bool,
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct SelectionRef {
     pub name: BString,
@@ -285,7 +295,7 @@ impl HistoryGraph {
             .into_iter()
             .flatten()
             .map(|decoration| {
-                let upstream = if decoration.kind == DecorationKind::Local {
+                let upstream = if matches!(decoration.kind, DecorationKind::Local | DecorationKind::WorktreeBranch) {
                     tracked
                         .into_iter()
                         .flatten()
@@ -393,10 +403,11 @@ impl HistoryGraph {
         repo: &gix::Repository,
         revisions: &[OsString],
         hidden_revisions: &[OsString],
+        include_worktrees: bool,
         expand: &HashSet<ObjectId>,
         authors: &SharedAuthors,
     ) -> Result<Refresh> {
-        let refs = snapshot(repo, revisions, hidden_revisions)?;
+        let refs = snapshot(repo, revisions, hidden_revisions, include_worktrees)?;
         let shallow: HashSet<_> = repo
             .shallow_commits()
             .context("could not read shallow commits")?
@@ -574,7 +585,7 @@ impl HistoryGraph {
             }
         }
         self.tracking = tracking;
-        let decorations = decorations(repo, &refs.pins)?;
+        let decorations = decorations(repo, &refs.pins, &refs.worktrees)?;
         Ok(Refresh {
             refs,
             decorations,
@@ -590,6 +601,7 @@ pub(crate) struct RefSnapshot {
     pub view_tips: Vec<ObjectId>,
     pub hidden_tips: Vec<ObjectId>,
     pub pins: Vec<Pin>,
+    pub worktrees: Vec<WorktreeCheckout>,
 }
 
 #[derive(Debug)]
@@ -758,21 +770,22 @@ pub(crate) fn load(
     repo: &gix::Repository,
     revisions: &[OsString],
     hidden_revisions: &[OsString],
+    include_worktrees: bool,
     authors: &SharedAuthors,
     cancelled: &AtomicBool,
     mut emit: impl FnMut(Event) -> bool,
 ) -> Result<()> {
-    let refs = snapshot(repo, revisions, hidden_revisions)?;
+    let refs = snapshot(repo, revisions, hidden_revisions, include_worktrees)?;
     let tips = refs.view_tips;
     if tips.is_empty() {
-        emit(Event::Decorations(decorations(repo, &refs.pins)?));
+        emit(Event::Decorations(decorations(repo, &refs.pins, &refs.worktrees)?));
         emit(Event::VisibleComplete);
         emit(Event::Complete(HistoryGraph::default()));
         return Ok(());
     }
     let hidden_tips = refs.hidden_tips;
 
-    if !emit(Event::Decorations(decorations(repo, &refs.pins)?)) {
+    if !emit(Event::Decorations(decorations(repo, &refs.pins, &refs.worktrees)?)) {
         return Ok(());
     }
     let shallow: HashSet<_> = repo
@@ -985,26 +998,36 @@ pub(crate) fn load(
     Ok(())
 }
 
-pub(crate) fn snapshot(repo: &gix::Repository, revisions: &[OsString], hidden: &[OsString]) -> Result<RefSnapshot> {
-    snapshot_ignoring_pin(repo, revisions, hidden, None)
+pub(crate) fn snapshot(
+    repo: &gix::Repository,
+    revisions: &[OsString],
+    hidden: &[OsString],
+    include_worktrees: bool,
+) -> Result<RefSnapshot> {
+    snapshot_ignoring_pin(repo, revisions, hidden, include_worktrees, None)
 }
 
 pub(crate) fn snapshot_ignoring_pin(
     repo: &gix::Repository,
     revisions: &[OsString],
     hidden: &[OsString],
+    include_worktrees: bool,
     ignored_pin: Option<&BStr>,
 ) -> Result<RefSnapshot> {
     let pins = applicable_pins(repo)?
         .into_iter()
         .filter(|pin| ignored_pin != Some(pin.name.as_bstr()))
         .collect::<Vec<_>>();
+    let worktrees = worktree_checkouts(repo);
     let mut view = referenced_refs(repo, revisions)?;
     for pin in &pins {
         insert_ref_chain(repo, pin.name.as_bstr(), &mut view)?;
     }
     let mut view_tips = resolve_tips(repo, revisions)?.unwrap_or_default();
     view_tips.extend(pins.iter().map(|pin| pin.id));
+    if include_worktrees {
+        view_tips.extend(worktrees.iter().map(|worktree| worktree.id));
+    }
     let mut seen = HashSet::new();
     view_tips.retain(|id| seen.insert(*id));
     Ok(RefSnapshot {
@@ -1013,9 +1036,98 @@ pub(crate) fn snapshot_ignoring_pin(
         view_tips,
         hidden_tips: resolve_revisions(repo, hidden, "hidden ")?,
         pins,
+        worktrees,
     })
 }
 
+pub(crate) fn worktree_checkouts(repo: &gix::Repository) -> Vec<WorktreeCheckout> {
+    let mut out = Vec::new();
+    let current_worktree = repo.worktree().map(|worktree| worktree.id().map(ToOwned::to_owned));
+    match repo.main_repo() {
+        Ok(main) if !main.is_bare() => {
+            let name = main.workdir().and_then(worktree_basename);
+            add_worktree_checkout(&main, name, b"main".as_bstr(), current_worktree == Some(None), &mut out);
+        }
+        Ok(_) => {}
+        Err(err) => tracing::warn!(error = %err, "ignoring inaccessible main worktree"),
+    }
+    match repo.worktrees() {
+        Ok(worktrees) => {
+            for proxy in worktrees {
+                let worktree = proxy.id().to_owned();
+                let name = proxy.base().ok().as_deref().and_then(worktree_basename);
+                let is_current = current_worktree
+                    .as_ref()
+                    .and_then(Option::as_ref)
+                    .is_some_and(|current| current == &worktree);
+                match proxy.into_repo_with_possibly_inaccessible_worktree() {
+                    Ok(repository) => {
+                        add_worktree_checkout(&repository, name, worktree.as_bstr(), is_current, &mut out);
+                    }
+                    Err(err) => {
+                        tracing::warn!(worktree = %worktree, error = %err, "ignoring inaccessible linked worktree");
+                    }
+                }
+            }
+        }
+        Err(err) => tracing::warn!(error = %err, "ignoring unreadable linked worktree list"),
+    }
+    out.sort_by(|a, b| {
+        a.id.cmp(&b.id)
+            .then_with(|| a.name.cmp(&b.name))
+            .then_with(|| a.reference.cmp(&b.reference))
+    });
+    out.dedup();
+    out
+}
+
+fn add_worktree_checkout(
+    repo: &gix::Repository,
+    detached_name: Option<BString>,
+    worktree: &BStr,
+    is_current: bool,
+    out: &mut Vec<WorktreeCheckout>,
+) {
+    let mut head = match repo.head() {
+        Ok(head) => head,
+        Err(err) => {
+            tracing::warn!(%worktree, error = %err, "ignoring worktree with unreadable HEAD");
+            return;
+        }
+    };
+    let reference = head.referent_name().map(ToOwned::to_owned);
+    let id = match head.try_peel_to_id() {
+        Ok(Some(id)) => id.detach(),
+        Ok(None) => return,
+        Err(err) => {
+            tracing::warn!(%worktree, error = %err, "ignoring worktree with unresolved HEAD");
+            return;
+        }
+    };
+    let name = match &reference {
+        Some(reference) => reference.shorten().to_owned(),
+        None => match detached_name {
+            Some(name) => name,
+            None => {
+                tracing::warn!(%worktree, "ignoring detached worktree without a directory basename");
+                return;
+            }
+        },
+    };
+    out.push(WorktreeCheckout {
+        id,
+        name,
+        reference,
+        is_current,
+    });
+}
+
+fn worktree_basename(path: &std::path::Path) -> Option<BString> {
+    path.file_name()
+        .and_then(|name| gix::path::os_str_into_bstr(name).ok())
+        .map(ToOwned::to_owned)
+}
+
 pub(crate) fn all_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
     let mut out = Vec::new();
     let references = repo.references().context("could not open references")?;
@@ -1274,7 +1386,7 @@ impl Authors {
     }
 }
 
-pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin]) -> Result<Decorations> {
+pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[WorktreeCheckout]) -> Result<Decorations> {
     let mut out = Decorations::new();
     let pins: HashSet<_> = pins.iter().map(|pin| pin.name.as_bstr()).collect();
     for reference in repo
@@ -1288,11 +1400,12 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin]) -> Result<Decora
             Err(err) if is_missing_ref(&*err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
-        let pin_suffix = reference.name().as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
-        if pin_suffix.is_some() && !pins.contains(reference.name().as_bstr()) {
+        let full_name = reference.name().to_owned();
+        let pin_suffix = full_name.as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
+        if pin_suffix.is_some() && !pins.contains(full_name.as_bstr()) {
             continue;
         }
-        let mut kind = decoration_kind(reference.name().as_bstr());
+        let mut kind = decoration_kind(full_name.as_bstr());
         if kind == DecorationKind::Tag {
             let annotated = match reference.try_id() {
                 Some(id) => id.header().context("could not inspect tag")?.kind() == gix::objs::Kind::Tag,
@@ -1306,8 +1419,13 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin]) -> Result<Decora
             continue;
         };
         let id = id.detach();
+        if worktrees.iter().any(|worktree| {
+            !worktree.is_current && worktree.id == id && worktree.reference.as_ref() == Some(&full_name)
+        }) {
+            kind = DecorationKind::WorktreeBranch;
+        }
         let mut name = pin_suffix.map_or_else(
-            || reference.name().shorten().to_owned(),
+            || full_name.shorten().to_owned(),
             |suffix| format!("pin:{}", suffix.to_str_lossy()).into(),
         );
         if matches!(kind, DecorationKind::Tag | DecorationKind::AnnotatedTag) {
@@ -1315,6 +1433,23 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin]) -> Result<Decora
         }
         out.entry(id).or_default().push(Decoration { name, kind });
     }
+    for worktree in worktrees.iter().filter(|worktree| !worktree.is_current) {
+        let kind = if worktree.reference.is_some() {
+            DecorationKind::WorktreeBranch
+        } else {
+            DecorationKind::WorktreeDetached
+        };
+        let decorations = out.entry(worktree.id).or_default();
+        if !decorations
+            .iter()
+            .any(|decoration| decoration.kind == kind && decoration.name == worktree.name)
+        {
+            decorations.push(Decoration {
+                name: worktree.name.clone(),
+                kind,
+            });
+        }
+    }
     if let Some(id) = repo
         .head()
         .context("could not read HEAD")?
@@ -1400,6 +1535,7 @@ mod tests {
             &repo,
             &revisions.iter().map(OsString::from).collect::<Vec<_>>(),
             &hidden_revisions.iter().map(OsString::from).collect::<Vec<_>>(),
+            false,
             &authors,
             &AtomicBool::new(false),
             |event| {
@@ -1527,8 +1663,8 @@ mod tests {
     #[test]
     fn snapshots_references_and_symbolic_targets_from_revisions() -> gix_testtools::Result {
         let fixture = fixture()?;
-        let repo = gix::open(fixture)?;
-        let implicit = snapshot(&repo, &[], &[])?;
+        let repo = crate::open_test_repository(fixture)?;
+        let implicit = snapshot(&repo, &[], &[], false)?;
         assert!(
             implicit.view.contains_key(b"HEAD".as_bstr()),
             "an implicit revision watches HEAD"
@@ -1538,12 +1674,137 @@ mod tests {
             "the symbolic target of HEAD is watched as well"
         );
 
-        let explicit = snapshot(&repo, &[OsString::from("main")], &[OsString::from("topic")])?;
+        let explicit = snapshot(&repo, &[OsString::from("main")], &[OsString::from("topic")], false)?;
         assert!(explicit.view.contains_key(b"refs/heads/main".as_bstr()));
         assert!(explicit.hidden.contains_key(b"refs/heads/topic".as_bstr()));
         Ok(())
     }
 
+    #[test]
+    fn discovers_worktree_decorations_and_optionally_adds_their_tips() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        for args in [
+            ["worktree", "add", "-q", "topic-wt", "topic"].as_slice(),
+            ["worktree", "add", "-q", "--detach", "detached-wt", "main~2"].as_slice(),
+            ["worktree", "add", "-q", "--detach", "broken-wt", "main~2"].as_slice(),
+        ] {
+            let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
+            assert!(status.success(), "git creates the worktree fixture");
+        }
+        std::fs::remove_dir_all(fixture.path().join("detached-wt"))?;
+        std::fs::write(
+            fixture.path().join(".git/worktrees/broken-wt/HEAD"),
+            "not a ref or object id\n",
+        )?;
+
+        let repo = crate::open_test_repository(fixture.path())?;
+        let main = repo.rev_parse_single("main")?.detach();
+        let topic = repo.rev_parse_single("topic")?.detach();
+        let root = repo.rev_parse_single("main~2")?.detach();
+        let worktrees = worktree_checkouts(&repo);
+        assert!(worktrees.iter().any(|worktree| {
+            worktree.id == main
+                && worktree.name == "main"
+                && worktree.is_current
+                && worktree
+                    .reference
+                    .as_ref()
+                    .is_some_and(|name| name.as_bstr() == b"refs/heads/main")
+        }));
+        assert!(worktrees.iter().any(|worktree| {
+            worktree.id == topic
+                && worktree.name == "topic"
+                && !worktree.is_current
+                && worktree
+                    .reference
+                    .as_ref()
+                    .is_some_and(|name| name.as_bstr() == b"refs/heads/topic")
+        }));
+        assert!(worktrees.iter().any(|worktree| {
+            worktree.id == root
+                && worktree.name == "detached-wt"
+                && worktree.reference.is_none()
+                && !worktree.is_current
+        }));
+        assert_eq!(worktrees.len(), 3, "the malformed worktree is ignored");
+
+        let main_repo_decorations = decorations(&repo, &[], &worktrees)?;
+        let main_decorations = main_repo_decorations.get(&main).expect("main is decorated");
+        assert!(
+            main_decorations
+                .iter()
+                .any(|decoration| { decoration.kind == DecorationKind::Local && decoration.name == "main" })
+        );
+        assert!(
+            !main_decorations
+                .iter()
+                .any(|decoration| { decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "main" })
+        );
+        assert!(main_repo_decorations.get(&topic).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "topic")
+        }));
+        assert!(main_repo_decorations.get(&root).is_some_and(|decorations| {
+            decorations.iter().any(|decoration| {
+                decoration.kind == DecorationKind::WorktreeDetached && decoration.name == "detached-wt"
+            })
+        }));
+
+        let explicit = [OsString::from("main")];
+        let without = snapshot(&repo, &explicit, &[], false)?;
+        assert_eq!(without.view_tips, [main], "explicit revisions are unchanged by default");
+        let with = snapshot(&repo, &explicit, &[], true)?;
+        assert!(with.view_tips.contains(&main));
+        assert!(with.view_tips.contains(&topic));
+        assert!(with.view_tips.contains(&root));
+
+        let linked_path = fixture.path().join("topic-wt");
+        let linked_repo = crate::open_test_repository(&linked_path)?;
+        let linked_worktrees = worktree_checkouts(&linked_repo);
+        assert!(
+            linked_worktrees
+                .iter()
+                .any(|worktree| worktree.id == topic && worktree.is_current)
+        );
+        let linked_decorations = decorations(&linked_repo, &[], &linked_worktrees)?;
+        assert!(linked_decorations.get(&topic).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Local && decoration.name == "topic")
+                && !decorations
+                    .iter()
+                    .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "topic")
+        }));
+        assert!(linked_decorations.get(&main).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "main")
+        }));
+
+        let status = Command::new("git")
+            .current_dir(&linked_path)
+            .args(["checkout", "-q", "--detach", "main~1"])
+            .status()?;
+        assert!(status.success(), "git detaches the current linked worktree");
+        let detached_repo = crate::open_test_repository(&linked_path)?;
+        let detached_worktrees = worktree_checkouts(&detached_repo);
+        let current = detached_worktrees
+            .iter()
+            .find(|worktree| worktree.is_current)
+            .expect("the current detached worktree is discovered");
+        assert!(current.reference.is_none());
+        let detached_decorations = decorations(&detached_repo, &[], &detached_worktrees)?;
+        assert!(
+            !detached_decorations
+                .get(&current.id)
+                .is_some_and(|decorations| decorations.iter().any(|decoration| {
+                    decoration.kind == DecorationKind::WorktreeDetached && decoration.name == current.name
+                }))
+        );
+        Ok(())
+    }
+
     #[test]
     fn decodes_commits_missing_from_a_stale_graph_and_defers_graph_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -1619,9 +1880,9 @@ mod tests {
         let repo = crate::open_test_repository(fixture.path())?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let first = graph.refresh(&repo, &["main".into()], &[], &HashSet::new(), &authors)?;
+        let first = graph.refresh(&repo, &["main".into()], &[], false, &HashSet::new(), &authors)?;
         assert_eq!(first.commits.rows.len(), 1, "only the new descendant is loaded");
-        let second = graph.refresh(&repo, &["main".into()], &[], &HashSet::new(), &authors)?;
+        let second = graph.refresh(&repo, &["main".into()], &[], false, &HashSet::new(), &authors)?;
         assert!(
             second.commits.rows.is_empty(),
             "an unchanged tip stops immediately at complete cached ancestry"
@@ -1667,7 +1928,7 @@ mod tests {
 
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let refresh = graph.refresh(&repo, &["topic".into()], &[], &HashSet::new(), &authors)?;
+        let refresh = graph.refresh(&repo, &["topic".into()], &[], false, &HashSet::new(), &authors)?;
         assert!(
             refresh.commits.rows.is_empty(),
             "an unchanged tracking tip stops before revisiting its cached parents"
@@ -1769,7 +2030,7 @@ mod tests {
         let repo = crate::open_test_repository(path)?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let refresh = graph.refresh(&repo, &["local".into()], &[], &boundary, &authors)?;
+        let refresh = graph.refresh(&repo, &["local".into()], &[], false, &boundary, &authors)?;
         visible.extend(refresh.commits.rows.into_iter().map(|row| row.id));
         let expected: HashSet<_> = repo
             .rev_walk([local])
@@ -1854,8 +2115,8 @@ mod tests {
         let mut cancelled = Vec::new();
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let repo = gix::open(&fixture)?;
-        load(&repo, &[], &[], &authors, &AtomicBool::new(true), |event| {
+        let repo = crate::open_test_repository(&fixture)?;
+        load(&repo, &[], &[], false, &authors, &AtomicBool::new(true), |event| {
             cancelled.push(event);
             true
         })?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 40619db8acf..edec1a808ea 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -81,6 +81,8 @@ struct WorktreeWatcher {
 struct RefWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
+    git_dir: PathBuf,
+    worktrees_dir: PathBuf,
 }
 
 impl WorktreeWatcher {
@@ -93,6 +95,16 @@ impl WorktreeWatcher {
     }
 }
 
+impl RefWatcher {
+    fn event_is_relevant(&self, event: &notify::Event) -> bool {
+        reference_event_is_relevant(event, &self.git_dir, &self.worktrees_dir)
+    }
+
+    fn watch_set_may_change(&self, event: &notify::Event) -> bool {
+        reference_watch_set_may_change(event, &self.worktrees_dir)
+    }
+}
+
 #[derive(Default)]
 struct WorktreeDirectories {
     root: PathBuf,
@@ -182,6 +194,36 @@ fn notification_is_actionable(event: &notify::Event) -> bool {
                 })))
 }
 
+fn reference_event_is_relevant(event: &notify::Event, git_dir: &Path, worktrees_dir: &Path) -> bool {
+    notification_is_actionable(event)
+        && (event.need_rescan()
+            || event.paths.is_empty()
+            || event.paths.iter().any(|path| {
+                if let Ok(relative) = path.strip_prefix(git_dir)
+                    && (relative.components().count() <= 1 || relative.starts_with("refs"))
+                {
+                    return true;
+                }
+                let Ok(relative) = path.strip_prefix(worktrees_dir) else {
+                    return true;
+                };
+                let mut components = relative.components();
+                let Some(_) = components.next() else { return true };
+                match components.next() {
+                    None => true,
+                    Some(name) => matches!(name.as_os_str().as_encoded_bytes(), b"HEAD" | b"gitdir"),
+                }
+            }))
+}
+
+fn reference_watch_set_may_change(event: &notify::Event, worktrees_dir: &Path) -> bool {
+    event.need_rescan()
+        || event.paths.iter().any(|path| {
+            path.strip_prefix(worktrees_dir)
+                .is_ok_and(|relative| relative.components().count() <= 1)
+        })
+}
+
 fn unseen_filesystem_redraw(current: bool, focused: bool, filesystem_frame: bool) -> bool {
     !focused && (current || filesystem_frame)
 }
@@ -700,6 +742,8 @@ pub struct Options {
     pub quit_on_finish: bool,
     /// Revisions whose reachable commits should initially be hidden.
     pub hide: Vec<OsString>,
+    /// Add every successfully resolved worktree HEAD as a visible traversal tip.
+    pub worktrees: bool,
 }
 
 fn detect_commit_pane_background() -> Option<(u8, u8, u8)> {
@@ -742,6 +786,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
     tracing::info!(
         revision_count = revisions.len(),
         hidden_revision_count = options.hide.len(),
+        include_worktrees = options.worktrees,
         "starting tix"
     );
     let commit_pane_background = detect_commit_pane_background();
@@ -801,7 +846,11 @@ fn event_loop(
     enhanced_keyboard: bool,
     commit_pane_background: Option<(u8, u8, u8)>,
 ) -> Result<Option<Duration>> {
-    let Options { quit_on_finish, hide } = options;
+    let Options {
+        quit_on_finish,
+        hide,
+        worktrees,
+    } = options;
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
@@ -809,7 +858,7 @@ fn event_loop(
     let (mut repository_is_bare, mut mailmap, mut ref_snapshot) = {
         let bare = view_repository.workdir().is_none();
         let mailmap = view_repository.open_mailmap();
-        let refs = history::snapshot(&view_repository, &revisions, &hide)?;
+        let refs = history::snapshot(&view_repository, &revisions, &hide, worktrees)?;
         (bare, mailmap, refs)
     };
     if recovered_at_startup {
@@ -828,10 +877,12 @@ fn event_loop(
             None
         }
     };
+    let mut ref_watch_set_changed = false;
     let (cancelled, receiver) = start_history(
         repository,
         &revisions,
         &hide,
+        worktrees,
         gix::features::threading::OwnShared::clone(&authors),
     );
 
@@ -984,8 +1035,9 @@ fn event_loop(
                     Ok(Ok(event)) => {
                         received += 1;
                         rescans += usize::from(event.need_rescan());
-                        if notification_is_actionable(&event) {
+                        if watcher.event_is_relevant(&event) {
                             actionable += 1;
+                            ref_watch_set_changed |= watcher.watch_set_may_change(&event);
                             filesystem_responses.observe_references(&event, &repository_path, &common_dir);
                             ref_refresh_deadline = Some(Instant::now() + REF_EVENT_IDLE);
                         }
@@ -1009,10 +1061,25 @@ fn event_loop(
             filesystem_responses.fail_pending_references();
             ref_watcher = None;
             ref_refresh_deadline = None;
+            ref_watch_set_changed = false;
             app.manual_refresh = true;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
+            if std::mem::take(&mut ref_watch_set_changed) {
+                match start_ref_watcher(&repository_path, &common_dir) {
+                    Ok(watcher) => {
+                        ref_watcher = Some(watcher);
+                        app.manual_refresh = false;
+                    }
+                    Err(err) => {
+                        tracing::warn!(error = %err, "reference watcher rebuild failed");
+                        ref_watcher = None;
+                        app.manual_refresh = true;
+                        schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                    }
+                }
+            }
             let response_ids = filesystem_responses.references_due();
             refresh_pending = true;
             refresh_from_filesystem = true;
@@ -1198,15 +1265,17 @@ fn event_loop(
                             None
                         }
                     };
+                    ref_watch_set_changed = false;
                     app.manual_refresh = ref_watcher.is_none();
                     app.notice = Some("worktree removed; using the common repository without worktree changes".into());
                     recovered
                 }
                 Err(err) => return Err(err).context("could not inspect changed references"),
             };
-            let next = history::snapshot(&repository, &revisions, &hide)?;
+            let next = history::snapshot(&repository, &revisions, &hide, worktrees)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
-            let tips_changed = next.view != ref_snapshot.view || hidden_changed;
+            let worktree_tips_changed = worktrees && next.worktrees != ref_snapshot.worktrees;
+            let tips_changed = next.view != ref_snapshot.view || hidden_changed || worktree_tips_changed;
             let from_filesystem = std::mem::take(&mut refresh_from_filesystem);
             if tips_changed && from_filesystem {
                 motion.capture();
@@ -1233,6 +1302,7 @@ fn event_loop(
                 repository_is_bare,
                 revisions.clone(),
                 hidden,
+                worktrees,
                 expand,
                 gix::features::threading::OwnShared::clone(&authors),
                 history_graph
@@ -1619,7 +1689,7 @@ fn event_loop(
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            time_travel::perform(&repository_path, repository_is_bare, id, graph, &revisions)
+                            time_travel::perform(&repository_path, repository_is_bare, id, graph, &revisions, worktrees)
                         });
                     match result {
                         Ok(Some(notice)) => {
@@ -1695,6 +1765,7 @@ fn start_history(
     repository: gix::ThreadSafeRepository,
     revisions: &[OsString],
     hidden_revisions: &[OsString],
+    include_worktrees: bool,
     authors: SharedAuthors,
 ) -> (Arc<AtomicBool>, mpsc::Receiver<Result<Event>>) {
     let cancelled = Arc::new(AtomicBool::new(false));
@@ -1709,6 +1780,7 @@ fn start_history(
             &repository,
             &revisions,
             &hidden_revisions,
+            include_worktrees,
             &authors,
             &worker_cancelled,
             |event| sender.send(Ok(event)).is_ok(),
@@ -1720,11 +1792,16 @@ fn start_history(
     (cancelled, receiver)
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "the worker owns each independent refresh input"
+)]
 fn start_history_refresh(
     repository_path: PathBuf,
     bare: bool,
     revisions: Vec<OsString>,
     hidden_revisions: Vec<OsString>,
+    include_worktrees: bool,
     expand: std::collections::HashSet<gix::ObjectId>,
     authors: SharedAuthors,
     mut graph: HistoryGraph,
@@ -1735,7 +1812,14 @@ fn start_history_refresh(
             .context("could not reopen repository for history refresh")
             .and_then(|mut repository| {
                 repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
-                graph.refresh(&repository, &revisions, &hidden_revisions, &expand, &authors)
+                graph.refresh(
+                    &repository,
+                    &revisions,
+                    &hidden_revisions,
+                    include_worktrees,
+                    &expand,
+                    &authors,
+                )
             });
         let _ = sender.send((graph, result));
     });
@@ -1748,15 +1832,23 @@ fn start_ref_watcher(git_dir: &Path, common_dir: &Path) -> Result<RefWatcher> {
         let _ = sender.send(event);
     })
     .context("could not initialize reference watcher")?;
+    let worktrees_dir = common_dir.join("worktrees");
+    let linked_git_dir_is_covered = worktrees_dir.is_dir() && git_dir.starts_with(&worktrees_dir);
     let mut roots = vec![(common_dir.to_owned(), RecursiveMode::NonRecursive)];
-    if git_dir != common_dir {
+    if git_dir != common_dir && !linked_git_dir_is_covered {
         roots.push((git_dir.to_owned(), RecursiveMode::NonRecursive));
     }
     for root in [common_dir.join("refs"), git_dir.join("refs")] {
-        if root.is_dir() && !roots.iter().any(|(path, _)| path == &root) {
+        if root.is_dir()
+            && !(linked_git_dir_is_covered && root.starts_with(&worktrees_dir))
+            && !roots.iter().any(|(path, _)| path == &root)
+        {
             roots.push((root, RecursiveMode::Recursive));
         }
     }
+    if worktrees_dir.is_dir() {
+        roots.push((worktrees_dir.clone(), RecursiveMode::Recursive));
+    }
     for (path, mode) in &roots {
         watcher
             .watch(path, *mode)
@@ -1766,6 +1858,8 @@ fn start_ref_watcher(git_dir: &Path, common_dir: &Path) -> Result<RefWatcher> {
     Ok(RefWatcher {
         _watcher: watcher,
         events,
+        git_dir: git_dir.to_owned(),
+        worktrees_dir,
     })
 }
 
@@ -3484,6 +3578,7 @@ mod tests {
             &repository,
             &[OsString::from("topic"), OsString::from("main")],
             &[],
+            false,
             &authors,
             &AtomicBool::new(false),
             |event| {
@@ -3561,6 +3656,7 @@ mod tests {
             &repository,
             &[OsString::from("topic")],
             &[],
+            false,
             &authors,
             &AtomicBool::new(false),
             |event| {
@@ -3571,7 +3667,7 @@ mod tests {
             },
         )?;
         let mut graph = graph.expect("history traversal returns its graph");
-        let refs = graph.selection_refs(topic, &history::decorations(&repository, &[])?);
+        let refs = graph.selection_refs(topic, &history::decorations(&repository, &[], &[])?);
         assert_eq!(refs[0].upstream, Some(Some(main)));
         assert_eq!(
             graph.selection_relation(topic, &refs, &[]),
@@ -4355,6 +4451,43 @@ mod tests {
         assert!(worktree_event_is_relevant(&rescan, workdir, &dot_git, &git_dir, &index));
         assert!(notification_is_actionable(&rescan));
 
+        let worktrees = git_dir.join("worktrees");
+        let linked = worktrees.join("linked");
+        assert!(reference_event_is_relevant(
+            &modified(&linked.join("HEAD")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(reference_event_is_relevant(
+            &modified(&linked.join("gitdir")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(!reference_event_is_relevant(
+            &modified(&linked.join("index")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(!reference_event_is_relevant(
+            &modified(&linked.join("logs/HEAD")),
+            &git_dir,
+            &worktrees
+        ));
+        let current_linked = worktrees.join("current");
+        assert!(reference_event_is_relevant(
+            &modified(&current_linked.join("index")),
+            &current_linked,
+            &worktrees
+        ));
+        assert!(reference_watch_set_may_change(
+            &modified(&worktrees.join("new-linked")),
+            &worktrees
+        ));
+        assert!(!reference_watch_set_may_change(
+            &modified(&linked.join("HEAD")),
+            &worktrees
+        ));
+
         let directories = HashSet::from([workdir.join("src")]);
         assert!(!worktree_watch_set_may_change(
             &modified(&workdir.join("src/lib.rs")),
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index a591bf44d24..a4df04558c5 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -328,12 +328,23 @@ fn event_kind(kind: &notify::EventKind) -> &'static str {
 fn classify_reference_path(path: &Path, git_dir: &Path, common_dir: &Path) -> Trigger {
     let head = git_dir.join("HEAD");
     let common_head = common_dir.join("HEAD");
+    let linked_head = path
+        .strip_prefix(common_dir.join("worktrees"))
+        .ok()
+        .is_some_and(|relative| {
+            let mut components = relative.components();
+            let name = components
+                .nth(1)
+                .map(|component| component.as_os_str().as_encoded_bytes());
+            matches!(name, Some(b"HEAD" | b"HEAD.lock")) && components.next().is_none()
+        });
     let index = git_dir.join("index");
     let packed_refs = common_dir.join("packed-refs");
     if path == head
         || path == head.with_extension("lock")
         || path == common_head
         || path == common_head.with_extension("lock")
+        || linked_head
     {
         Trigger::Head
     } else if path == index || path == index.with_extension("lock") {
@@ -450,6 +461,11 @@ mod tests {
             Trigger::Head,
             "transaction lock files retain their semantic trigger"
         );
+        assert_eq!(
+            classify_reference_path(&common.join("worktrees/other/HEAD"), &linked, common),
+            Trigger::Head,
+            "other linked worktree HEADs retain their semantic trigger"
+        );
         assert_eq!(
             classify_reference_path(&linked.join("index"), &linked, common),
             Trigger::Index
diff --git a/gix-tix/src/main.rs b/gix-tix/src/main.rs
index ef02db214a0..40132e32788 100644
--- a/gix-tix/src/main.rs
+++ b/gix-tix/src/main.rs
@@ -8,7 +8,7 @@ fn main() -> Result<()> {
     let (revisions, options, help) = arguments(gix::env::args_os().skip(1))?;
     if help {
         println!(
-            "Usage: tix [--quit-on-finish] [-h|--hide REVSPEC] [REVISION]...\n\nBrowse commits reachable from HEAD or the given revisions.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n      --help          Print help"
+            "Usage: tix [--quit-on-finish] [-w|--worktrees] [-h|--hide REVSPEC] [REVISION]...\n\nBrowse commits reachable from HEAD or the given revisions.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n  -w, --worktrees     Add all worktree HEADs as visible tips\n      --help          Print help"
         );
         return Ok(());
     }
@@ -29,13 +29,20 @@ fn arguments(mut args: impl Iterator<Item = OsString>) -> Result<(Vec<OsString>,
             break;
         } else if arg == "--quit-on-finish" {
             options.quit_on_finish = true;
+        } else if arg == "-w" || arg == "--worktrees" {
+            options.worktrees = true;
         } else if arg == "-h" || arg == "--hide" {
             let revision = args.next().context("-h/--hide requires a revision to hide")?;
             if revision == "--help" {
                 help = true;
                 break;
             }
-            if revision == "-h" || revision == "--hide" || revision == "--quit-on-finish" {
+            if revision == "-h"
+                || revision == "--hide"
+                || revision == "-w"
+                || revision == "--worktrees"
+                || revision == "--quit-on-finish"
+            {
                 anyhow::bail!("-h/--hide requires a revision to hide");
             }
             options.hide.push(revision);
@@ -55,12 +62,22 @@ mod tests {
     #[test]
     fn separates_options_from_revisions() -> Result<()> {
         let (revisions, options, help) = arguments(
-            ["--quit-on-finish", "-h", "main", "--hide", "tag", "topic", "--help"]
-                .into_iter()
-                .map(OsString::from),
+            [
+                "--quit-on-finish",
+                "-w",
+                "-h",
+                "main",
+                "--hide",
+                "tag",
+                "topic",
+                "--help",
+            ]
+            .into_iter()
+            .map(OsString::from),
         )?;
 
         assert!(options.quit_on_finish);
+        assert!(options.worktrees);
         assert_eq!(options.hide, ["main", "tag"], "both hide options are retained");
         assert_eq!(revisions, ["topic"], "only positional revisions remain");
         assert!(help, "--help remains available without claiming -h");
@@ -74,6 +91,10 @@ mod tests {
                 "--help wins regardless of its position"
             );
         }
+        assert!(
+            arguments(["--hide", "--worktrees"].into_iter().map(OsString::from)).is_err(),
+            "worktree options cannot be consumed as hidden revisions"
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/time_travel.rs b/gix-tix/src/time_travel.rs
index 2fe5f2efc8c..7fd8e1b1e88 100644
--- a/gix-tix/src/time_travel.rs
+++ b/gix-tix/src/time_travel.rs
@@ -18,6 +18,7 @@ pub(crate) fn perform(
     selected: ObjectId,
     graph: &history::HistoryGraph,
     revisions: &[OsString],
+    include_worktrees: bool,
 ) -> Result<Option<String>> {
     let repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
@@ -71,7 +72,8 @@ pub(crate) fn perform(
     if let Some((pin, true)) = provisional {
         let repository =
             open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
-        let snapshot = history::snapshot_ignoring_pin(&repository, revisions, &[], Some(pin.name.as_bstr()))?;
+        let snapshot =
+            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
         if snapshot
             .view_tips
             .iter()
@@ -246,12 +248,20 @@ mod tests {
             history::Authors::default(),
         ));
         let mut graph = None;
-        history::load(repository, revisions, &[], &authors, &AtomicBool::new(false), |event| {
-            if let history::Event::Complete(value) = event {
-                graph = Some(value);
-            }
-            true
-        })?;
+        history::load(
+            repository,
+            revisions,
+            &[],
+            false,
+            &authors,
+            &AtomicBool::new(false),
+            |event| {
+                if let history::Event::Complete(value) = event {
+                    graph = Some(value);
+                }
+                true
+            },
+        )?;
         graph.context("history traversal did not produce a graph")
     }
 
@@ -273,7 +283,7 @@ mod tests {
         assert!(!contains(&repository, main, root));
         drop(repository);
 
-        let notice = perform(&repository_path, false, root, &graph, &[])?.context("time-travel changed HEAD")?;
+        let notice = perform(&repository_path, false, root, &graph, &[], false)?.context("time-travel changed HEAD")?;
         assert!(notice.contains("saved pin:"), "{notice}");
         let repository = gix::open(fixture.path())?;
         assert!(repository.head()?.is_detached(), "travel detaches HEAD");
@@ -285,16 +295,20 @@ mod tests {
             Some(b"refs/heads/main".as_bstr())
         );
         assert_eq!(pins[0].id, main);
-        assert!(history::snapshot(&repository, &[], &[])?.view_tips.contains(&main));
+        assert!(
+            history::snapshot(&repository, &[], &[], false)?
+                .view_tips
+                .contains(&main)
+        );
 
         repository
             .find_reference("refs/heads/main")?
             .set_target_id(topic, "advance pinned branch")?;
-        let advanced = history::snapshot(&repository, &[], &[])?;
+        let advanced = history::snapshot(&repository, &[], &[], false)?;
         assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
         drop(repository);
 
-        perform(&repository_path, false, topic, &graph, &[])?;
+        perform(&repository_path, false, topic, &graph, &[], false)?;
         let repository = gix::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -310,12 +324,12 @@ mod tests {
             .status()?;
         assert!(detach.success());
         let graph = loaded_graph(&gix::open(fixture.path())?, &[])?;
-        perform(&repository_path, false, root, &graph, &[])?;
+        perform(&repository_path, false, root, &graph, &[], false)?;
         let pin = history::all_pins(&gix::open(fixture.path())?)?
             .pop()
             .context("direct pin is present")?;
         assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
-        perform(&repository_path, false, main, &graph, &[])?;
+        perform(&repository_path, false, main, &graph, &[], false)?;
         let repository = gix::open(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
@@ -337,7 +351,7 @@ mod tests {
         let graph = loaded_graph(&repository, &revisions)?;
         drop(repository);
 
-        perform(&repository_path, false, root, &graph, &revisions)?;
+        perform(&repository_path, false, root, &graph, &revisions, false)?;
         assert!(
             history::all_pins(&gix::open(fixture.path())?)?.is_empty(),
             "an explicit tip already retains the former HEAD"
@@ -350,7 +364,8 @@ mod tests {
             .status()?;
         assert!(checkout.success());
         std::fs::write(fixture.path().join("main"), "dirty\n")?;
-        let err = perform(&repository_path, false, root, &graph, &[]).expect_err("Git rejects a conflicting checkout");
+        let err =
+            perform(&repository_path, false, root, &graph, &[], false).expect_err("Git rejects a conflicting checkout");
         assert!(format!("{err:#}").contains("git checkout failed"));
         let repository = gix::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 3ba9eeb12a6..64563c17724 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1384,14 +1384,20 @@ fn metadata_line<'a>(
             id_style
         },
     )];
-    let mut labels = decorations
-        .get(&row.id)
-        .into_iter()
-        .flatten()
+    let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
+    let mut labels = row_decorations
+        .iter()
         .filter(|decoration| match ref_mode {
+            _ if decoration.kind == DecorationKind::Head => false,
             RefMode::All => true,
             RefMode::Default => decoration.kind != DecorationKind::Special,
-            RefMode::None => false,
+            RefMode::None => {
+                selected
+                    && matches!(
+                        decoration.kind,
+                        DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
+                    )
+            }
         })
         .peekable();
     if labels.peek().is_some() {
@@ -1400,8 +1406,16 @@ fn metadata_line<'a>(
             if index != 0 {
                 spans.push(Span::raw(", "));
             }
+            let name = decoration.name.to_str_lossy();
             spans.push(Span::styled(
-                decoration.name.to_str_lossy(),
+                if matches!(
+                    decoration.kind,
+                    DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
+                ) {
+                    format!("{name}@").into()
+                } else {
+                    name
+                },
                 decoration_style(decoration.kind),
             ));
         }
@@ -1536,6 +1550,7 @@ fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
+        DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => Style::default().fg(Color::LightBlue),
         DecorationKind::Local => Style::default().fg(Color::Cyan),
         DecorationKind::Remote => Style::default().fg(Color::Yellow),
         DecorationKind::Tag => Style::default().fg(Color::Magenta),
@@ -2148,7 +2163,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
         let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · r reword · [ align · o commit · c changes · v view · y copy · q quit";
-        let selected_line = "> @ 0101010 (HEAD) 1970-01-01 mapped author subject";
+        let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
@@ -2163,13 +2178,10 @@ mod tests {
                     .add_modifier(Modifier::REVERSED | Modifier::BOLD),
             );
         }
-        for x in 13..17 {
-            expected[(x, 0)].set_style(Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD));
-        }
-        for x in 19..30 {
+        for x in 12..23 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Blue));
         }
-        for x in 30..44 {
+        for x in 23..37 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Green));
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
@@ -2191,7 +2203,10 @@ mod tests {
             !row[(11, 0)].modifier.contains(Modifier::REVERSED),
             "selection ends immediately after the hash"
         );
-        assert_eq!(row[(13, 0)].fg, Color::Cyan, "reference colors remain visible");
+        assert!(
+            !rendered_row(&terminal).contains("HEAD"),
+            "the graph marker makes textual HEAD redundant"
+        );
         assert!(
             !rendered_line(&terminal, 1).contains("Esc cancel"),
             "completed work cannot be cancelled"
@@ -2281,7 +2296,10 @@ mod tests {
 
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        assert!(rendered_row(&terminal).contains("HEAD"), "all refs shows regular refs");
+        assert!(
+            !rendered_row(&terminal).contains("HEAD"),
+            "all refs still omits redundant HEAD"
+        );
         assert!(
             rendered_row(&terminal).contains("refs/patches"),
             "all refs shows special refs"
@@ -2290,7 +2308,10 @@ mod tests {
 
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        assert!(rendered_row(&terminal).contains("HEAD"), "refs shows regular refs");
+        assert!(
+            !rendered_row(&terminal).contains("HEAD"),
+            "refs still omits redundant HEAD"
+        );
         assert!(
             !rendered_row(&terminal).contains("refs/patches"),
             "refs hides special refs"
@@ -2386,6 +2407,66 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renders_worktree_labels_and_keeps_them_selected_when_refs_are_hidden() -> Result<(), Box<dyn std::error::Error>>
+    {
+        let checked_out = gix::ObjectId::Sha1([1; 20]);
+        let other = gix::ObjectId::Sha1([2; 20]);
+        let commit = |id| Commit {
+            id,
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(2);
+        app.extend_commits(vec![commit(checked_out), commit(other)]);
+        complete(&mut app);
+        let decorations = Decorations::from([(
+            checked_out,
+            vec![
+                Decoration {
+                    name: "main".into(),
+                    kind: DecorationKind::WorktreeBranch,
+                },
+                Decoration {
+                    name: "detached".into(),
+                    kind: DecorationKind::WorktreeDetached,
+                },
+                Decoration {
+                    name: "HEAD".into(),
+                    kind: DecorationKind::Head,
+                },
+            ],
+        )]);
+        let mut terminal = Terminal::new(TestBackend::new(140, 3))?;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let row = rendered_row(&terminal);
+        assert!(row.contains("main@"));
+        assert!(row.contains("detached@"));
+        assert!(!row.contains("HEAD"), "a worktree label replaces textual HEAD");
+        let x = row.find("main@").expect("the worktree label is visible") as u16;
+        assert_eq!(terminal.backend().buffer()[(x, 0)].fg, Color::LightBlue);
+
+        app.update(Action::ToggleRefs);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            rendered_row(&terminal).contains("main@"),
+            "the selected row retains worktrees"
+        );
+        app.update(Action::MoveDown);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            !rendered_row(&terminal).contains("main@"),
+            "hidden refs omit worktrees from unselected rows"
+        );
+        Ok(())
+    }
+
     #[test]
     fn removes_the_copied_fields_color_from_only_the_selected_row_for_one_frame()
     -> Result<(), Box<dyn std::error::Error>> {
@@ -3978,9 +4059,9 @@ mod tests {
         );
         assert_eq!(style("1970-01-01 "), Style::default().fg(Color::Blue));
         assert_eq!(style("author "), Style::default().fg(Color::Green));
-        assert_eq!(
-            style("HEAD"),
-            Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)
+        assert!(
+            line.spans.iter().all(|span| span.content != "HEAD"),
+            "the graph marker makes textual HEAD redundant"
         );
         assert_eq!(style("main"), Style::default().fg(Color::Cyan));
         assert_eq!(style("origin/main"), Style::default().fg(Color::Yellow));

From 08be5aedb9bc1ee09a96cda9b7c8b0ade3143fae Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 13:38:44 +0200
Subject: [PATCH 050/282] Adapt plumbing tix launch to extensible options

Construct gix_tix::Options with an explicit update over its defaults. This keeps the embedding plumbing command on the established behavior when tix adds optional traversal inputs such as linked worktree tips, and prevents future additive options from breaking workspace builds.
---
 src/plumbing/main.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index 10010dc3db6..8640da5da3b 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -166,7 +166,11 @@ pub fn main() -> Result<()> {
         } => gix_tix::run(
             repository(Mode::Lenient)?.into_sync(),
             revisions,
-            gix_tix::Options { quit_on_finish, hide },
+            gix_tix::Options {
+                quit_on_finish,
+                hide,
+                ..Default::default()
+            },
         ),
         Subcommands::Env => prepare_and_run(
             "env",

From 83777f32181f6dc22056b8d37489a0d8adfb7ea2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 14:38:44 +0200
Subject: [PATCH 051/282] feat: group tix editing shortcuts

Put commit rewording and time-travel checkouts behind an e prefix, matching the existing view shortcut group's toggle and dismissal behavior. Keep the overlapping e, r, and t display commands unchanged while the view group is active, and remove the former direct mutation shortcuts.

Advertise the edit group in the history footer, expand it to only the actions available for the current selection, and document and test the key-routing and group-state contract.
---
 gix-tix/spec.md    | 12 +++++++++++-
 gix-tix/src/app.rs | 34 ++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs | 42 ++++++++++++++++++++++++++----------------
 gix-tix/src/ui.rs  | 32 +++++++++++++++++++++++++-------
 4 files changed, 96 insertions(+), 24 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6125d0f8538..592e8450fcd 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -274,7 +274,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Reword
 
-- `r` is available only after history completion and only on the newest
+- `e`, then `r`, is available only after history completion and only on the newest
   selectable row, where tix assumes the commit has no displayed descendants.
 - The configured Git editor receives a document containing `Author`,
   `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
@@ -294,6 +294,16 @@ space first; changes blocks adapt within the remaining history width.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
   the main status line and do not leave a repository retained by the UI.
 
+### Editing shortcuts
+
+- `e` toggles the edit shortcut group. `e r` rewords the newest commit and
+  `e t` enters or returns from time travel when that action is available.
+- Edit shortcuts keep the group open. Navigation or another recognized command
+  closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
+  mutate the repository.
+- While the `v` group is open, `e`, `r`, and `t` retain their display meanings
+  for emails, references, and trailers.
+
 ## Refresh, focus, and diagnostics
 
 - Native reference watchers observe `HEAD`, loose and packed refs, linked-worktree
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 2db09a7a43b..ab34b9ff635 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -276,6 +276,7 @@ pub(crate) enum Action {
     Refresh,
     ToggleHidden,
     ToggleHistoryDisplay,
+    ToggleEdit,
     ToggleAlign,
     ToggleCommit,
     ToggleChanges,
@@ -362,6 +363,7 @@ pub(crate) struct App {
     pub(crate) notice: Option<String>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
+    pub(crate) edit_expanded: bool,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
     horizontal_page: usize,
@@ -429,6 +431,7 @@ impl App {
             notice: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
+            edit_expanded: false,
             estimated_lane_width: 0,
             horizontal_offset: 0,
             horizontal_page: 1,
@@ -608,6 +611,9 @@ impl App {
         ) {
             self.history_display_expanded = false;
         }
+        if !matches!(&action, Action::ToggleEdit | Action::Reword | Action::TimeTravel) {
+            self.edit_expanded = false;
+        }
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
@@ -697,6 +703,7 @@ impl App {
             Action::ToggleTrailers => self.show_trailers = !self.show_trailers,
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
+            Action::ToggleEdit => self.edit_expanded = !self.edit_expanded,
             Action::ToggleRefs => {
                 self.ref_mode = match self.ref_mode {
                     RefMode::All => RefMode::Default,
@@ -2353,6 +2360,33 @@ mod tests {
         assert!(!app.history_display_expanded, "the prefix key toggles the group");
     }
 
+    #[test]
+    fn edit_group_stays_open_only_for_grouped_actions() {
+        let mut app = App::new(1);
+
+        app.update(Action::ToggleEdit);
+        assert!(app.edit_expanded);
+        app.update(Action::Reword);
+        assert!(app.edit_expanded, "grouped edit commands keep the group open");
+
+        app.update(Action::MoveDown);
+        assert!(!app.edit_expanded, "navigation collapses the group");
+
+        app.update(Action::ToggleEdit);
+        app.update(Action::ToggleHistoryDisplay);
+        assert!(!app.edit_expanded, "opening the view group closes the edit group");
+        assert!(app.history_display_expanded);
+
+        app.update(Action::ToggleEdit);
+        assert!(app.edit_expanded);
+        assert!(
+            !app.history_display_expanded,
+            "opening the edit group closes the view group"
+        );
+        app.update(Action::ToggleEdit);
+        assert!(!app.edit_expanded, "the prefix key toggles the group");
+    }
+
     #[test]
     fn cycles_both_tree_and_hidden_changes() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index edec1a808ea..6a702acfb36 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1448,7 +1448,7 @@ fn event_loop(
         };
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
-                let action = action_with_history_display(key, app.history_display_expanded);
+                let action = action_with_shortcut_groups(key, app.history_display_expanded, app.edit_expanded);
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
@@ -3303,10 +3303,10 @@ fn poll_timeout(
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
-    action_with_history_display(key, false)
+    action_with_shortcut_groups(key, false, false)
 }
 
-fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) -> Option<Action> {
+fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, edit_expanded: bool) -> Option<Action> {
     if key.kind == KeyEventKind::Release
         && !matches!(
             key.code,
@@ -3348,10 +3348,11 @@ fn action_with_history_display(key: KeyEvent, history_display_expanded: bool) ->
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
-        KeyCode::Char('r') => Some(Action::Reword),
-        KeyCode::Char('t') => Some(Action::TimeTravel),
+        KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
+        KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
+        KeyCode::Char('e') => Some(Action::ToggleEdit),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']' | 'o') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
@@ -4175,17 +4176,14 @@ mod tests {
             "terminals that report shifted letters in lowercase still map Shift-G to the first commit"
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
-            Some(Action::Reword)
-        );
         assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)),
-            Some(Action::TimeTravel)
+            action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
+            Some(Action::ToggleEdit)
         );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
@@ -4210,16 +4208,28 @@ mod tests {
             ('h', Action::ToggleHidden),
         ] {
             assert_eq!(
-                action_with_history_display(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), true),
+                action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), true, false),
                 Some(expected),
                 "{key} is available after the view prefix"
             );
         }
         assert_eq!(
-            action_with_history_display(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE), true),
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE), true, false),
             Some(Action::ToggleHistoryDisplay),
             "v closes the view shortcut group"
         );
+        for (key, expected) in [('r', Action::Reword), ('t', Action::TimeTravel)] {
+            assert_eq!(
+                action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), false, true),
+                Some(expected),
+                "{key} is available after the edit prefix"
+            );
+        }
+        assert_eq!(
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE), false, true),
+            Some(Action::ToggleEdit),
+            "e closes the edit shortcut group"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)),
             Some(Action::VerifySignatures)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 64563c17724..7abae7f7158 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -630,7 +630,7 @@ pub(crate) fn draw_with_worktree(
     ))];
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · Enter diff"));
-        if app.time_travel_shortcut_visible()
+        let time_travel = if app.time_travel_shortcut_visible()
             && decorations
                 .values()
                 .flatten()
@@ -642,7 +642,7 @@ pub(crate) fn draw_with_worktree(
                 .iter()
                 .any(|decoration| decoration.kind == DecorationKind::Head)
             {
-                footer_spans.push(Span::raw(
+                Some(
                     if selected_refs
                         .iter()
                         .any(|decoration| decoration.kind == DecorationKind::Pin)
@@ -651,11 +651,22 @@ pub(crate) fn draw_with_worktree(
                     } else {
                         " · t travel"
                     },
-                ));
+                )
+            } else {
+                None
             }
-        }
-        if app.reword_shortcut_visible() {
-            footer_spans.push(Span::raw(" · r reword"));
+        } else {
+            None
+        };
+        if app.edit_expanded {
+            if let Some(label) = time_travel {
+                footer_spans.push(Span::raw(label));
+            }
+            if app.reword_shortcut_visible() {
+                footer_spans.push(Span::raw(" · r reword"));
+            }
+        } else if !app.history_display_expanded {
+            footer_spans.push(Span::raw(" · e edit"));
         }
     }
     if app.tree_changes_visible || app.worktree_changes_visible {
@@ -1994,6 +2005,11 @@ mod tests {
             gix::mailmap::Snapshot::from_bytes(b"Mapped Human <mapped@example.com> Human <human@example.com>\n");
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
+        assert!(
+            !rendered_line(&terminal, 1).contains("e edit"),
+            "the view group keeps e reserved for toggling emails"
+        );
+
         let row = rendered_row(&terminal);
         assert!(
             row.contains("[Codex] Co, A: [Claude], * Re: Mapped Human Ack: Acknowledger Te: Tester So: Signer subject"),
@@ -2162,7 +2178,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · r reword · [ align · o commit · c changes · v view · y copy · q quit";
+        let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · e edit · [ align · o commit · c changes · v view · y copy · q quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2397,9 +2413,11 @@ mod tests {
             ),
         ]);
         let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
+        app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
         assert!(rendered_line(&terminal, 1).contains("t return"));
+        assert!(!rendered_line(&terminal, 1).contains("e edit"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;

From ec09425986c2bff3f367664a32dcee10a198c3d3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 16:17:09 +0200
Subject: [PATCH 052/282] feat: focus and flag non-tip HEAD in tix

Select the current worktree HEAD as soon as its history row becomes available during startup, while allowing user navigation to cancel the pending jump and retaining the normal fallback when HEAD is outside the view.

Warn when the current HEAD has visible descendants by underlining its unselected history row and bolding the @ marker without changing signature, selection, or other row colors.
---
 gix-tix/spec.md    |   4 ++
 gix-tix/src/app.rs |  87 +++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs |  20 +++++++-
 gix-tix/src/ui.rs  | 112 ++++++++++++++++++++++++++++++++++++++++++---
 4 files changed, 216 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 592e8450fcd..c727a7c7131 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -72,6 +72,10 @@ without trading responsiveness for metadata that is not visible.
 - The current `HEAD` commit uses `@` instead of the normal commit disc and keeps
   the same signature and selection coloring. It remains visible when textual
   reference labels are hidden, and textual `HEAD` is never rendered alongside it.
+- At startup, the current worktree's `@` row becomes selected as soon as it is
+  loaded, unless the user navigates first. If it has visible descendants, its
+  unselected non-whitespace content is underlined and `@` is bold; a selected
+  row keeps only bold `@`.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. Other detached
   worktrees use their checkout directory basename. The current worktree is
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ab34b9ff635..22a25aec857 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -370,6 +370,9 @@ pub(crate) struct App {
     horizontal_max: usize,
     follow_tail: bool,
     reload_selection: Option<ObjectId>,
+    pending_initial_selection: Option<ObjectId>,
+    worktree_head: Option<ObjectId>,
+    worktree_head_has_descendants: bool,
     select_top_after_refresh: bool,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
@@ -438,6 +441,9 @@ impl App {
             horizontal_max: 0,
             follow_tail: false,
             reload_selection: None,
+            pending_initial_selection: None,
+            worktree_head: None,
+            worktree_head_has_descendants: false,
             select_top_after_refresh: false,
             signature_failures: 0,
             signature_verification_running: false,
@@ -453,6 +459,16 @@ impl App {
         }
     }
 
+    pub(crate) fn set_worktree_head(&mut self, head: Option<ObjectId>, select_on_load: bool) {
+        self.worktree_head = head;
+        self.pending_initial_selection = select_on_load.then_some(head).flatten();
+        self.update_worktree_head_descendants();
+    }
+
+    pub(crate) fn worktree_head_has_descendants(&self, id: ObjectId) -> bool {
+        self.worktree_head == Some(id) && self.worktree_head_has_descendants
+    }
+
     pub(crate) fn extend_commits(&mut self, commits: impl Into<LoadedCommits>) {
         let commits = commits.into();
         if self.state != State::Loading || commits.rows.is_empty() {
@@ -482,6 +498,16 @@ impl App {
             self.reload_selection = None;
             self.ensure_visible();
         }
+        if let Some(index) = self
+            .pending_initial_selection
+            .and_then(|id| self.rows.iter().position(|row| row.id == id))
+        {
+            if !self.is_row_hidden(index) {
+                self.selected = Some(index);
+            }
+            self.pending_initial_selection = None;
+            self.ensure_visible();
+        }
         if self.reachability_anchor.is_some() {
             self.compute_reachable_rows();
         }
@@ -489,6 +515,11 @@ impl App {
 
     fn store_commits(&mut self, commits: LoadedCommits) -> Vec<SharedCommitRow> {
         let LoadedCommits { rows, attributions } = commits;
+        if !self.worktree_head_has_descendants
+            && let Some(head) = self.worktree_head
+        {
+            self.worktree_head_has_descendants = rows.iter().any(|row| row.parent_ids.contains(&head));
+        }
         self.titles.reserve(rows.iter().map(|row| row.title.len()).sum());
         let attribution_base = self.attributions.len();
         self.attributions.extend(attributions);
@@ -677,6 +708,7 @@ impl App {
                 self.ensure_changes_visible();
             }
             Action::Last if self.last_selectable().is_some() => {
+                self.pending_initial_selection = None;
                 let previous = self.selected;
                 self.selected = self.last_selectable();
                 if self.selected != previous {
@@ -849,6 +881,7 @@ impl App {
                 self.state = State::Computing;
                 self.follow_tail = false;
                 self.reload_selection = None;
+                self.pending_initial_selection = None;
                 Some(self.rows.clone())
             }
             State::Cancelling => {
@@ -959,6 +992,7 @@ impl App {
         }
         self.graph = Some(graph);
         self.lane_time = Some(lane_time);
+        self.update_worktree_head_descendants();
         self.selected = selected
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
             .or_else(|| self.first_selectable());
@@ -996,6 +1030,8 @@ impl App {
         self.reset_commit_view();
         self.reset_changes_view();
         self.follow_tail = false;
+        self.pending_initial_selection = None;
+        self.update_worktree_head_descendants();
         self.clear_preview_author_copy();
         self.signature_failures = 0;
         self.signature_verification_running = false;
@@ -1084,6 +1120,7 @@ impl App {
     }
 
     fn move_selection(&mut self, distance: usize, down: bool) {
+        self.pending_initial_selection = None;
         let Some(selected) = self.selected else { return };
         let target = if down {
             selected.saturating_add(distance).min(self.rows.len() - 1)
@@ -1099,6 +1136,7 @@ impl App {
     }
 
     fn move_reachable(&mut self, distance: usize, down: bool) {
+        self.pending_initial_selection = None;
         let (Some(selected), Some(reachable)) = (self.selected, self.reachable_rows.as_ref()) else {
             self.move_selection(distance, down);
             return;
@@ -1203,6 +1241,7 @@ impl App {
     }
 
     fn select(&mut self, selected: usize) {
+        self.pending_initial_selection = None;
         if !self.rows.is_empty() && !self.is_row_hidden(selected) {
             let previous = self.selected;
             self.selected = Some(selected.min(self.rows.len() - 1));
@@ -1218,6 +1257,14 @@ impl App {
         (0..self.rows.len()).find(|index| !self.is_row_hidden(*index))
     }
 
+    fn update_worktree_head_descendants(&mut self) {
+        self.worktree_head_has_descendants = self.worktree_head.is_some_and(|head| {
+            self.rows
+                .iter()
+                .any(|row| row.id != head && row.parent_ids.contains(&head))
+        });
+    }
+
     pub(crate) fn can_reword(&self) -> bool {
         self.state == State::Complete && self.reword_shortcut_visible()
     }
@@ -2141,6 +2188,46 @@ mod tests {
         assert_eq!(app.selected, Some(2), "manual navigation stops following the tail");
     }
 
+    #[test]
+    fn startup_selection_follows_the_worktree_head_until_the_user_moves() {
+        let mut app = App::new(2);
+        app.set_worktree_head(Some(id(2)), true);
+        app.extend_commits(vec![row_with_parents(3, &[2])]);
+        assert_eq!(app.selected, Some(0), "the newest row is selected provisionally");
+        assert!(
+            app.worktree_head_has_descendants(id(2)),
+            "a streamed child marks HEAD as having visible descendants"
+        );
+
+        app.extend_commits(vec![row(2)]);
+        assert_eq!(app.selected, Some(1), "selection moves to HEAD when its row arrives");
+        complete(&mut app);
+        assert_eq!(app.selected, Some(1), "lane computation retains the HEAD selection");
+
+        let mut moved = App::new(2);
+        moved.set_worktree_head(Some(id(2)), true);
+        moved.extend_commits(vec![row_with_parents(3, &[2])]);
+        moved.update(Action::MoveDown);
+        moved.extend_commits(vec![row(2)]);
+        assert_eq!(moved.selected, Some(0), "navigation cancels the pending jump to HEAD");
+    }
+
+    #[test]
+    fn startup_head_selection_falls_back_when_head_is_unavailable() {
+        let mut absent = App::new(2);
+        absent.set_worktree_head(Some(id(9)), true);
+        absent.extend_commits(vec![row(3), row(2)]);
+        complete(&mut absent);
+        assert_eq!(absent.selected, Some(0), "an absent HEAD retains the newest selection");
+
+        let mut hidden = App::new(2);
+        hidden.set_worktree_head(Some(id(2)), true);
+        hidden.extend_commits(vec![row(3)]);
+        hidden.extend_hidden_commits(vec![row(2)]);
+        complete(&mut hidden);
+        assert_eq!(hidden.selected, Some(0), "a hidden HEAD cannot become selected");
+    }
+
     #[test]
     fn navigation_is_clamped_and_uses_the_viewport_for_pages() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 6a702acfb36..eedee93773c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1198,6 +1198,12 @@ fn event_loop(
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "history-refresh-completed");
                     filesystem_responses.queue_frame(&response_ids, "history-refresh-completed");
+                    app.set_worktree_head(
+                        (!repository_is_bare)
+                            .then(|| decoration_head(&result.decorations))
+                            .flatten(),
+                        false,
+                    );
                     decorations = result.decorations;
                     selection_relation = None;
                     app.selection_relation = None;
@@ -1368,7 +1374,10 @@ fn event_loop(
             events += 1;
             dirty = true;
             match message? {
-                Event::Decorations(value) => decorations = value,
+                Event::Decorations(value) => {
+                    app.set_worktree_head((!repository_is_bare).then(|| decoration_head(&value)).flatten(), true);
+                    decorations = value;
+                }
                 Event::Commits(rows) => app.extend_commits(rows),
                 Event::HiddenCommits(rows) => app.extend_hidden_commits(rows),
                 Event::VisibleComplete => {
@@ -1959,6 +1968,15 @@ fn remembered_change_selection(view: &app::ChangesView, changes: Option<&Changes
     })
 }
 
+fn decoration_head(decorations: &Decorations) -> Option<gix::ObjectId> {
+    decorations.iter().find_map(|(id, decorations)| {
+        decorations
+            .iter()
+            .any(|decoration| decoration.kind == history::DecorationKind::Head)
+            .then_some(*id)
+    })
+}
+
 fn restore_change_selection(view: &mut app::ChangesView, changes: &Changes, remembered: Option<(BString, usize)>) {
     let Some((path, viewport_row)) = remembered else {
         return;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7abae7f7158..1be49c3c737 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -371,6 +371,9 @@ pub(crate) fn draw_with_worktree(
                 .iter()
                 .any(|decoration| decoration.kind == DecorationKind::Head)
         });
+        let head_has_descendants = app.worktree_head_has_descendants(visible_rows[index].id);
+        let underline = head_has_descendants && !selected;
+        let head_state = head.then_some(head_has_descendants);
         let metadata_width = metadata.width();
         let signature_color = signature_color(visible_rows[index].signature);
         let highlight = if selected && app.show_selection_tail {
@@ -408,7 +411,7 @@ pub(crate) fn draw_with_worktree(
                 graph_offset,
                 highlight,
                 visible_rows[index].signature,
-                head,
+                head_state,
             );
             let aligned = Rect::new(
                 content.x.saturating_add(align_width as u16),
@@ -433,7 +436,7 @@ pub(crate) fn draw_with_worktree(
                 horizontal_offset,
                 highlight,
                 visible_rows[index].signature,
-                head,
+                head_state,
             );
         }
         let lane_offset = if align_metadata {
@@ -495,6 +498,14 @@ pub(crate) fn draw_with_worktree(
             }
             buffer[(marker_x, y)].set_symbol(" ").set_style(style);
         }
+        if underline {
+            for x in body.x..body.right() {
+                let cell = &mut frame.buffer_mut()[(x, y)];
+                if !cell.symbol().chars().all(char::is_whitespace) {
+                    cell.modifier.insert(Modifier::UNDERLINED);
+                }
+            }
+        }
         if !app.is_row_reachable(start + index) {
             for x in body.x..body.right() {
                 frame.buffer_mut()[(x, y)].set_style(Style::default().add_modifier(Modifier::DIM));
@@ -1581,21 +1592,24 @@ fn color_graph(
     offset: usize,
     highlight: Option<Color>,
     signature: SignatureState,
-    head: bool,
+    head: Option<bool>,
 ) {
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
             continue;
         }
-        let style = if let Some(highlight) = highlight {
+        let mut style = if let Some(highlight) = highlight {
             color(highlight).add_modifier(Modifier::REVERSED)
         } else if symbol == '●' {
             color(signature_color(signature))
         } else {
             graph_style(offset.saturating_add(x) / 2)
         };
+        if head == Some(true) && symbol == '●' {
+            style = style.add_modifier(Modifier::BOLD);
+        }
         let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
-        if head && symbol == '●' {
+        if head.is_some() && symbol == '●' {
             cell.set_symbol("@");
         }
         cell.set_style(style);
@@ -2581,7 +2595,7 @@ mod tests {
                         0,
                         Some(signature_color(*state)),
                         *state,
-                        head,
+                        head.then_some(false),
                     );
                 }
             }
@@ -2599,6 +2613,92 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn underlines_an_unselected_non_tip_head_and_bolds_its_marker() -> Result<(), Box<dyn std::error::Error>> {
+        let head = gix::ObjectId::Sha1([1; 20]);
+        let child = gix::ObjectId::Sha1([2; 20]);
+        let commit = |id: gix::ObjectId, parent: Option<gix::ObjectId>| Commit {
+            id,
+            parent_ids: parent.into_iter().collect(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(2);
+        app.set_worktree_head(Some(head), false);
+        app.extend_commits(vec![commit(child, Some(head)), commit(head, None)]);
+        complete(&mut app);
+        app.selected = Some(0);
+        let decorations = Decorations::from([(
+            head,
+            vec![Decoration {
+                name: "HEAD".into(),
+                kind: DecorationKind::Head,
+            }],
+        )]);
+        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let head_row = 1;
+        for x in [2, 5, 20] {
+            assert!(
+                terminal.backend().buffer()[(x, head_row)]
+                    .modifier
+                    .contains(Modifier::UNDERLINED),
+                "each non-whitespace part of the unselected HEAD line is underlined"
+            );
+        }
+        for x in [0, 1, 3, 11, 79] {
+            assert!(
+                !terminal.backend().buffer()[(x, head_row)]
+                    .modifier
+                    .contains(Modifier::UNDERLINED),
+                "whitespace on the HEAD line is not underlined"
+            );
+        }
+        assert!(
+            terminal.backend().buffer()[(2, head_row)]
+                .modifier
+                .contains(Modifier::BOLD),
+            "the non-tip @ is bold"
+        );
+
+        app.selected = Some(1);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            !terminal.backend().buffer()[(20, head_row)]
+                .modifier
+                .contains(Modifier::UNDERLINED),
+            "selection removes the warning underline"
+        );
+        assert!(
+            terminal.backend().buffer()[(2, head_row)]
+                .modifier
+                .contains(Modifier::BOLD),
+            "the selected non-tip @ remains bold"
+        );
+
+        app.set_worktree_head(Some(child), false);
+        let decorations = Decorations::from([(
+            child,
+            vec![Decoration {
+                name: "HEAD".into(),
+                kind: DecorationKind::Head,
+            }],
+        )]);
+        app.selected = Some(1);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            !terminal.backend().buffer()[(2, 0)].modifier.contains(Modifier::BOLD),
+            "a tip @ keeps its normal weight"
+        );
+        Ok(())
+    }
+
     #[test]
     fn marks_dirty_head_independently_of_history_selection() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);

From a7f4336b7125eb9cdb6d40910894ee309f4671cb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 20:15:42 +0200
Subject: [PATCH 053/282] Move tix editing into a dedicated module

---
 gix-tix/src/edit/mod.rs               | 45 +++++++++++++++++++++
 gix-tix/src/{ => edit}/reword.rs      |  2 +-
 gix-tix/src/{ => edit}/time_travel.rs | 18 ++++-----
 gix-tix/src/lib.rs                    | 56 ++++++++++-----------------
 4 files changed, 75 insertions(+), 46 deletions(-)
 create mode 100644 gix-tix/src/edit/mod.rs
 rename gix-tix/src/{ => edit}/reword.rs (99%)
 rename gix-tix/src/{ => edit}/time_travel.rs (95%)

diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
new file mode 100644
index 00000000000..35c0f139810
--- /dev/null
+++ b/gix-tix/src/edit/mod.rs
@@ -0,0 +1,45 @@
+use std::{ffi::OsStr, io::Write, process::Command};
+
+use anyhow::{Context, Result};
+
+pub(crate) mod reword;
+pub(crate) mod time_travel;
+
+pub(crate) fn edit_document(
+    terminal: &mut ratatui::DefaultTerminal,
+    editor: &OsStr,
+    document: &[u8],
+    filename: &str,
+    enhanced_keyboard: bool,
+) -> Result<Option<Vec<u8>>> {
+    let mut tempfile = gix::tempfile::writable_at(
+        std::env::temp_dir().join(filename),
+        gix::tempfile::ContainingDirectory::Exists,
+        gix::tempfile::AutoRemove::Tempfile,
+    )
+    .context("could not create commit message file")?
+    .take()
+    .context("commit message file disappeared")?;
+    tempfile
+        .write_all(document)
+        .context("could not write commit message file")?;
+    tempfile.flush().context("could not flush commit message file")?;
+
+    if editor != ":" {
+        crate::with_suspended_terminal(terminal, enhanced_keyboard, || {
+            let status = Command::from(
+                gix::command::prepare(editor)
+                    .arg(tempfile.path())
+                    .command_may_be_shell_script_allow_manual_argument_splitting(),
+            )
+            .status()
+            .with_context(|| format!("could not launch Git editor {}", editor.to_string_lossy()))?;
+            if !status.success() {
+                anyhow::bail!("Git editor {} exited with {status}", editor.to_string_lossy());
+            }
+            Ok(())
+        })?;
+    }
+    let edited = std::fs::read(tempfile.path()).context("could not read edited commit message")?;
+    Ok((edited != document).then_some(edited))
+}
diff --git a/gix-tix/src/reword.rs b/gix-tix/src/edit/reword.rs
similarity index 99%
rename from gix-tix/src/reword.rs
rename to gix-tix/src/edit/reword.rs
index 809d1df86de..a48d00754b1 100644
--- a/gix-tix/src/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -375,7 +375,7 @@ mod tests {
         }
         let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let old_id = gix::open(fixture.path())?.head_id()?.detach();
+        let old_id = crate::open_test_repository(fixture.path())?.head_id()?.detach();
         let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
             Command::new("git").arg("-C").arg(fixture.path()).args(args).status()
         };
diff --git a/gix-tix/src/time_travel.rs b/gix-tix/src/edit/time_travel.rs
similarity index 95%
rename from gix-tix/src/time_travel.rs
rename to gix-tix/src/edit/time_travel.rs
index 7fd8e1b1e88..a88945c33f8 100644
--- a/gix-tix/src/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -268,7 +268,7 @@ mod tests {
     #[test]
     fn travels_with_symbolic_and_direct_pins_and_returns() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
@@ -285,7 +285,7 @@ mod tests {
 
         let notice = perform(&repository_path, false, root, &graph, &[], false)?.context("time-travel changed HEAD")?;
         assert!(notice.contains("saved pin:"), "{notice}");
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         assert!(repository.head()?.is_detached(), "travel detaches HEAD");
         assert_eq!(repository.head_id()?.detach(), root);
         let pins = history::all_pins(&repository)?;
@@ -309,7 +309,7 @@ mod tests {
         drop(repository);
 
         perform(&repository_path, false, topic, &graph, &[], false)?;
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
             Some(b"refs/heads/main".into()),
@@ -323,14 +323,14 @@ mod tests {
             .args(["checkout", "--detach", &main.to_hex().to_string()])
             .status()?;
         assert!(detach.success());
-        let graph = loaded_graph(&gix::open(fixture.path())?, &[])?;
+        let graph = loaded_graph(&crate::open_test_repository(fixture.path())?, &[])?;
         perform(&repository_path, false, root, &graph, &[], false)?;
-        let pin = history::all_pins(&gix::open(fixture.path())?)?
+        let pin = history::all_pins(&crate::open_test_repository(fixture.path())?)?
             .pop()
             .context("direct pin is present")?;
         assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
         perform(&repository_path, false, main, &graph, &[], false)?;
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
             "a direct pin returns to detached HEAD"
@@ -343,7 +343,7 @@ mod tests {
     #[test]
     fn explicit_tips_avoid_redundant_pins_and_failed_checkouts_clean_up() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
@@ -353,7 +353,7 @@ mod tests {
 
         perform(&repository_path, false, root, &graph, &revisions, false)?;
         assert!(
-            history::all_pins(&gix::open(fixture.path())?)?.is_empty(),
+            history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty(),
             "an explicit tip already retains the former HEAD"
         );
 
@@ -367,7 +367,7 @@ mod tests {
         let err =
             perform(&repository_path, false, root, &graph, &[], false).expect_err("Git rejects a conflicting checkout");
         assert!(format!("{err:#}").contains("git checkout failed"));
-        let repository = gix::open(fixture.path())?;
+        let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
         assert!(
             history::all_pins(&repository)?.is_empty(),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index eedee93773c..2fcf66d6840 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4,10 +4,9 @@
 
 mod animation;
 mod app;
+mod edit;
 mod history;
 mod logging;
-mod reword;
-mod time_travel;
 mod ui;
 
 use std::{
@@ -1698,7 +1697,14 @@ fn event_loop(
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            time_travel::perform(&repository_path, repository_is_bare, id, graph, &revisions, worktrees)
+                            edit::time_travel::perform(
+                                &repository_path,
+                                repository_is_bare,
+                                id,
+                                graph,
+                                &revisions,
+                                worktrees,
+                            )
                         });
                     match result {
                         Ok(Some(notice)) => {
@@ -2654,45 +2660,23 @@ fn reword_commit(
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before editing commit")?;
         repository.object_cache_size(None);
-        reword::document(&repository, id)?
+        edit::reword::document(&repository, id)?
     };
-    let mut tempfile = gix::tempfile::writable_at(
-        std::env::temp_dir().join(format!("tix-reword-{}.md", std::process::id())),
-        gix::tempfile::ContainingDirectory::Exists,
-        gix::tempfile::AutoRemove::Tempfile,
-    )
-    .context("could not create commit message file")?
-    .take()
-    .context("commit message file disappeared")?;
-    tempfile
-        .write_all(&document)
-        .context("could not write commit message file")?;
-    tempfile.flush().context("could not flush commit message file")?;
-
-    if editor != ":" {
-        with_suspended_terminal(terminal, enhanced_keyboard, || {
-            let status = Command::from(
-                gix::command::prepare(&editor)
-                    .arg(tempfile.path())
-                    .command_may_be_shell_script_allow_manual_argument_splitting(),
-            )
-            .status()
-            .with_context(|| format!("could not launch Git editor {}", editor.to_string_lossy()))?;
-            if !status.success() {
-                anyhow::bail!("Git editor {} exited with {status}", editor.to_string_lossy());
-            }
-            Ok(())
-        })?;
-    }
-    let edited = std::fs::read(tempfile.path()).context("could not read edited commit message")?;
-    if edited == document {
+    let Some(edited) = edit::edit_document(
+        terminal,
+        &editor,
+        &document,
+        &format!("tix-reword-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?
+    else {
         return Ok(None);
-    }
+    };
 
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    reword::apply(&repository, id, &edited)
+    edit::reword::apply(&repository, id, &edited)
 }
 
 fn run_external_diff(

From 1e87f6e049d1f5ba82b88e5c507bf4008b91e5d1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 12 Aug 2026 20:19:23 +0200
Subject: [PATCH 054/282] feat: create commits from tix

Restrict rewording and commit creation to commits without descendants in the completed in-memory history graph. Offer `e n` for a live worktree, including unborn repositories, without retaining a repository in the UI.

Resolve identities, signing configuration, every mutable direct ref, linked-worktree safety, index conflicts, filters, the candidate tree, and its per-path diffstat before opening the editor. Keep provisional objects in object memory so cancellation and preflight failures leave refs, index, object storage, and worktree untouched.

Let a changed index win over unstaged files; otherwise snapshot worktree changes only when HEAD is based on the selected parent, falling back to the parent or empty tree. Present a Markdown what/why template with optional attribution trailers and a commented Git-style diffstat.

After editing, revalidate all destinations, sign when configured, persist prepared objects, and atomically advance every mutable direct ref pointing at the parent, including local branches, custom refs, direct pins, and detached HEAD. Preserve attached HEAD and unrelated worktrees, exclude tags and remote-tracking refs, reject branches checked out elsewhere, and align the current checkout without running hooks. Add scenario coverage for staged precedence, worktree snapshots, unborn roots, multi-ref updates, and repository-state isolation.
---
 gix-tix/spec.md                               |  36 +-
 gix-tix/src/app.rs                            |  80 ++-
 gix-tix/src/edit/create.rs                    | 565 ++++++++++++++++++
 gix-tix/src/edit/mod.rs                       |   2 +
 gix-tix/src/edit/refs.rs                      | 174 ++++++
 gix-tix/src/edit/reword.rs                    | 119 ++--
 gix-tix/src/edit/time_travel.rs               |   4 +-
 gix-tix/src/history.rs                        |   4 +
 gix-tix/src/lib.rs                            | 118 +++-
 gix-tix/src/ui.rs                             |   3 +
 gix-tix/tests/fixtures/create_commit.sh       |  14 +
 .../generated-archives/create_commit.tar      | Bin 0 -> 64000 bytes
 12 files changed, 1013 insertions(+), 106 deletions(-)
 create mode 100644 gix-tix/src/edit/create.rs
 create mode 100644 gix-tix/src/edit/refs.rs
 create mode 100644 gix-tix/tests/fixtures/create_commit.sh
 create mode 100644 gix-tix/tests/fixtures/generated-archives/create_commit.tar

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c727a7c7131..d6afc335658 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -264,7 +264,7 @@ space first; changes blocks adapt within the remaining history width.
   Broken-pipe writes are accepted. If a pager exits within 250 ms, its already
   displayed output is retained until a keypress so short output remains readable.
 
-## Signature verification and rewording
+## Signature verification and editing
 
 ### Signatures
 
@@ -278,8 +278,8 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Reword
 
-- `e`, then `r`, is available only after history completion and only on the newest
-  selectable row, where tix assumes the commit has no displayed descendants.
+- `e`, then `r`, is available only after history completion and only when the
+  selected commit has no descendants in tix's complete cached graph.
 - The configured Git editor receives a document containing `Author`,
   `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
   message in a temporary `.md` file for syntax highlighting. Author identity and
@@ -298,10 +298,36 @@ space first; changes blocks adapt within the remaining history width.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
   the main status line and do not leave a repository retained by the UI.
 
+### New commits
+
+- `e`, then `n`, creates a child of the selected commit, or a root commit for an
+  unborn `HEAD`. It is available only with a live worktree, after history
+  completion, and when the selected parent has no known descendants.
+- Before launching the editor, tix resolves identities, signing configuration,
+  every mutable direct ref, linked-worktree safety, index conflicts, filters,
+  candidate tree, per-path diffstat, and a provisional commit entirely through an
+  in-memory object database. Cancellation and preflight failure write no object,
+  reference, index, or worktree state.
+- A changed index supplies the complete commit tree and wins over unstaged
+  changes. Otherwise, when the worktree `HEAD` is the selected parent, worktree
+  changes are filtered into a tree. With no applicable changes—or when the
+  selected parent is not the worktree base—the parent tree is reused; an unborn
+  repository starts from the empty tree.
+- The Markdown editor buffer contains editable identities and dates, a `what`
+  title, a `why` body, optional attribution trailers, and a commented Git-style
+  per-path diffstat. Commit hooks are not run.
+- After editing, tix revalidates the destination, applies configured signing,
+  persists the already-prepared objects, and atomically advances every mutable
+  direct ref pointing at the parent. This includes local branches, custom refs,
+  direct tix pins, and a detached `HEAD`, while excluding tags and remote-tracking
+  refs. An attached `HEAD` remains attached; an unrelated worktree `HEAD` is left
+  untouched. A ref changed by another process or a branch checked out in another
+  worktree aborts safely.
+
 ### Editing shortcuts
 
-- `e` toggles the edit shortcut group. `e r` rewords the newest commit and
-  `e t` enters or returns from time travel when that action is available.
+- `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
+  and `e t` enters or returns from time travel when each action is available.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 22a25aec857..59fe42b4069 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -284,6 +284,7 @@ pub(crate) enum Action {
     CycleChangesParent,
     OpenDiff,
     Reword,
+    NewCommit,
     TimeTravel,
     VerifySignatures,
     Cancel,
@@ -305,6 +306,7 @@ pub(crate) enum Effect {
     OpenDiff(ChangePane, usize),
     OpenCommitDiff(ObjectId),
     Reword(ObjectId),
+    NewCommit(Option<ObjectId>),
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
@@ -373,6 +375,8 @@ pub(crate) struct App {
     pending_initial_selection: Option<ObjectId>,
     worktree_head: Option<ObjectId>,
     worktree_head_has_descendants: bool,
+    worktree_head_unborn: bool,
+    known_descendants: HashSet<ObjectId>,
     select_top_after_refresh: bool,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
@@ -444,6 +448,8 @@ impl App {
             pending_initial_selection: None,
             worktree_head: None,
             worktree_head_has_descendants: false,
+            worktree_head_unborn: false,
+            known_descendants: HashSet::new(),
             select_top_after_refresh: false,
             signature_failures: 0,
             signature_verification_running: false,
@@ -465,6 +471,15 @@ impl App {
         self.update_worktree_head_descendants();
     }
 
+    pub(crate) fn set_worktree_head_unborn(&mut self, unborn: bool) {
+        self.worktree_head_unborn = unborn;
+    }
+
+    pub(crate) fn set_known_descendants(&mut self, ids: HashSet<ObjectId>) {
+        self.known_descendants = ids;
+        self.update_worktree_head_descendants();
+    }
+
     pub(crate) fn worktree_head_has_descendants(&self, id: ObjectId) -> bool {
         self.worktree_head == Some(id) && self.worktree_head_has_descendants
     }
@@ -642,7 +657,10 @@ impl App {
         ) {
             self.history_display_expanded = false;
         }
-        if !matches!(&action, Action::ToggleEdit | Action::Reword | Action::TimeTravel) {
+        if !matches!(
+            &action,
+            Action::ToggleEdit | Action::Reword | Action::NewCommit | Action::TimeTravel
+        ) {
             self.edit_expanded = false;
         }
         match action {
@@ -804,6 +822,11 @@ impl App {
                     self.rows[self.selected.expect("reword requires a selection")].id,
                 )];
             }
+            Action::NewCommit if self.can_create_commit() => {
+                return vec![Effect::NewCommit(
+                    self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
+                )];
+            }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
@@ -1258,11 +1281,11 @@ impl App {
     }
 
     fn update_worktree_head_descendants(&mut self) {
-        self.worktree_head_has_descendants = self.worktree_head.is_some_and(|head| {
-            self.rows
-                .iter()
-                .any(|row| row.id != head && row.parent_ids.contains(&head))
-        });
+        self.worktree_head_has_descendants = self.worktree_head.is_some_and(|head| self.has_known_descendant(head));
+    }
+
+    fn has_known_descendant(&self, id: ObjectId) -> bool {
+        self.known_descendants.contains(&id) || self.rows.iter().any(|row| row.parent_ids.contains(&id))
     }
 
     pub(crate) fn can_reword(&self) -> bool {
@@ -1272,8 +1295,21 @@ impl App {
     pub(crate) fn reword_shortcut_visible(&self) -> bool {
         self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self.selected.is_some()
-            && self.selected == self.first_selectable()
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| !self.has_known_descendant(row.id))
+    }
+
+    pub(crate) fn can_create_commit(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && match self.selected.and_then(|index| self.rows.get(index)) {
+                Some(row) => !self.has_known_descendant(row.id),
+                None => self.worktree_head_unborn,
+            }
     }
 
     pub(crate) fn time_travel_shortcut_visible(&self) -> bool {
@@ -1931,7 +1967,7 @@ mod tests {
     }
 
     #[test]
-    fn only_the_newest_completed_history_row_can_be_reworded() {
+    fn only_a_completed_history_row_without_descendants_can_be_reworded() {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         assert!(!app.can_reword(), "loading history cannot be reworded");
@@ -1946,6 +1982,31 @@ mod tests {
         assert!(app.update(Action::Reword).is_empty());
     }
 
+    #[test]
+    fn editing_requires_no_known_descendants_and_new_commits_support_unborn_head() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row(2)]);
+        complete(&mut app);
+        app.set_known_descendants(HashSet::from([id(2)]));
+        assert!(
+            !app.can_reword(),
+            "a descendant outside the visible projection still prevents rewording"
+        );
+        assert!(
+            !app.can_create_commit(),
+            "a descendant outside the visible projection still prevents a child"
+        );
+
+        let mut unborn = App::new(10);
+        unborn.set_worktree_head_unborn(true);
+        complete(&mut unborn);
+        assert!(
+            unborn.can_create_commit(),
+            "an unborn worktree can create its root commit"
+        );
+        assert_eq!(unborn.update(Action::NewCommit), vec![Effect::NewCommit(None)]);
+    }
+
     #[test]
     fn time_travel_requires_completed_history_and_a_worktree() {
         let mut app = App::new(10);
@@ -2454,6 +2515,7 @@ mod tests {
         app.update(Action::ToggleEdit);
         assert!(app.edit_expanded);
         app.update(Action::Reword);
+        app.update(Action::NewCommit);
         assert!(app.edit_expanded, "grouped edit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
new file mode 100644
index 00000000000..ae92bc0a9ac
--- /dev/null
+++ b/gix-tix/src/edit/create.rs
@@ -0,0 +1,565 @@
+use std::{ffi::OsString, path::Path};
+
+use anyhow::{Context, Result};
+use gix::{ObjectId, bstr::ByteSlice, objs::Write};
+
+use crate::{
+    ChangeGroup, ChangeKind, ComparedParent, add_line_counts, load_tree_changes_without_lines,
+    load_worktree_changes_without_lines, ui,
+};
+
+use super::{refs::MutableRefs, reword, time_travel};
+
+pub(crate) struct Prepared {
+    pub editor: OsString,
+    pub document: Vec<u8>,
+    parent: Option<ObjectId>,
+    tree: ObjectId,
+    references: MutableRefs,
+    checkout: Checkout,
+    objects: gix::odb::memory::Storage,
+}
+
+enum Checkout {
+    None,
+    Branch(gix::refs::FullName),
+    Detached,
+}
+
+pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
+    repo.workdir().context("creating a commit requires a worktree")?;
+    let head = repo.head().context("could not read HEAD before creating a commit")?;
+    let head_id = head.id().map(gix::Id::detach);
+    if parent.is_none() && !head.is_unborn() {
+        anyhow::bail!("an unborn history is required to create a root commit");
+    }
+    if let Some(parent) = parent {
+        repo.find_commit(parent)
+            .context("could not find the selected parent commit")?;
+    }
+    let (references, checkout) = match parent {
+        Some(parent) => {
+            let references = MutableRefs::pointing_to(&repo, parent)?;
+            if references.is_empty() {
+                anyhow::bail!("no mutable reference points to the selected parent");
+            }
+            references.ensure_not_checked_out_elsewhere(&repo)?;
+            let checkout = if head_id == Some(parent) {
+                match head.referent_name() {
+                    Some(name) => Checkout::Branch(name.to_owned()),
+                    None => Checkout::Detached,
+                }
+            } else {
+                Checkout::None
+            };
+            (references, checkout)
+        }
+        None => {
+            let name = head
+                .referent_name()
+                .context("an unborn HEAD must point to a branch")?
+                .to_owned();
+            (MutableRefs::unborn(&repo)?, Checkout::Branch(name))
+        }
+    };
+    let editor = repo.editor().context("no Git editor is available")?;
+    let author = repo
+        .author()
+        .context("no Git author is configured")?
+        .context("could not resolve the Git author")?
+        .to_owned()
+        .context("could not own the Git author")?;
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()
+        .context("could not own the Git committer")?;
+    repo.commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+
+    repo = repo.with_object_memory();
+    let baseline = match parent {
+        Some(id) => repo
+            .find_commit(id)
+            .context("could not find the parent commit")?
+            .tree()
+            .context("could not load the parent tree")?,
+        None => repo.empty_tree(),
+    };
+    let index = repo.index_or_empty().context("could not load the index")?;
+    if index
+        .entries()
+        .iter()
+        .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+    {
+        anyhow::bail!("cannot create a commit with unresolved index conflicts");
+    }
+    let mut index_editor = repo.empty_tree().edit().context("could not prepare the index tree")?;
+    for entry in index.entries() {
+        let mode = entry
+            .mode
+            .to_tree_entry_mode()
+            .context("an index entry has an invalid mode")?;
+        index_editor
+            .upsert(entry.path(&index), mode.kind(), entry.id)
+            .context("could not add an index entry to the candidate tree")?;
+    }
+    let index_tree = index_editor
+        .write()
+        .context("could not build the candidate index tree")?
+        .detach();
+    let based_on_parent = head_id == parent;
+    let tree = if based_on_parent && index_tree != baseline.id {
+        index_tree
+    } else if based_on_parent {
+        worktree_tree(&repo, &baseline)?
+    } else {
+        baseline.id
+    };
+
+    let new_tree = repo.find_tree(tree).context("could not load the candidate tree")?;
+    let mut changes = load_tree_changes_without_lines(
+        &repo,
+        parent.map(|_| &baseline),
+        &new_tree,
+        parent.map(|id| ComparedParent { index: 0, total: 1, id }),
+    )?;
+    let line_counts = add_line_counts(&repo, &mut changes)?;
+    let mut document = Vec::new();
+    reword::write_headers(&mut document, &author, &committer)?;
+    document.extend_from_slice(b"\nwhat\n\nwhy\n");
+    for trailer in reword::missing_agent_trailers(b"what\n\nwhy\n").into_iter().flatten() {
+        document.extend_from_slice(b"\n;");
+        document.extend_from_slice(trailer);
+    }
+    document.extend_from_slice(b"\n\n; Changes to be committed:\n");
+    for line in ui::commit_diff_summary(&changes, &line_counts, changes.lines_added, changes.lines_removed) {
+        document.extend_from_slice(b"; ");
+        for span in line.spans {
+            document.extend_from_slice(span.content.as_bytes());
+        }
+        document.push(b'\n');
+    }
+    drop(new_tree);
+    drop(baseline);
+    drop(index);
+
+    let provisional = repo
+        .new_commit("what\n\nwhy\n", tree, parent)
+        .context("could not prepare the commit object")?
+        .id;
+    let mut objects = repo
+        .objects
+        .take_object_memory()
+        .context("candidate object memory was unavailable")?;
+    objects.remove(&provisional);
+    Ok(Prepared {
+        editor,
+        document,
+        parent,
+        tree,
+        references,
+        checkout,
+        objects,
+    })
+}
+
+fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<ObjectId> {
+    let changes = load_worktree_changes_without_lines(repo)?;
+    if changes.paths.is_empty() {
+        return Ok(baseline.id);
+    }
+    let (mut pipeline, index) = repo
+        .filter_pipeline(None)
+        .context("could not initialize worktree filters")?;
+    let mut editor = baseline.edit().context("could not edit the parent tree")?;
+    for change in changes
+        .paths
+        .iter()
+        .filter(|change| change.group == ChangeGroup::Unstaged)
+    {
+        if let Some(source) = &change.source {
+            editor
+                .remove(source)
+                .context("could not remove a renamed source path")?;
+        }
+        if change.kind == ChangeKind::Deleted {
+            editor
+                .remove(&change.path)
+                .context("could not remove a deleted worktree path")?;
+            continue;
+        }
+        match pipeline
+            .worktree_file_to_object(change.path.as_bstr(), &index)
+            .with_context(|| format!("could not prepare {}", change.path.to_str_lossy()))?
+        {
+            Some((id, kind, _)) => {
+                editor
+                    .upsert(&change.path, kind, id)
+                    .context("could not add a worktree path to the candidate tree")?;
+            }
+            None => {
+                editor
+                    .remove(&change.path)
+                    .context("could not remove an unavailable worktree path")?;
+            }
+        }
+    }
+    Ok(editor.write().context("could not build the worktree tree")?.detach())
+}
+
+pub(crate) fn apply(mut repo: gix::Repository, mut prepared: Prepared, edited: &[u8]) -> Result<ObjectId> {
+    let edit = reword::parse(edited)?;
+    if edit.message.is_empty() {
+        anyhow::bail!("the edited commit message is empty");
+    }
+    prepared.references.validate(&repo)?;
+    let references = match prepared.parent {
+        Some(parent) => MutableRefs::pointing_to(&repo, parent)?,
+        None => MutableRefs::unborn(&repo)?,
+    };
+    if references.is_empty() {
+        anyhow::bail!("no mutable reference points to the selected parent anymore");
+    }
+    references.ensure_not_checked_out_elsewhere(&repo)?;
+    let signing = repo
+        .commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+    repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
+    let mut commit = gix::objs::Commit {
+        message: edit.message,
+        tree: prepared.tree,
+        author: reword::actor(edit.author, edit.author_time, "author")?,
+        committer: reword::actor(edit.committer, edit.committer_time, "committer")?,
+        encoding: None,
+        parents: prepared.parent.into_iter().collect(),
+        extra_headers: Vec::new(),
+    };
+    if let Some(options) = signing {
+        commit = commit.sign(options).context("could not sign the new commit")?;
+    }
+    let new_id = repo
+        .write_object(&commit)
+        .context("could not prepare the final commit")?
+        .detach();
+    let objects = repo
+        .objects
+        .take_object_memory()
+        .context("candidate object memory was unavailable")?;
+    for (id, (kind, data)) in objects.iter() {
+        repo.write_buf_with_known_id(*kind, data, *id)
+            .map_err(|err| anyhow::anyhow!("could not persist a prepared commit object: {err}"))?;
+    }
+    let log_message = gix::reference::log::message("commit", commit.message.as_bstr(), commit.parents.len());
+    let mut time_buf = gix::date::parse::TimeBuf::default();
+    references.update(
+        &repo,
+        new_id,
+        log_message.as_bstr(),
+        Some(commit.committer.to_ref(&mut time_buf)),
+    )?;
+    let checkout = match &prepared.checkout {
+        Checkout::None => Ok(()),
+        Checkout::Branch(name) => {
+            let workdir = repo.workdir().context("creating a commit requires a worktree")?;
+            let branch = name
+                .as_bstr()
+                .strip_prefix(b"refs/heads/")
+                .context("the destination isn't a local branch")?;
+            time_travel::checkout(
+                workdir,
+                [
+                    OsString::from("--no-guess"),
+                    gix::path::from_bstr(branch.as_bstr()).into_owned().into_os_string(),
+                ],
+            )
+            .and_then(|()| reset_index(workdir, new_id))
+        }
+        Checkout::Detached => {
+            let workdir = repo.workdir().context("creating a commit requires a worktree")?;
+            time_travel::checkout_detached(workdir, new_id)
+        }
+    };
+    if let Err(err) = checkout {
+        let rollback = references.rollback(&repo, new_id);
+        return match rollback {
+            Ok(()) => Err(err),
+            Err(rollback) => Err(err.context(format!("the destination could not be rolled back: {rollback:#}"))),
+        };
+    }
+    Ok(new_id)
+}
+
+fn reset_index(workdir: &Path, id: ObjectId) -> Result<()> {
+    let output = std::process::Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["reset", "--mixed", "--quiet"])
+        .arg(id.to_string())
+        .output()
+        .context("could not update the index after checkout")?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!(
+            "git reset failed with {}: {}",
+            output.status,
+            output.stderr.to_str_lossy().trim()
+        )
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use super::*;
+
+    fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "user.name=author".to_owned(),
+                "user.email=author@example.com".to_owned(),
+            ]),
+        )?)
+    }
+
+    fn object_count(path: &Path) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git")
+            .arg("-C")
+            .arg(path)
+            .args(["count-objects", "-v"])
+            .output()?;
+        if !output.status.success() {
+            return Err(format!("git count-objects failed: {}", output.stderr.to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn preparation_is_unobservable_and_staged_changes_win() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let parent = open(fixture.path())?.head_id()?.detach();
+        for name in ["refs/patches/create", "refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(fixture.path())
+                    .args(["update-ref", name, &parent.to_string()])
+                    .status()?
+                    .success(),
+                "the test reference is created"
+            );
+        }
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let objects_before = object_count(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        assert!(
+            prepared
+                .document
+                .windows(b"tracked".len())
+                .any(|window| window == b"tracked"),
+            "the editor buffer includes a commented per-file diffstat: {}",
+            prepared.document.as_bstr()
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "preparing the tree and commit leaves the complete repository state unchanged"
+        );
+        assert_eq!(
+            object_count(fixture.path())?,
+            objects_before,
+            "preparation writes no loose objects"
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["update-ref", "refs/patches/late", &parent.to_string()])
+                .status()?
+                .success(),
+            "a ref may appear while the editor is open"
+        );
+
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"title\n\nbody", 1);
+        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            after.head,
+            gix_testtools::repository::Head::Symbolic {
+                name: b"refs/heads/main".into(),
+                id: new_id,
+            },
+            "the checked-out branch advances to the new commit"
+        );
+        let repository = open(fixture.path())?;
+        let commit = repository.find_commit(new_id)?;
+        assert_eq!(commit.parent_ids().next().map(gix::Id::detach), Some(parent));
+        assert_eq!(commit.message_raw()?, b"title\n\nbody\n".as_bstr());
+        assert_eq!(
+            Some(commit.tree_id()?.detach()),
+            before.index_tree,
+            "a changed index supplies the commit tree even when the worktree differs"
+        );
+        assert_eq!(after.index_tree, before.index_tree, "the committed index stays intact");
+        assert_eq!(
+            after.worktree, before.worktree,
+            "unstaged and untracked files stay intact"
+        );
+        assert_eq!(
+            after.commits.len(),
+            before.commits.len() + 1,
+            "exactly one reachable commit is added"
+        );
+        for name in ["refs/heads/main", "refs/patches/create", "refs/patches/late"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                new_id,
+                "{name} advances to the new commit"
+            );
+        }
+        for name in ["refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                parent,
+                "{name} is not edited"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn worktree_changes_supply_the_tree_when_the_index_is_unchanged() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["reset", "-q", "HEAD"])
+                .status()?
+                .success()
+        );
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let parent = open(fixture.path())?.head_id()?.detach();
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"worktree\n\nstate", 1);
+        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        let repository = open(fixture.path())?;
+        let commit = repository.find_commit(new_id)?;
+        assert_ne!(
+            Some(commit.tree_id()?.detach()),
+            before.index_tree,
+            "worktree changes produce a new tree"
+        );
+        assert_eq!(
+            after.index_tree,
+            Some(commit.tree_id()?.detach()),
+            "checking out the commit updates the index to its worktree-derived tree"
+        );
+        assert_eq!(
+            after.worktree, before.worktree,
+            "the committed worktree bytes remain exactly as prepared"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn creates_an_empty_root_commit_for_an_unborn_head() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["init", "-q", "-b", "main"])
+                .status()?
+                .success()
+        );
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?, None)?;
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "root-commit preflight is unobservable"
+        );
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"root\n\nreason", 1);
+        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let repository = open(fixture.path())?;
+        let commit = repository.find_commit(new_id)?;
+        assert!(commit.parent_ids().next().is_none(), "the root has no parent");
+        assert_eq!(
+            commit.tree_id()?.detach(),
+            ObjectId::empty_tree(repository.object_hash()),
+            "no index or worktree changes reuse the empty tree"
+        );
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "the unborn branch is created and remains checked out"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn an_unrelated_worktree_head_is_not_checked_out_or_moved() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let parent = open(fixture.path())?.head_id()?.detach();
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "--orphan", "other"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["rm", "-rf", "-q", "."])
+                .status()?
+                .success()
+        );
+        std::fs::write(fixture.path().join("other"), b"other\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "other"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["-c", "commit.gpgSign=false", "commit", "-q", "-m", "other"])
+                .status()?
+                .success()
+        );
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"child\n\nreason", 1);
+        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            after.head, before.head,
+            "the unrelated checked-out branch does not move"
+        );
+        assert_eq!(after.index, before.index, "the unrelated index does not change");
+        assert_eq!(
+            after.worktree, before.worktree,
+            "the unrelated worktree does not change"
+        );
+        assert_eq!(
+            open(fixture.path())?.find_reference("refs/heads/main")?.id().detach(),
+            new_id,
+            "the selected parent branch advances independently"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 35c0f139810..216b294e7d9 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -2,6 +2,8 @@ use std::{ffi::OsStr, io::Write, process::Command};
 
 use anyhow::{Context, Result};
 
+pub(crate) mod create;
+pub(crate) mod refs;
 pub(crate) mod reword;
 pub(crate) mod time_travel;
 
diff --git a/gix-tix/src/edit/refs.rs b/gix-tix/src/edit/refs.rs
new file mode 100644
index 00000000000..6a3e7c616e9
--- /dev/null
+++ b/gix-tix/src/edit/refs.rs
@@ -0,0 +1,174 @@
+use anyhow::{Context, Result};
+use gix::bstr::{BStr, ByteSlice};
+use gix::refs::{
+    Category, Target,
+    transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+};
+
+use crate::history;
+
+#[derive(Clone)]
+pub(super) struct MutableRefs {
+    names: Vec<gix::refs::FullName>,
+    old: Option<gix::ObjectId>,
+}
+
+impl MutableRefs {
+    pub(super) fn pointing_to(repo: &gix::Repository, id: gix::ObjectId) -> Result<Self> {
+        let mut names = Vec::new();
+        for reference in repo.references()?.all()? {
+            let reference = match reference {
+                Ok(reference) => reference,
+                Err(err) if is_missing_ref(&*err) => continue,
+                Err(err) => anyhow::bail!("could not inspect references pointing to commit: {err}"),
+            };
+            if !matches!(
+                reference.name().category(),
+                Some(Category::Tag | Category::RemoteBranch)
+            ) && reference.try_id().is_some_and(|target| target.as_ref() == id)
+            {
+                names.push(reference.name().to_owned());
+            }
+        }
+        if let Some(head) = repo.try_find_reference("HEAD")?
+            && head.try_id().is_some_and(|target| target.as_ref() == id)
+        {
+            names.push(head.name().to_owned());
+        }
+        Ok(Self { names, old: Some(id) })
+    }
+
+    pub(super) fn unborn(repo: &gix::Repository) -> Result<Self> {
+        let head = repo.head().context("could not read unborn HEAD")?;
+        if !head.is_unborn() {
+            anyhow::bail!("an unborn HEAD is required");
+        }
+        let name = head
+            .referent_name()
+            .context("an unborn HEAD must point to a branch")?
+            .to_owned();
+        Ok(Self {
+            names: vec![name],
+            old: None,
+        })
+    }
+
+    pub(super) fn is_empty(&self) -> bool {
+        self.names.is_empty()
+    }
+
+    pub(super) fn contains(&self, name: &gix::refs::FullNameRef) -> bool {
+        self.names.iter().any(|candidate| candidate.as_ref() == name)
+    }
+
+    pub(super) fn validate(&self, repo: &gix::Repository) -> Result<()> {
+        for name in &self.names {
+            let actual = repo
+                .try_find_reference(name)?
+                .and_then(|reference| reference.try_id().map(gix::Id::detach));
+            if actual != self.old {
+                anyhow::bail!("a reference changed while editing");
+            }
+        }
+        Ok(())
+    }
+
+    pub(super) fn ensure_not_checked_out_elsewhere(&self, repo: &gix::Repository) -> Result<()> {
+        if history::worktree_checkouts(repo).iter().any(|checkout| {
+            !checkout.is_current
+                && checkout
+                    .reference
+                    .as_ref()
+                    .is_some_and(|name| self.contains(name.as_ref()))
+        }) {
+            anyhow::bail!("an affected branch is checked out in another worktree");
+        }
+        Ok(())
+    }
+
+    pub(super) fn update(
+        &self,
+        repo: &gix::Repository,
+        new: gix::ObjectId,
+        message: &BStr,
+        committer: Option<gix::actor::SignatureRef<'_>>,
+    ) -> Result<()> {
+        repo.edit_references_as(
+            self.names.iter().cloned().map(|name| RefEdit {
+                change: Change::Update {
+                    log: LogChange {
+                        mode: RefLog::AndReference,
+                        force_create_reflog: false,
+                        message: message.to_owned(),
+                    },
+                    expected: self.old.map_or(PreviousValue::MustNotExist, |old| {
+                        PreviousValue::MustExistAndMatch(Target::Object(old))
+                    }),
+                    new: Target::Object(new),
+                },
+                name,
+                deref: false,
+            }),
+            committer,
+        )
+        .context("could not update references")?;
+        Ok(())
+    }
+
+    pub(super) fn delete(
+        &self,
+        repo: &gix::Repository,
+        _message: &BStr,
+        committer: Option<gix::actor::SignatureRef<'_>>,
+    ) -> Result<()> {
+        let old = self.old.context("cannot delete an unborn reference")?;
+        repo.edit_references_as(
+            self.names.iter().cloned().map(|name| RefEdit {
+                change: Change::Delete {
+                    expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
+                    log: RefLog::AndReference,
+                },
+                name,
+                deref: false,
+            }),
+            committer,
+        )
+        .context("could not delete references")?;
+        Ok(())
+    }
+
+    pub(super) fn rollback(&self, repo: &gix::Repository, current: gix::ObjectId) -> Result<()> {
+        let current_refs = Self {
+            names: self.names.clone(),
+            old: Some(current),
+        };
+        let committer = repo.committer().transpose()?;
+        match self.old {
+            Some(old) => current_refs.update(repo, old, b"tix edit rollback".as_bstr(), committer),
+            None => current_refs.delete(repo, b"tix edit rollback".as_bstr(), committer),
+        }
+    }
+
+    pub(super) fn rollback_deleted(&self, repo: &gix::Repository) -> Result<()> {
+        let old = self.old.context("an unborn reference was not deleted")?;
+        let deleted = Self {
+            names: self.names.clone(),
+            old: None,
+        };
+        let committer = repo.committer().transpose()?;
+        deleted.update(repo, old, b"tix edit rollback".as_bstr(), committer)
+    }
+}
+
+fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
+    loop {
+        if err
+            .downcast_ref::<std::io::Error>()
+            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
+        {
+            return true;
+        }
+        let Some(source) = err.source() else { return false };
+        err = source;
+    }
+}
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index a48d00754b1..a5fb0c98e77 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -1,27 +1,23 @@
 use anyhow::{Context, Result};
-use gix::{
-    bstr::{BString, ByteSlice},
-    refs::{
-        Category, Target,
-        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
-    },
-};
+use gix::bstr::{BString, ByteSlice};
+
+use super::refs::MutableRefs;
 
 const AUTHOR: &[u8] = b"Author: ";
 const AUTHOR_DATE: &[u8] = b"AuthorDate: ";
 const COMMITTER: &[u8] = b"Committer: ";
 const COMMITTER_DATE: &[u8] = b"CommitterDate: ";
 const COMMENT_CHAR: &[u8] = b"CommentChar: ";
-const DEFAULT_COMMENT_CHAR: &[u8] = b";";
-const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
-const CO_AUTHORED_BY: &[u8] = b"Co-authored-by: GPT 5.6 <codex@openai.com>";
+pub(super) const DEFAULT_COMMENT_CHAR: &[u8] = b";";
+pub(super) const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
+pub(super) const CO_AUTHORED_BY: &[u8] = b"Co-authored-by: GPT 5.6 <codex@openai.com>";
 
-struct Edit<'a> {
-    author: &'a [u8],
-    author_time: gix::date::Time,
-    committer: &'a [u8],
-    committer_time: gix::date::Time,
-    message: BString,
+pub(super) struct Edit<'a> {
+    pub author: &'a [u8],
+    pub author_time: gix::date::Time,
+    pub committer: &'a [u8],
+    pub committer_time: gix::date::Time,
+    pub message: BString,
 }
 
 pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
@@ -36,13 +32,7 @@ pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std
     commit.committer.time = gix::date::Time::now_local_or_utc();
 
     let mut out = Vec::new();
-    write_actor(&mut out, AUTHOR, &commit.author);
-    write_date(&mut out, AUTHOR_DATE, commit.author.time)?;
-    write_actor(&mut out, COMMITTER, &commit.committer);
-    write_date(&mut out, COMMITTER_DATE, commit.committer.time)?;
-    out.extend_from_slice(COMMENT_CHAR);
-    out.extend_from_slice(DEFAULT_COMMENT_CHAR);
-    out.push(b'\n');
+    write_headers(&mut out, &commit.author, &commit.committer)?;
     out.push(b'\n');
     out.extend_from_slice(&commit.message);
     if !out.ends_with(b"\n") {
@@ -62,7 +52,7 @@ pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std
     Ok((editor, out))
 }
 
-fn missing_agent_trailers(message: &[u8]) -> [Option<&'static [u8]>; 2] {
+pub(super) fn missing_agent_trailers(message: &[u8]) -> [Option<&'static [u8]>; 2] {
     let mut has_assisted_by = false;
     let mut has_co_authored_by = false;
     if let Some(body) = gix::objs::commit::MessageRef::from_bytes(message).body() {
@@ -83,10 +73,11 @@ pub(crate) fn apply(repo: &gix::Repository, old_id: gix::ObjectId, edited: &[u8]
         anyhow::bail!("the edited commit message is empty");
     }
 
-    let refs = matching_references(repo, old_id)?;
+    let refs = MutableRefs::pointing_to(repo, old_id)?;
     if refs.is_empty() {
         anyhow::bail!("no mutable reference points to the commit anymore");
     }
+    refs.ensure_not_checked_out_elsewhere(repo)?;
 
     let mut commit = repo
         .find_commit(old_id)
@@ -117,25 +108,32 @@ pub(crate) fn apply(repo: &gix::Repository, old_id: gix::ObjectId, edited: &[u8]
     }
 
     let log_message = gix::reference::log::message("commit", commit.message.as_bstr(), commit.parents.len());
-    let edits = refs.into_iter().map(|name| RefEdit {
-        change: Change::Update {
-            log: LogChange {
-                mode: RefLog::AndReference,
-                force_create_reflog: false,
-                message: log_message.clone(),
-            },
-            expected: PreviousValue::MustExistAndMatch(Target::Object(old_id)),
-            new: Target::Object(new_id),
-        },
-        name,
-        deref: false,
-    });
     let mut time_buf = gix::date::parse::TimeBuf::default();
-    repo.edit_references_as(edits, Some(commit.committer.to_ref(&mut time_buf)))
-        .context("could not update references to the reworded commit")?;
+    refs.update(
+        repo,
+        new_id,
+        log_message.as_ref(),
+        Some(commit.committer.to_ref(&mut time_buf)),
+    )
+    .context("could not update references to the reworded commit")?;
     Ok(Some(new_id))
 }
 
+pub(super) fn write_headers(
+    out: &mut Vec<u8>,
+    author: &gix::actor::Signature,
+    committer: &gix::actor::Signature,
+) -> Result<()> {
+    write_actor(out, AUTHOR, author);
+    write_date(out, AUTHOR_DATE, author.time)?;
+    write_actor(out, COMMITTER, committer);
+    write_date(out, COMMITTER_DATE, committer.time)?;
+    out.extend_from_slice(COMMENT_CHAR);
+    out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+    out.push(b'\n');
+    Ok(())
+}
+
 fn write_actor(out: &mut Vec<u8>, label: &[u8], actor: &gix::actor::Signature) {
     out.extend_from_slice(label);
     out.extend_from_slice(&actor.name);
@@ -155,7 +153,7 @@ fn write_date(out: &mut Vec<u8>, label: &[u8], time: gix::date::Time) -> Result<
     Ok(())
 }
 
-fn parse(input: &[u8]) -> Result<Edit<'_>> {
+pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
     let mut parts = input.splitn(7, |byte| *byte == b'\n');
     let author = header(parts.next(), AUTHOR)?;
     let author_time = date(header(parts.next(), AUTHOR_DATE)?, "author")?;
@@ -222,7 +220,7 @@ fn date(value: &[u8], field: &str) -> Result<gix::date::Time> {
         .with_context(|| format!("could not parse {field} date"))
 }
 
-fn actor(value: &[u8], time: gix::date::Time, field: &str) -> Result<gix::actor::Signature> {
+pub(super) fn actor(value: &[u8], time: gix::date::Time, field: &str) -> Result<gix::actor::Signature> {
     let parsed = gix::actor::SignatureRef::from_bytes(value)
         .with_context(|| format!("could not parse {field} identity"))?
         .trim();
@@ -236,43 +234,6 @@ fn actor(value: &[u8], time: gix::date::Time, field: &str) -> Result<gix::actor:
     })
 }
 
-fn matching_references(repo: &gix::Repository, id: gix::ObjectId) -> Result<Vec<gix::refs::FullName>> {
-    let mut out = Vec::new();
-    for reference in repo.references()?.all()? {
-        let reference = match reference {
-            Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
-            Err(err) => anyhow::bail!("could not inspect references pointing to commit: {err}"),
-        };
-        if !matches!(
-            reference.name().category(),
-            Some(Category::Tag | Category::RemoteBranch)
-        ) && reference.try_id().is_some_and(|target| target.as_ref() == id)
-        {
-            out.push(reference.name().to_owned());
-        }
-    }
-    if let Some(head) = repo.try_find_reference("HEAD")?
-        && head.try_id().is_some_and(|target| target.as_ref() == id)
-    {
-        out.push(head.name().to_owned());
-    }
-    Ok(out)
-}
-
-fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
-    loop {
-        if err
-            .downcast_ref::<std::io::Error>()
-            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
-        {
-            return true;
-        }
-        let Some(source) = err.source() else { return false };
-        err = source;
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use std::process::Command;
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index a88945c33f8..4ee0e5ee4d1 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -194,14 +194,14 @@ fn checkout_pin(workdir: &Path, pin: &history::Pin) -> Result<()> {
     }
 }
 
-fn checkout_detached(workdir: &Path, id: ObjectId) -> Result<()> {
+pub(super) fn checkout_detached(workdir: &Path, id: ObjectId) -> Result<()> {
     checkout(
         workdir,
         [OsString::from("--detach"), OsString::from(id.to_hex().to_string())],
     )
 }
 
-fn checkout(workdir: &Path, args: impl IntoIterator<Item = OsString>) -> Result<()> {
+pub(super) fn checkout(workdir: &Path, args: impl IntoIterator<Item = OsString>) -> Result<()> {
     let output = Command::new("git")
         .arg("-C")
         .arg(workdir)
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 477a618df13..2aeb3440df0 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -190,6 +190,10 @@ impl HistoryGraph {
         false
     }
 
+    pub(crate) fn commits_with_descendants(&self) -> HashSet<ObjectId> {
+        self.parents.iter().map(|parent| self.id(*parent)).collect()
+    }
+
     fn parent_ids(&self, index: CommitIndex) -> gix::traverse::commit::ParentIds {
         self.parents(index).iter().map(|parent| self.id(*parent)).collect()
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 2fcf66d6840..f3fea1a50c7 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -854,11 +854,12 @@ fn event_loop(
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
     view_repository.object_cache_size(None);
-    let (mut repository_is_bare, mut mailmap, mut ref_snapshot) = {
+    let (mut repository_is_bare, mut mailmap, mut ref_snapshot, mut worktree_head_unborn) = {
         let bare = view_repository.workdir().is_none();
         let mailmap = view_repository.open_mailmap();
         let refs = history::snapshot(&view_repository, &revisions, &hide, worktrees)?;
-        (bare, mailmap, refs)
+        let unborn = !bare && view_repository.head()?.is_unborn();
+        (bare, mailmap, refs, unborn)
     };
     if recovered_at_startup {
         repository = view_repository.into_sync();
@@ -886,6 +887,7 @@ fn event_loop(
     );
 
     let mut app = App::new(1);
+    app.set_worktree_head_unborn(worktree_head_unborn);
     app.commit_pane_background = commit_pane_background;
     if recovered_at_startup {
         app.notice = Some("worktree removed; using the common repository without worktree changes".into());
@@ -1191,6 +1193,7 @@ fn event_loop(
         if let Some(result) = refresh_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
                 Ok((graph, result)) => {
+                    app.set_known_descendants(graph.commits_with_descendants());
                     history_graph = Some(graph);
                     let result = result?;
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
@@ -1203,6 +1206,11 @@ fn event_loop(
                             .flatten(),
                         false,
                     );
+                    worktree_head_unborn = !repository_is_bare
+                        && open_repository(&repository_path, false, false)
+                            .and_then(|repo| Ok(repo.head()?.is_unborn()))
+                            .unwrap_or(false);
+                    app.set_worktree_head_unborn(worktree_head_unborn);
                     decorations = result.decorations;
                     selection_relation = None;
                     app.selection_relation = None;
@@ -1386,6 +1394,7 @@ fn event_loop(
                 }
                 Event::Complete(graph) => {
                     history_finished = true;
+                    app.set_known_descendants(graph.commits_with_descendants());
                     history_graph = Some(graph);
                     selection_relation = None;
                     app.selection_relation = None;
@@ -1690,6 +1699,23 @@ fn event_loop(
                         Err(err) => app.notice = Some(format!("reword: {err:#}")),
                     }
                 }
+                Effect::NewCommit(parent) => {
+                    match create_commit(
+                        terminal,
+                        &repository_path,
+                        repository_is_bare,
+                        parent,
+                        enhanced_keyboard,
+                    ) {
+                        Ok(Some(new_id)) => {
+                            app.notice = Some(format!("created {}", new_id.to_hex_with_len(7)));
+                            refresh_select_top_requested = true;
+                            refresh_pending = true;
+                        }
+                        Ok(None) => {}
+                        Err(err) => app.notice = Some(format!("new commit: {err:#}")),
+                    }
+                }
                 Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2679,6 +2705,33 @@ fn reword_commit(
     edit::reword::apply(&repository, id, &edited)
 }
 
+fn create_commit(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    parent: Option<gix::ObjectId>,
+    enhanced_keyboard: bool,
+) -> Result<Option<gix::ObjectId>> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository before creating commit")?;
+    repository.object_cache_size(None);
+    let prepared = edit::create::prepare(repository, parent)?;
+    let Some(edited) = edit::edit_document(
+        terminal,
+        &prepared.editor,
+        &prepared.document,
+        &format!("tix-commit-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?
+    else {
+        return Ok(None);
+    };
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
+    repository.object_cache_size(None);
+    edit::create::apply(repository, prepared, &edited).map(Some)
+}
+
 fn run_external_diff(
     terminal: &mut ratatui::DefaultTerminal,
     mut command: gix::diff::blob::platform::prepare_diff_command::Command,
@@ -2883,15 +2936,29 @@ fn load_changes_without_lines(
         ),
         None => None,
     };
-    let changes = repository
-        .diff_tree_to_tree(old_tree.as_ref(), Some(&new_tree), None)
-        .context("could not diff commit trees")?;
-    let mut out = Changes {
-        parent: (parents.len() > 1).then(|| ComparedParent {
+    load_tree_changes_without_lines(
+        repository,
+        old_tree.as_ref(),
+        &new_tree,
+        (parents.len() > 1).then(|| ComparedParent {
             index: parent_index,
             total: parents.len(),
             id: parent.expect("a merge has parents").detach(),
         }),
+    )
+}
+
+fn load_tree_changes_without_lines(
+    repository: &gix::Repository,
+    old_tree: Option<&gix::Tree<'_>>,
+    new_tree: &gix::Tree<'_>,
+    parent: Option<ComparedParent>,
+) -> Result<Changes> {
+    let changes = repository
+        .diff_tree_to_tree(old_tree, Some(new_tree), None)
+        .context("could not diff commit trees")?;
+    let mut out = Changes {
+        parent,
         ..Changes::default()
     };
     for change in changes {
@@ -2947,6 +3014,24 @@ fn load_changes_without_lines(
     Ok(out)
 }
 
+fn add_line_counts(repository: &gix::Repository, changes: &mut Changes) -> Result<Vec<LineCounts>> {
+    let mut cache = repository
+        .diff_resource_cache_for_tree_diff()
+        .context("could not initialize commit diff summary")?;
+    let mut counts = Vec::with_capacity(changes.diffs.len());
+    for (path, change) in changes.paths.iter_mut().zip(&changes.diffs) {
+        let lines = line_counts_for_change(repository, change, &mut cache, None)?;
+        path.lines = lines;
+        if let Some((added, removed)) = lines {
+            changes.lines_added += u64::from(added);
+            changes.lines_removed += u64::from(removed);
+        }
+        counts.push(lines);
+        cache.clear_resource_cache_keep_allocation();
+    }
+    Ok(counts)
+}
+
 fn entry_mode(mode: gix::index::entry::Mode) -> Result<gix::objs::tree::EntryMode> {
     mode.to_tree_entry_mode()
         .context("status entry cannot be represented in a tree")
@@ -3221,7 +3306,7 @@ fn unstaged_change(
     )))
 }
 
-fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
+fn load_worktree_changes_without_lines(repository: &gix::Repository) -> Result<Changes> {
     let mut status = repository
         .status(gix::progress::Discard)
         .context("could not initialize worktree status")?
@@ -3249,10 +3334,16 @@ fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut Line
     staged.extend(unstaged);
 
     let (paths, diffs): (Vec<_>, Vec<_>) = staged.into_iter().unzip();
-    let mut out = Changes {
+    Ok(Changes {
         paths,
+        diffs,
         ..Changes::default()
-    };
+    })
+}
+
+fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
+    let mut out = load_worktree_changes_without_lines(repository)?;
+    let diffs = std::mem::take(&mut out.diffs);
     for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
         path.lines = lines;
         if let Some((insertions, removals)) = lines {
@@ -3351,6 +3442,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
         KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
+        KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
@@ -4220,7 +4312,11 @@ mod tests {
             Some(Action::ToggleHistoryDisplay),
             "v closes the view shortcut group"
         );
-        for (key, expected) in [('r', Action::Reword), ('t', Action::TimeTravel)] {
+        for (key, expected) in [
+            ('r', Action::Reword),
+            ('n', Action::NewCommit),
+            ('t', Action::TimeTravel),
+        ] {
             assert_eq!(
                 action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), false, true),
                 Some(expected),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 1be49c3c737..7b6b793b71c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -676,6 +676,9 @@ pub(crate) fn draw_with_worktree(
             if app.reword_shortcut_visible() {
                 footer_spans.push(Span::raw(" · r reword"));
             }
+            if app.can_create_commit() {
+                footer_spans.push(Span::raw(" · n new"));
+            }
         } else if !app.history_display_expanded {
             footer_spans.push(Span::raw(" · e edit"));
         }
diff --git a/gix-tix/tests/fixtures/create_commit.sh b/gix-tix/tests/fixtures/create_commit.sh
new file mode 100644
index 00000000000..320bcd3fc33
--- /dev/null
+++ b/gix-tix/tests/fixtures/create_commit.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+set -eu
+
+# A staged version plus a different unstaged version makes the staged-wins rule observable.
+git init -q -b main .
+git config user.name author
+git config user.email author@example.com
+printf 'base\n' >tracked
+git add tracked
+GIT_AUTHOR_DATE='2000-01-01T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-01T00:00:00 +0000' git commit -q -m base
+printf 'staged\n' >tracked
+git add tracked
+printf 'unstaged\n' >tracked
+printf 'untracked\n' >untracked
diff --git a/gix-tix/tests/fixtures/generated-archives/create_commit.tar b/gix-tix/tests/fixtures/generated-archives/create_commit.tar
new file mode 100644
index 0000000000000000000000000000000000000000..0059d8d99c2310f70e778c4e259f8d70e1893957
GIT binary patch
literal 64000
zcmeHwYiwLecAjP(WWi2=Y#xTOe~g+|XGu!zC*RbNGa5>>!&!|eOH{Omq~YA|zD@S1
z*|*iVTNFp5MHWdA<cER4{t>`=Ab=AD0X9!0K#)ZY7)XG`b{xQf19%bS;j9A#2@oI;
z+y9d9JE!XQ?b}T@NwMXbohD|~-S<|VsygS?sdG-9I+e>`8v9=Xf6I%Dm-val<fl9<
z78aI@g;Jq3FYlM<ON*Bl$KEqE&<#6Y+n85wN`@92+$#foJpejwukysNj<qqOW@%v|
zNq6_VP$(8J_0zvtSS*1L#@Z_j{7X*%ZWH{!=T}p&1J{!_K6e<%?bSQu?iA<$S>^xo
zVre4($4wZ(C;juA+aG?owX=Kk#@5b<_r7`It&Wucg~g=&FBOaP6ZwDPlo$k9_CkLm
z`v>vzWqBg=zuv6+&&N07QS-mJw3M9x#R8s9^uO`Z#6iBXb$1irzk>hY_~f(i=ghO8
zth&!PE?xTCPi)+Idg;=4{}x{VUzGV%`2VY4|IJ_h3xEE5b1(nhgJ0kOvF`8uv8liQ
zFTZ=~t369%=kCp$DEEgiWs9be`s%Oz$#=fH^n+jfi?@Gx<J$lEPyhZGzW<N^JKj$I
zJ{K5}`QP?y;TU^!cKxqdScXkFvH!<N6bm|{e;#Jwn3&)k^e-+gEKle^e)6mS&-tI<
z_r2<P7~nkgUtXU0|6T+6ll0FYc=hH*w>wJzD=ZH9|4Pfn<%#}x(S#TRZ*|G{=e;sM
zR!g<QidQZaykfabZ+vOFyyCCSSG}dx%F4t>9D=+bfk(3b?+3w?@rZuG(0SxP9EOwi
z|26PekN){qH{8#5f^22quRIC5om}W0v>N`acVYzn7w6}fllK4O;xhJ&UcKqj5WeL5
zKbPOkm+Q@ZxSvX0HrJcRe=bBf6bUA*wCk;o=>(?Rs(KyYct)7RuV%p?rqlL)6EyJ@
zPGm#&$)zp>%+7v2Q~>y_H=hOAU^L|;mddvMieG=`XIt2IoGH$l!+pPLP`mAWl}^Z}
zPzo>z&3MhKZ8=1Nn&0-D6@Mn21yI!CvsMt+J3;$sPRa_f&b}|T0i@He`vTK;pRdYo
zuUXkQoqexk(7j5x4XB;QksF!e$k;Fn1BC5wuIe|BHnr@#3ZW7-YxTWu+w0VUgJ)j5
z?v)!pVTL|&hRWLP7Pi=+TPtqfJu+3l=5-sLITLo#5l@GTY8YWR1g7dWwrviB_LF*Z
zPqAz}gn`3T2grezY5NBO$kM}u+4n;99*xv%7GI{;4h{rjG*$qxbd=Fnf`fy4=bF-@
z9CV1CliD{2UZ=7TAS`Bq8U-@PXGg|s`*!faW1!`wbkjcss!3c7v{P^OhN5)I^)nCZ
zmH~-a!PnrK-)`5dzCf~A1c0)??>(yr-S#yw-Jy>{+OYs7%YGv`1b*t2WCtKL*a4lk
zm3vhIhKMr^2Ivs$t)SlQm|D=rz?#qeW*v3SK>)PYD?)L{>b`Qi<r4+3xG;xxpz?6P
zF6@S0*ISNm7HRCfG84$ZhZaF?9kEQe>RL)6t!Ijyo?9JL@i;{>Uj(*inn5%BsoxIR
z@lIEGUD-&6DU)c%O|fd=hkz0WbDVGo5PYa^2X!Rng}V&KoTUG3E>*4jW@gsBNKN^b
z{lIK|qh!*VD{1^>cZ#W(?BRBspxMa-?+L^O7_o^7ABJ9=6U=Mw>3mGW*9jM}T|m)p
z5EE@d$-WQ%m6sq~SZ{+HI9#wOg$H4cK&{S0;USg=6GrUHi4{j^44F#d_ka#76ot8!
z+#F&^raCh1Zd2qRBv>^oA~D-F*#q<b&FeRSqGDP`1guucn1S&Rx(#-oGPCAmB4Gq7
ziwFslja_V$jYBXhMq8nP0T3a%le7?c%4?m&KwAZ`9+1CSBH5QZ2@f)WiR)eion{+Y
z-a#TT9x8+Yj-Ftw{N*$N?U}w4-cfD^4Z+orbx(Z1WhrDDLB(rCG`7R&lVLK<D&->C
z4%5qTQ$*>w*rAxrD*K&7-xAj~nj?qppqx%>Oc@U|vh8PscD8}RkxUh?N?tPrhAEYS
zZb+I&!_B)*(7j3)<HVLGRTlRIfxH0@rbCfZaeYWB57AL?Qc9B~1i?wR+X;57eyb52
zVT#ncO(7X+S?<;wkSF>0vX`qUXWgdg7Nii2EVzet^c51%f9_Yh9kde3?wE*Ip5UTq
zQ5hAAqZ`Xhz@_9U=$b<h!V9=)0pr3Y_#y}jv3%QM^w*VI><mOJIvE(R>Om90V+uqF
zR<BY4M}zncti6724@2S-?^XHCq$^dE%caRr-H;F3J}ClFEw8g5f|BUjo5E{4H?unD
zvrkPnTi<Jvs$sVbdD{hL@eD$(?L$ccrkbfK%A)lB7KtNjiSVnbdEm)vI#sL3z>}x4
zHM}5{r`<Z1=HV^GK|iodZ-i-CR$Zu!V{&cDsyo7s?V!7d=^SIgptdF|kuh|y?P7J_
zg>poV1&s2xNmEFq&6>IS;hmkI-sQ&0?!EV~7kA&k`E8;|CZpGp0hp|>GNrVUulmpO
z&2FP%J5AW@1eNj|*v_4j-<cWKMvME|p!^A>h{;-&Et?HHAd`73f-^e=X_g`p(kdR%
zTpfzN3>(Co(Kys#qkarVtdNvi>5MLa={VfYpxda51hGn8oN>vil<tC7j%l?1|0ORG
zv;P#I7iRVK5Ie&DTSnYx(*B#5c)=cs@qL@vf7bq^<#xOQSjPJP#B`fp6N@+07bsKM
zFVgi1T7^$djcdRr)C;`CQjn(jiLZNUtF*TFx}u4%;ccx+B_!PUirE0uTE1Wcs~HJh
zsVO#9#~GA!s3JAw3B@{Rd|Ej-t;_1B*k$NSR{ros+*>(xEI5n}056PM8|5Hq_*Ce8
zm<P})vB+TEN)FYn%>oBQgaYFfR)cOiOEhOp&&H#Ia0E-PIo-jsPW;6BQuP~t#|Iim
z^hC;W5fzLNc7u%wi1TzpOq!$7o$%N?wE82eCu#=)2VM=7Hx&qOs$03($fZMIfD^~A
zn%!xK@AN>hk!ndjN}Lx3wCbhz{;9g6<~Dr=GGdTqpih8UM>H*YD^lf;V-4sGR2#^b
zzPJZa4LoZ$VUN=;X+Y6T**UT<mIUSqECYNmrBj$D`h7l4#h4ZEc`zufCxhz4LzDd!
zCdfAt+lM%hw0V4uh=KwoCS3Z4@FlGdnNHT*6KRuNd|fx7%faGv70nEQJH>KNzExyd
z4!bRyM7BX`jP_A~Ws@nGw=k>?^OlYWUvw}Vv#zAtlvb0o!?2i0n{1%t(%QY>3S?lI
z-4FrJYbUfi*r=leJv^zT;8<79O8q~;d*`U-uTzG^CwEMI%qj$(?#eKy0uiq;n@Y0k
zC=ki=eZ9b39#vmP9f>GgJCYWssvVV{C4*We9VS6DpdBy1MOwD4c0l!%j{ugw9%#DL
z#i!Ff)`g-Pl~2#6DhOJ{%UH!U?XmRzCKrclOd6-Jn9ocaRV>S2xpKwa(e~nfFtU_D
zS5`p{!xL*kKU+*)yO#1puj1y~CcWf_w5M&2`H)fe<CLbtlgs7!L0=1ONjOf$$;RbM
zk%~uP=v;~p2aC-<U41}D$3Qx5GySlTUG=iH$J1uIFg>fYJZ;-fn{}Xt5Mz@-yR|D^
zs!dxfA^yU$bYyCD+;G$~un2cEaLzR-PzCo>co#|xN&d>5jul9sf)BKr?b8|XFx(H?
zom~rTJ@dkTyL`C^<0XoT083|*(=Tn_#3(!Mt{)rZRE)kmu%?r(&Y4VKs~}4#Mue5V
zDy;FWw}x8s$06Sb+f7rg;aUi(<bfvH(0~@=PoP5Nq#_9o{%m=BP?ntZ1S}P7Q&SLa
zQ)H<=yeWAUZ<b5AGWVlGU*P#jMBJc)LB&BA?=y_}#9pFl?P8Lyae_s2zpt0(8{ZI{
z77G`40O;V#SmK)v6Ir9CwDFB1My+dAoB%t(`?RYvjir+&;}IQrVJD1XnI6hC=lX~A
z*dCn$2QeVSkw8;7Oz^l>9wIuqg{e0i!7AxYQY6cCJ%N!ootELn+{E;qorY;o?)?x>
zOAaEo0O+eeN;*v<PMsLPX^pc?vf=$zjVp<72{k2AqdrG7saIjh5C`kUSyn5YeXI$n
zuQcc@I<u}fkD!uafb{1;+Y(nVT%~ZR_nyDavZ~3E)$i*T9Sw{%$iFAe;1G%()+ahY
zt*-<^3G=Nt>9~!=5_bKt;#@Sno~TMJeDBqpb#C9JM3xmME|&56CSC*NnE$5*rz@S=
z7w!R~9(2O_uhQcDK>Ytgaei|C=QWW3(kb`<u^WYT6wVRdsq)IQ|1W!$x|s{NN5AU_
zN-^K0t&c!m(P{)hL&wq%NhF)sx^p>)trGf3ph(5U95iA)gT<=AU?m%~#jS5hL~E{6
z3c+i`t=7TqP%M@rMxDpN_H{5y0ee?;TL~EUtrpNKrv!$Y0-FMEj!-@MnIcR+bDM6f
z{!Mtu*4|z(8{$Gx_6egJz>vReG9^~MfA<!Z!;{ORG{#9Ntj}%{;kuWCVOlFk@P}7e
zBRuC-i@YQL)2`Q0m)KU5+djG_W=V%Js+KN$d5l8<-nF-iB=%m+dAKvUOGsw~_m|N#
zA_!D#R=qaeU@i2_`a0N*+wgcxcLcHCz`ob-LA{FamhSq({@|M)RW$Gj-oW6Hfh32j
zOk+zF+gO5GV7}LT?jf>EjQ|cR?ltd8_u3sAW<t^QgRMJhGsB$%_7r;g9(I#L>}tck
zLL{nprQ2?(YvomqvXpL*QaROqQ5rk;8%An5Umj}vyLg(y)+lYBj*pG`bVe}7=P{!$
z<y7L!=6#?a-cQw8pa-nM!j-+B7>FM1J{S%NjI-O=D^Z09n|O%)0gb6#I^+WG6gIQ=
zh@W16sC8&lfMB%_FtjM)<kloW*qOrs_Ij7g^+TuIho+;N*fgy`KMMjcl=9YQrX|sU
z_HVLH!<h-fw#@WLs6h9Dbe`6KgcTI)Z7U^A42fxYFX+Pc)@zUqW4i|;&WX`z=Ouz4
zfQq={ik{0{|KjLIiS^&3{|<Y!m5bB@My&sZrNu&W|7UT&IEnvzz3czU`#&cr06HJB
zB?NKH5P*n<bax0FD}ENo3K~v0>zcF!i7hb?kn-Hom3bu6IvLZXn+)|Z>{7aTR0hxn
zd@G2!Lj;8r`4FAlZ$PMngh64Gy(P<ncF#6?>MbQI!@ZGUYblkZ=OT;Ubhrk)EqE<`
zD~QtSJnQ*1Acatpkq+t+&J&mxp2c1^<$Lxy#83nxO}_|ZKKdVKUKFpUGw-Bdrq;%0
zWhLhSf#2S9eZ4R{VC4K?7@YqI3ZBIOz6Jr%)Bj(6{$q|Mi~vkd@RQy6h1);UQlZBu
z1OV!uUIYvk0HT{BvIRk+^v4es2GSp^N}NX|#OKElq0pP#b_*;o`@Jy%z^R_X=Aiu9
zDSvF)G0uC(TJiZGgq^H9iY{#GOEaV9e`$Fj|Hs18Wd1u6jrH@i^B-#!EMZs&Fo>Bj
zEVfZ1n;(eLmiTN;<7)SytU+)s?DHVlPtF9Ke&y}4A!nG(5$?GtXJYkjLl;53U@aKi
zqBvHJf4+dn=f9HJYAV@-aPNY|z=-)@S}rXl_5Y>9^5p#I>)@2L&VM>uRF#eUTZXLs
zTF5T_tR-<<)@7!VTXZJU!-uyJ8y2cn=jW^o4w42o1?$H`0G#JdtDvr}gpKwP5y}-m
zre5G#tJ_8hjvURQpP~w3(i=vvwgdq<2ctDk7*l+lcah=OJvj82!ME0i9du@iH!$%i
z`1;OKH7kuS5P<f0=E|N&2zgotzRG$V76n|4;#YbmrHIh<Wpf8{Z5X%&=*9bL@r4+L
zGy;<wEr&qca{vut-M|l0?==kh-tExW2O3IjA499*aUoq1tRTlvvTZ%>05lUb5iLLA
zVH4}z<qN5=br2*jV2OC1$U?_SR(2Vr_bVP(7Ep|*R~Vg939w%!c49V*meEJ}hvat%
zho@{zIbL#04;q9U7`{r2H%6&5B;y_;&3Tj!5#r!6IymWQ?CZFM=i{&kdKGqDa6TAF
zJkdLJL*u_T7Dhxp;TT*H0A*F*1Nm%DHRMy<eQ)d5O&;N~kM3>Xzq^SCr4&QG*E92}
zRK6Rw<s2RY^BX2x&y~F=@Mt0007fpHp4}!7ILsX6Kgx}wX+D=jvCEnKEFEBpUPz>v
z4d&?U&0L0kkw^}NuFZYc@o}~V*7e*hMvlMX9Rww&^*xGcPt%W@X_GS_bH%m{5(SR;
zbIQl4IYmVsz0K1A&Ilu4y=vCiO<`E)4R#{Yn=7;W#YN-X+kV$N191pXV$XDFJ2&s{
zZr!+fdk0Y(5>?bR(_#LjM>DxA8;@plS2FoN23RwXiuo2oYA#ENf}Br**3-f18XhcY
z^8i7;nFU%ZKEB$gz%klS4@0#?1*t{AD7-#=bDDtB$X6#JH-=Ln>P^MaE;;q;)nOO{
zIJh9svTpRR|L%C^1uguxBO}&-q<$T+{}&dQCieeX=y=|;r(OT$JfA4}x-Dgb7DIk1
zVr3C>qSYRXV^{(fBJL&VhK-g6&tuJp;BVU#jMFSwhDEVXLBeR$w$EU|UR6Mej`^ka
zWjYR%0vP=|&!X$NovSUTmrhmg56~dLbN}A^yW4kmwzhBYZf@Vdz2i=y)Yl8CDc#_a
z8tF_OA*c=R*&I`EiaR?~{xh79OXHuezy4^TD1e}h70pse!|Ei!Ll7jPAvWGaqCTQP
zUAh-tpuL8FWL^k}%U9N4Mqz9WkwLT>vC9pS-o}N<QS6XFh|bi_Ra2bBd)dY~qbxZu
z4^Ha+!C@dK|7+nv(Bx_Q>>)RR5c_>W%fQL<zgQfS|8c2QnAm@>gDW8a<GN=mMHwF=
zaYChYO}-y`?I!kJLjARMXLD_ByX7}a*Jz;}e_n{{(;g0)`sRUUCKR99?{r$>T0UQc
z4uy#MC*;2UZaG&E@{Z^7$O(amqJu#j4_iL$fNl%sUk8#4Jpml<D08ilAXCOC$N|ru
z@gn<5SQlCzjyxlJ!SFCO&jZgyDG*F)RzNg7SSC?)+!N8rG+2W62aHqZ1dwCsY*0-V
zyT4RrNCtv2(3v;@g5_F<rBAx0Yo45=WhhIp(>NFlO_JtDygC$oY#fDhJ|AFk+9o<X
zYmJk3fDlk?NcSCnWDi5S>40`Io6&b53}FJd@87c6Ikg+^Y1eNbMUntvJOZ4lIV1ww
zo_@d~U_TcL4il3m{q?cBrw)$HOvX|I@z})tu8thXr-AudM6bVd{q8sajIh@IrZoe_
zy;$|j-Mu}fzADA{c5d9fdl!pt!8o8pV8R*^Xf|3OxK`ef!{=1wZGX7_N1X#n$sR~`
zpa+ecjDr!&-sq@$0~TnGyQW=7rgLHirKV^)rQZW9py!6GI1S7Y_9UkitZ(TaGA95v
z8BB#;l5<yb2&|huUw@<IE)F8k%wixc2a^QJ6xL1A{{AEkn!BwhdpMpz4FkPyBlM>Z
zU+o9?wr{Vkefu63{){Wd69VozP%{N6FKIzngTb12?hLPa=MHMVMDq;~N8R^#-PDyX
z;@GxHJSSxKJV4{F?5<#vH5i(K2-n`&6`o(6$po`Pg(;nOh?fbGHwBNg8!sw|M|tvc
z&b;$Ne#%UH`I6vXG8F}T(O1j%VJ0IL>s8d0I>L0j7z<-rhO=DMXA6-<;e>!R;h<{!
zb0)o!#y`URZhTCT17}GNA8GaqGr8V`yh5z4)L83wYAZk^UMN4~F__u*?om^FC;WjT
zcnq<OBJ8LGgc-1Xe+Lamuq-4C1i+pBSYS&UgO!;h3p|o1`dXU;MHOvs1iJ#p(GIw8
zLEZOJ`RVgWShHhb>U2Nzrt@e`rp|kEB%e$VZnlLH{{%@q-Cre|F;gR^i=4E1n@2zj
z#04fpw~YWD$KKfuh~w-Ak(=G9!iQD$XE0;5@1R3+jKYO(j4gC+T}WG+d30s-{aZJ7
z1;O_F*6len?XY9ApV0ReWa%R49Kmfc#aYC}1mukp^FYYpaq#R-D-A{rO_^{@6M$&P
z{O154%F?AtFAn`_Zo-6;8HkZl^r;|=LoK$}kf$`)3YG&|V+LidL|gJGL1aXbd+Bq<
z_Gu0f2xJEvwn*~;PY?pWu~5~+IinrWKt%E6NegMvx5=Cm=n;rb9Re>2gLX-?as)>r
z5*LZ|!=V)9B7h96)+KpE6Ewmyi{&L<tNV>=m}ap?9Vv+%5S>eW%sK1E+-w|)1GG8V
zsUF?{%tu}n><yzcwQd{Tl9WDJ)RE~@R$mn>uw+F@#g`><31YTz_E1Ves-WJ?AUfv^
z4tgP*mH!l}FVZTs2207rLnK{t;d>+vO!d96O+S755X_@E1}6<voqLR~;jk1Xk+RIX
zdF!q8)Xm#B*y*W<X?aTV)IZ_y<V7DiHb}G35n;_dOq03NkLToZ45jia=m5mSG*%`l
zW#wP`@ne*JiGR?86NM_7Cz?#sNm6LET$Q3Z&UY(Ud*V|ufMF*Drk0TTymi~+38hr1
z+Q;~<i)$q2xFTASnZIV<a^hfv3m;lIZn22Q1=d$sy>T78Sh%9cjLW?q9GVE62Uf#g
z6VEwkl8Qwrfrz=V3(@Ihkcd~;oUk+5XjCi6@#Zxs*JaHEpE?MqY*gLby=rFtJMaoW
zdVzK1+#-IMMqvd#GzjUaTl<Cbh#G<LT8EY*@1SDH6Hr^GzE!(6OhH6dMvD{I_A9!4
zkjJTC=758s0tSKx^4*BCp1XpT0g{k;Uku#ONMNU@4`l-QRoFZ)Fm1GrY!*!>nK8cR
zN~MAM%r!T;=!(-Wnq*q<*oF5Lx@zCzi~cIAh_utLzo>KqqLYlKWt}p8D%C)slWk6z
zq7g>4|5A3e;L*a7LYEXW`2E1nLm03y{=CMacf<pwqM`K6L8hgG?9*L4mDwTvgIp`6
zsJx|Fnr0F(d*BNU0~YEWrA@7YLy+JwuGi#0$SKqi08s}Ntn9k6By=wnX8Js}t#LGr
z*`W?0fh7e%%R7?#Y`KE)3&uPXJnA->2NLEt(lg>f1J>+k^(xL4$U=-2Q~0z`uNRF_
z^!k%XjhYFe@=CN;+6*-iX43ieEH&`{^;IlRneLG>AzY(2RMLWhHb+6=)J>?KSab*E
zV*e0EXnQi3B5t*$r!}Tpc*6R#k}G5FeHw)5gBYzJZBtxMAB0EYwE65ald%sfM|(KH
zGHpdmtRhDJpx&G>t*w32?`$4cEwTDad<OwM`A3iPkMfi&FZCSa3&DWemZ*mpQ}GS~
zE}pKfRV+wi$c`&sj6-}Ko~=n6r@=tXW77+FzQEWY_TgmzFU|%Ip8s2%FBK>8zo#MK
zE0#I!{-0*=&;^3oV&l<2NQVIT9pZH8_WXQC|Hs0OCBy{FF_Z3ag-gT(xu6xh!ksO4
zu{U~7p&<dn8nJ|TI8i0}`A#@Bpk)cD@6<p9B7SNh_V8?{24eG{+lUJ1g7$qJYmS)z
z^Tnls`yUn-kQ028|Jz}3e4nSC|Ii(eI{>Ua!;mP<|NcY3VvyF6Nyi@S8SeprdJP?b
zXu8NVKsq=ZAwZotK4C3Vm~GPZl5%SL5{OD9+Cuu5I?{i~lXK!^FLqgxhSwrz4T?Pi
z>1;`;^vDq0LKZL0t}dB7dvH`}^d$;{n$DQOD0_-#?2+@s@nke2@!$_=X0PAd+}aZH
zrp`l2SI$tjD2F+uBGZ!OG;tN`cwwc^_y8i{<h)m|u%vvt3)xDu*E$9$ZS{OcPQ$v3
z%rrr!X$MH(%YZX(z43gm#(;Df-iJ!wGoG3q()Vj9E60KX1PDJ+ccva=Mv$KhcrIFq
zu(X-tbLIg9D3PldW8o|8Me+;cQt%6K#9Jh0yqq4@XcagpwRDK^cNj_g*kr3P_Z=-T
z^wP$NB1EtXv_UU_2m@VE?hw+KJ;mS<2n@d4eHnmlbPbNrBEX&zFi0m0=t$nvMu;I!
z;nHgWYYZMte-2wF$SXx496!b<YB{zw=oIE=l~=Ae>SUw9+zT4WP9K_L0l~1*c5kOW
ziyXo94-*P8!2n8lmu&~Io+G{m0lF>jbpT9_HmvoT!exu#N!e$VuE7+PU>Ic)GPKL+
zo9z$(3*fbd<6KI>nF|!IUuQPAjN|{$xNCN6bNBkKTkD$~dbWzBS0?+N$Bz&c_?bDZ
zm~3TMHUMl|Sma}e&-2mE?e|hQ>BLzx*E@_~1i_fMm>BG59dRHd=11Z;naNv&Ou=?=
z-W(vLvzOeCAZQq=0BiXH(#UiB0(k{Me8;iy9jA6Q8G>LQWx!m(xL18v4|^^l&Nt;b
zxUo@ZOB-UU7EP_d2}=@GB^Nw@v3peqgOgMhF>%1JrErocHYK?k8ET$O$8|D~Q$&r6
z_u=7c5e^&y^9H~Pu#bRNWo$7>;pSJDDVYM%vEXm+U&egz<a%yz*m=x8^wV6Dqh%fK
zBjO@O@c5Rp3FLENAg2EzJABpWLEWr)b1}IuNDmyL|1B&O2G4&KC+EM<LCv#Q>FIxv
z3de`@IF5iUmFxg!1|lHOrG`FFM4j-am026&4@l%C$_xmGXLS!6jR*@drXW)!YU0f2
zzT<~J(S$u*KxvIuBAw4F1R`doS>6{TyPT>P@D7Bt#=;EF3@C&gOfS=~+^HdcUs>Ut
zxoout!O{#dM0t*w9vX@aT%t1==hOpgu9UX!Vv=qP8;!nqV3TRc@&hNQC|?c4X7OGf
z&_YjX@Nx|<Qq%);<~noo0-Pn8ggxP=8Q#KC>*6K^=HKkhx&R{XC|V+76PXZ6NxkX9
z!2~duKu7b9xL{j!xR)r$>V-~;#7d<@74<T(JJNlF)C?e0q0oZ;!9*#djB#ONT(2zR
zbSg+yK_s_}Rj+orW+DRR9HZXV<U%tRp=%g-9q~hYoZ-0QchPvS2Gx3$N8j$^Y6q%)
zq|naxjcqRc6@Ong%iZaqSVjUNKKkgcNZ=5#mXjz=M6*#_aNXRk&?~=-JdIQ);bw-9
zmFuh~q=8<>=GLMPh#3XmiIN}Kre=5p17qc&p~)l6J!H3;q83k&a@3riyo2rBM356O
z?(|^G63V7J#6I=|Y%cm>(Cj=kU3NK5=d=2IsZgG-<J49eSfK5(o(@F@A)U>&8be2-
zjA~JKw&tkuAmg{?^<JY;p%Ki&D?6Y^BXooUEbJViq@o!)aype<yf=_Sj3UrX;}`I6
zDvCqbVDfv|MZfvs^{rcShDhVkZz7R1qQ9*2tJ5ZFnmI9|OppF?3+OnmpA~Ba6Yn@E
zV&9$&12ad#IGF)h2T!Plqw&r`3w9tC`KSv$7316br?tsb4uYue*&6Sa5cHG((z202
zIfoNB=y8aPRhYji%wzAAU-(&*Gxoxtk*x~*k5e{F6DI0JBrG0S;TeZ-ljOSIBylqw
zp$-sja83uzW=+r-wHXb3&4{kOX2XOiBd~PI8Ee;Oe*$7mW86RjI@)vr^7&x<?ziOH
zkQ8oQiDL%_CV5HHA>me)^he@kkjx~8r<HIm5u_PB6baEFZ#2DA^rlZnNdb(`HXv5t
zC}th{erJ2<`YqRsm=%-F$}mTfiWW3tc#!O=k7>vT*mlptqY^{Mw7L21tsUX>XjCdd
zzU-HT#Pomqf7^Z;2SzVQ?|0hh$@)Ju{e^-1KNc2n|NF%M>o7RJ&z}BIMQ1Z;9YIgp
z?;uis)|3i`r8)k)Vm|0L>w(!s+BqBxK@LEa-GMTc?(qx`5;If)OF1tTh#&a17lDwm
z($1SE4h{fe?#54ovR>avg)y$a)AuT#23}wYs0^CsX>jI=;a6%y)T#RKz_ZFddgnTH
z*5r;<^CAVDKdi2Ch~ofISeX5S1_j;Sn$nSFH0vF7d-hDHQPs>qy-{zjoMDs4e9sE*
z;zX?otwNCs1fG=s5Y|GyVjF`V9I47S6*jsgDQZM*o^JZjJJYUbVgq5>64coaBI~9-
zVJ*H&c1>>IJd~7Nh+#s!H7$*(<1XWNt6OGJC@=x#jbTmDY3;LhwwfZfb!4i_VlA>u
z#bv55CA<2_aMpDx*UZ|y+CtYKefKfNdw6tE4q*2{KGo!Mr;o9^T9;PAT!Vc=pBW7s
z^cI?Qy9@7M)M*?Y(Yvdt$jD7s_MDxxAm{8vm(UKp{dS&5?QmR<ACi;k*e1jc$jH%H
zj^x{P=BZ;1C&4B1U)6S6dJ*mV83kmEEJ3K0xG%KL^YF0pI%fM@)D4ti`29BBcQ<&r
zl1!u^VJY%bKlC-kdqEhoW(u;n_Gj!kV+x6+I=l^cJg*?NtZR!!o<b-ba1`>e3%d>5
z5l!@%OMCft3OL`bH+S{tx=@Q-B$|`aMn|tBIe`SUex${sE`1#7yK+%UA1tRDhyo@3
z)ecg`4DZY}AXV%rs|3_Lx#)gM%OrYDi7-2GsYz#nM_4|9ieO2(_A@6u5*s_?uwp|e
zgTF0_Xc0t3C#`j5kp1Mm4wzr3QZ7Yrz%DE778A&caPg6&Pv(W4LN9q@9iHTmW7SK?
zRA<<p{tc<#n{}~%Xfn{=157xe0IHxxztB6;S~}{aQt)F5K9U(7r<^icl%{kT>6`>X
zOc~f(BEV&OC|n+bl_^&|8^K&gQk|}}q1`1H%ATY^Vo2Em=8PfG%^8d{+Az`F3`}{T
zVQ)Gw5d6q9OAiZ-#FlV4Y}iA>;pP#`uS{{G+lcT9*c%Ia^GHbUB>EZxW-XYRKW)ju
zt}{~g0J<*hiK(glM>FmckgKys;y$Nlkd}CT10m?F{Sux4?ETE-A2sthXeHe%K9*Os
zw;AV*Ap8TIUvVH4Fd3qnQNU9V6>_E|;~NUQ^w^%$k$|)}MGS?=Dc?i=3u!RB0W7`L
zfV3$MUSn{Bj%vytR<Y;0GI+zW;18Q%kovs`yc;A@I;|r@1I5P{g^Y^l|4fshY>6+i
zF3||GKO@#t&Xd`X4W%2~o4XRlF8f4wQC8O_?pfNyUKzIilnGRVy7f3Z>*tn4t1v_|
zAIobKJ~V7VF#@ywq=sM=9O?*hFB%q9l}6m$xnj0?L=ZcG@s)!rh`o6&ZM%->d;3k~
z808g{%vmnOl8CE7;jN+53=S5kO^|20H4B*zmSA8fH)<P4&_j-EH<G&*D0=89RkL^t
zt_yQ)8qJ}+a~F!Rq@<+(i}PNbEU`5Y#qkuU3E2zQ_q{e8q+nJoX^1X@M^aB(_F)1o
z=<Qu{+L3sn*!2Ve#u&dA*mX`a1EC)N1NEVf@}w(}5M5I&Yl0mC<ELc}Miw1*23_Qp
zx8lrmijQ6c%-uYY>jC7bEEe&xij)MBt#H@c@yn1&T(;=AXim|}1^$5g4DK?a5J=ks
zmT@%yIW;&LbaZw59JXxRRi1oO6~Q%YS9$J1rbq#3?*dg9L8TY40e5|a1C`iuJXIG8
zt~qC5J6@*Tbz*tzTseT0_i!Zy^x@P4p4=6Go?~mh9ZdB}cMUD~JHg(({vBr^>A+8L
zI3=c_Q4h>Ahoo?gb{Hi5X-uF!q6|Il=~NgnO$eEOA#$`LX27wJEYnu2#qnC59ypN3
zYyYqk+0;Z9RluhjBp3-!KC6-~P{}fqkDg7(d0+Q~9RZ!|n`{H#vdXq|;!D3hY^%y~
zX1A3rTgw>QyUeh}S+5kaUGm|PBu~i@1OU6@5Zd+;>5I%m*w{$T;N<G@SQUgOwWnxq
z2;d#?u(U;7>I5cagS&L7CLKs{K@)REd(_i?r1p@Bjhy#(yIi-=d5NG~2ki)?s!j>A
z50NgXo|Wt}m4(jWi^L9q%qFSsMiIaGSj0_q>Pzn*mz^3+f2%9vWEhD_;lT-K8EOWL
zJt7}mSO=cVZP}bWI5#eL5l2Voq`tj@+;swkxaITWFNvR*T_7}Rlca$6r+73tfX8^`
z|8|y2jXZmbKleHCou&BF17!YRHrH9EzXA%eOdQCNGJJ$TSF!?V(f{UMeaZKF$hlXr
zAMB%nf({@*%hJV7DdS37fbn9(K;{MOs6P^cu1vH<rc$Zva~J~GuT2Sn=occO9Ypzc
zNlnMBYPI@vdyW!Ql0E=C@l}JhGD+&ZD|K)`xR}P6GFzJ9ZgAGwx^B^CSFAMVxcC$7
z!utaxfCsYLt)$Y<rnEx|V7t;=BEV{}ZYYYWS}?J;6B26lAf!fQzm-Y6P_@RuBVdHB
z;;be%s&Ios>Rnr~*YFM(=mQ*T#*IY9Su!y#&B)ku_RL3$O|C7+l(0M@CDe}C_t6Dh
zP*K5QYOT&CAT~hgEiBF`EFE6FGo``KC}MLt0fwH^5aKoyCn2NjoDeu(6sDZ|H$LCn
z=K*re|Eo621;_q#j3@hl3&o|vVE(U#N&es0!XEwp-|LYUX=60xl1@qj*@BY=QrRRP
z|4&EgNpZgvqAv5dMixjQoK0cEy<-3nPbOzQ7h&6mOH&z(-aj^K1R!h@%H(|k@wgEP
zOuZlm0zssC;<f-l(Y7JHp$J7TWD%aKja=k;f!>s3gmL^(F|nXW{(*cAV(iOSI4oTy
z>2O0L2UXTFLd5yNafKi*qhW4J`g8TPek1aKxvj@o?q9%ibq}cc;r0b)l|gT)X3|$Z
zn0N8|{hjx>&z*D;yPqceG{jz|OR0#2l<-;V4yr!e*nruNy-PH|LwWAf&LIXA914T8
z3(p6B_(PI=GVVfs(CPu3v3JGv;dRZ>VZer=*w6<DR~+^}o+9YfrICaODF4wzGxhjN
zk^kna)3~-c;ak0Naz9)!<{$h?IFbJ_72R#T;}ANO|4R$F&qe=|p9N$9OXhzrm6i*W
z{l9S#BLQ>p%H(VAL=>i%g#1p&*khUkAPQr~jCE1<lepdlV!t3iW&Y#lv~Z05<+MNH
z{ztw}&i}%4ap}_H82c1~MrLYc4K~s5^M2td@D~ZU^TK(}^&<KslBzZ)CLmtUNdMx}
z;^Kt<uYni(>7SP^@QZHt9P}?OFBB*Azi2`Xfj5l)c?Pu(DSO^Wr2k3!UkSE8l7KH2
z3#CG7o+7k3zqGVC(f`hi@H5mSZBFxNR+oH#-Yer{wNxvtc;!ODE0)V7TWPtx;;+nC
zy`|O4inX5^&i<B~xA^*wwbOEVvSC&imX=l)Rtg1kl}+0VJ#nH@&&AHJ!B!3ZiAH$_
zGM>9=Z~ikl>fB&XtVklCasC$<ij(vICnEKNUXnJa`J2rD3qttk42;ZwUZyt2ev!Y<
zsQ(w13lsf+j3kLbNA%D8&*hG(=*`7_A^lI1|MN=&_CHj@iTuAf3LFnfFFR_4S-Sdo
z#gT?I<BR2oEaS%42iOD-_*=*rYlCCrH@aM&mOXXqemH6ir~75|9-^Oca9GoNAOU{J
zh%0PEZ0c@M?+mH#So3_W-lfIkPI5NZc81X(P$!$AnL*}pZGjs`2$Sm1*<dpeA7E$r
zvbmCb7<iBQ<vSClGQkQ$*zu`;(%Pu`UnmXS|5{jBEKTgc1g*yL6JEbH#(;$C`VrHA
zGD*gP>CY!jng4-gnHrP#cVzqr#Y58nQ(P#_PyBzcfo0<K&-*K5X^{jzqyAr9hW$U;
z{}~H8`hX_rpD!$|R=mZP^5RNqzE)eU%`X;e@W~d6<)!)6`NCqkR#{%H_JJ7rgY-X1
z|HsSZ{9jsLM!djC$QMxHOTPd2{Ee%#AAESfu;k+w&cb~0r)Fk9xb<tdKlJ|D+kfxV
zAN=|+Pyf`PxVH1JekND@hmB8v{>M|7R)6tpU%vpXPe6Q5Fwi&uSC_`ptMkbJrOE!^
zSZI+1nxKFFbelX$C@23OCI7M5C*}Wg2|3{=^8aMKUc}qyZ@m1OUrK$Y_(yN7|K8R1
zPh`Gdf0Fu@-}(ptWbyhh-Tk{i{=5G>JM(Fn`=7<at-t@bA6>ikH=g~Azw~DdKlsbP
z@LzxU{2RaVH-C6%@7=%lvw!EE-}%}9R$2M0zyCk}$`AhYpZo29`*V$d^dExuzy7D+
z``Y(@ukrOi{<|yX_f~)LpD+CWZ~m{}_<s+7?zc97^^bh(dyD=>bbbQkl`+sa|Hrfs
za1Qwo|L-LJ>y?Rn3IKidFRq@V#@UOUgZ{;(`Gtx7cXm{txkiHi`RZz=va-0c;8jYM
z<!Yt2xLhqQtrX^$7yXq&t+2XUtt_k*&(_SS^}kSB8d(1e6Z`LMNIqxj=Wl%Lm;cT7
z-NN2XZtK?ehyUd(m(u_74;`Ho*reJQ4g-DjAGz(Hj9~=lkpCs#|1<Ibje!^mkbU&8
z))H?o=I1%+U!?zULjQ}w|4C31^v|y@EhEO$TU=iC7Z$zZN_nNUSX`bjRg2I97Rn`m
z5iie3n9=M1p#OIXIUy(Z|4Ed)n0Idd_uv0u?)Gng<<i%G^2dJuVjxeTd=W4p^ItRh
zjIFz)=6`8<ApXBtD$P&k|JW$f1N;y<w|rdJ-8;&OOgPBIfed1D?fkkaFq<CI#UY^-
zvd~FJ`KdCq^RM$pAjIiU;rJlV$1{;gi~0P*s2HvY0(42X>1rasE8@0rY}Ci8Y9^_2
zg&!hhtBsDx;nH>Ebvye(8@VWXa|Fuh@Ax@_Nt8;Dis%2<Z6b*_?wdN}mhPDv95w$7
z#ew|KMeYet*8el1`CNq~`cJ0Qx$yTzue7_1Bu>F|BnH_%K$_&;-7yU49QI#nu{4SQ
z83QQ>Kn~D94_0V)aC6{5(Q`i-E&m7nzYFt=llcF0Bm4{%7fP$erDa(CxOJoc{0tQ*
zMSmnPFgX9Q9%QZde?cQ0IsaknCC+~@EH6*|KNp1l6TvWrqqFr&xy3@RI8g*oMA+oz
P1OpQcOfc{xf`R`Jpvc72

literal 0
HcmV?d00001


From d624e719fde43d4295f9859fd57caec3293ef423 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 05:39:37 +0200
Subject: [PATCH 055/282] feat: forget top commits from tix

Offer `e d d` only for a completed, selected non-merge commit with no known descendants. Make the first `d` arm an explicit status-line confirmation, and cancel it on navigation, refresh, cancellation, selection changes, or another command.

Reuse the shared all-mutable-ref transaction used by reword and create. Retarget local branches, custom refs, direct pins, and detached HEAD to the sole parent; delete matching refs for a root while excluding tags and remote-tracking refs. Preserve attached HEAD, reject affected branches checked out in another worktree, support ref-only operation without a worktree, and leave an attached root branch unborn.

When the selected commit is current worktree HEAD, use a temporary-index `git read-tree` preflight and a two-tree update to discard only the tracked delta introduced by the commit. Reject overlapping tracked, staged, index, or untracked conflicts while preserving unrelated untracked files; roll references back if checkout application fails. Refresh cached history and retain the parent selection.

Add full-state scenarios for ordinary tips, conflict isolation, root-to-unborn behavior, bare repositories, detached-root rejection, multi-ref retargeting, and immutable tags/remotes. Update the tix specification and shortcut coverage.
---
 gix-tix/spec.md                               |  26 +-
 gix-tix/src/app.rs                            |  66 +++-
 gix-tix/src/edit/forget.rs                    | 322 ++++++++++++++++++
 gix-tix/src/edit/mod.rs                       |   1 +
 gix-tix/src/lib.rs                            |  24 ++
 gix-tix/src/ui.rs                             |   7 +
 gix-tix/tests/fixtures/forget_commit.sh       |  18 +
 .../generated-archives/forget_commit.tar      | Bin 0 -> 76288 bytes
 8 files changed, 460 insertions(+), 4 deletions(-)
 create mode 100644 gix-tix/src/edit/forget.rs
 create mode 100644 gix-tix/tests/fixtures/forget_commit.sh
 create mode 100644 gix-tix/tests/fixtures/generated-archives/forget_commit.tar

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index d6afc335658..6249c8e8ca2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -324,15 +324,35 @@ space first; changes blocks adapt within the remaining history width.
   untouched. A ref changed by another process or a branch checked out in another
   worktree aborts safely.
 
+### Forget commits
+
+- `e`, then `d`, is available after history completion for a selected non-merge
+  commit with no descendants in the complete cached graph. The first `d` arms a
+  `d again forget` confirmation; the second performs it. Navigation, refresh,
+  cancellation, selection changes, and other commands disarm confirmation.
+- Forgetting does not require a worktree. Every mutable direct ref pointing at
+  the commit is atomically retargeted to its parent, or deleted for a root.
+  Tags and remote-tracking refs remain unchanged. A branch checked out in another
+  worktree aborts before mutation.
+- When the selected commit is the current worktree `HEAD`, Git preflights and
+  applies a two-tree index/worktree transition which discards only that commit's
+  tracked delta. Conflicting staged, tracked, or untracked state refuses the
+  operation; unrelated untracked content survives. When `HEAD` is unrelated, only
+  refs move and the worktree is untouched.
+- Forgetting an attached root deletes the branch and leaves symbolic `HEAD`
+  unborn. A selected detached root is rejected because it cannot produce a valid
+  unborn `HEAD`. Success refreshes history and selects the parent when present.
+
 ### Editing shortcuts
 
 - `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
-  and `e t` enters or returns from time travel when each action is available.
+  `e d d` confirms forgetting a top commit, and `e t` enters or returns from time
+  travel when each action is available.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
-- While the `v` group is open, `e`, `r`, and `t` retain their display meanings
-  for emails, references, and trailers.
+- While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
+  meanings for dates, emails, references, and trailers.
 
 ## Refresh, focus, and diagnostics
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 59fe42b4069..ae19edf7f16 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -285,6 +285,7 @@ pub(crate) enum Action {
     OpenDiff,
     Reword,
     NewCommit,
+    Forget,
     TimeTravel,
     VerifySignatures,
     Cancel,
@@ -307,6 +308,7 @@ pub(crate) enum Effect {
     OpenCommitDiff(ObjectId),
     Reword(ObjectId),
     NewCommit(Option<ObjectId>),
+    Forget(ObjectId),
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
@@ -366,6 +368,7 @@ pub(crate) struct App {
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) edit_expanded: bool,
+    forget_confirmation: Option<ObjectId>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
     horizontal_page: usize,
@@ -439,6 +442,7 @@ impl App {
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             edit_expanded: false,
+            forget_confirmation: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
             horizontal_page: 1,
@@ -644,6 +648,9 @@ impl App {
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         self.notice = None;
+        if !matches!(&action, Action::Forget) {
+            self.forget_confirmation = None;
+        }
         if !matches!(
             &action,
             Action::ToggleHistoryDisplay
@@ -659,7 +666,7 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleEdit | Action::Reword | Action::NewCommit | Action::TimeTravel
+            Action::ToggleEdit | Action::Reword | Action::NewCommit | Action::Forget | Action::TimeTravel
         ) {
             self.edit_expanded = false;
         }
@@ -827,6 +834,14 @@ impl App {
                     self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
                 )];
             }
+            Action::Forget if self.can_forget() => {
+                let id = self.rows[self.selected.expect("forget requires a selection")].id;
+                if self.forget_confirmation == Some(id) {
+                    self.forget_confirmation = None;
+                    return vec![Effect::Forget(id)];
+                }
+                self.forget_confirmation = Some(id);
+            }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
@@ -927,6 +942,7 @@ impl App {
         hidden_tips: &[ObjectId],
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
+        self.forget_confirmation = None;
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -1312,6 +1328,28 @@ impl App {
             }
     }
 
+    pub(crate) fn can_forget(&self) -> bool {
+        self.state == State::Complete
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| row.parent_ids.len() <= 1 && !self.has_known_descendant(row.id))
+    }
+
+    pub(crate) fn forget_confirmation_visible(&self) -> bool {
+        self.selected
+            .and_then(|index| self.rows.get(index))
+            .is_some_and(|row| self.forget_confirmation == Some(row.id))
+    }
+
+    pub(crate) fn select_commit(&mut self, id: ObjectId) {
+        if let Some(index) = self.rows.iter().position(|row| row.id == id) {
+            self.select(index);
+        }
+    }
+
     pub(crate) fn time_travel_shortcut_visible(&self) -> bool {
         self.worktree_changes_available
             && self.changes_focus.is_none()
@@ -1982,6 +2020,31 @@ mod tests {
         assert!(app.update(Action::Reword).is_empty());
     }
 
+    #[test]
+    fn forgetting_a_non_merge_tip_requires_a_second_d_and_navigation_cancels_it() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        assert!(!app.can_forget(), "loading history cannot forget commits");
+        complete(&mut app);
+        assert!(app.can_forget());
+        assert!(
+            app.update(Action::Forget).is_empty(),
+            "the first d only arms confirmation"
+        );
+        assert!(app.forget_confirmation_visible());
+        app.update(Action::MoveDown);
+        assert!(!app.forget_confirmation_visible(), "navigation cancels confirmation");
+        assert!(!app.can_forget(), "a commit with a descendant cannot be forgotten");
+        app.update(Action::MoveUp);
+        assert!(app.update(Action::Forget).is_empty());
+        assert_eq!(app.update(Action::Forget), vec![Effect::Forget(id(2))]);
+
+        let mut merge = App::new(10);
+        merge.extend_commits(vec![row_with_parents(3, &[2, 1]), row(2), row(1)]);
+        complete(&mut merge);
+        assert!(!merge.can_forget(), "merge commits are not forgettable");
+    }
+
     #[test]
     fn editing_requires_no_known_descendants_and_new_commits_support_unborn_head() {
         let mut app = App::new(10);
@@ -2516,6 +2579,7 @@ mod tests {
         assert!(app.edit_expanded);
         app.update(Action::Reword);
         app.update(Action::NewCommit);
+        app.update(Action::Forget);
         assert!(app.edit_expanded, "grouped edit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
new file mode 100644
index 00000000000..5f0536a92c6
--- /dev/null
+++ b/gix-tix/src/edit/forget.rs
@@ -0,0 +1,322 @@
+use std::{io::Write, path::Path, process::Command};
+
+use anyhow::{Context, Result};
+use gix::{ObjectId, bstr::ByteSlice};
+
+use super::refs::MutableRefs;
+
+pub(crate) fn perform(repo: &gix::Repository, id: ObjectId) -> Result<Option<ObjectId>> {
+    let commit = repo.find_commit(id).context("could not find the commit to forget")?;
+    let parents: Vec<_> = commit.parent_ids().map(gix::Id::detach).collect();
+    if parents.len() > 1 {
+        anyhow::bail!("merge commits cannot be forgotten");
+    }
+    let parent = parents.first().copied();
+    let old_tree = commit
+        .tree_id()
+        .context("could not read the forgotten commit tree")?
+        .detach();
+    let refs = MutableRefs::pointing_to(repo, id)?;
+    if refs.is_empty() {
+        anyhow::bail!("no mutable reference points to the commit anymore");
+    }
+    refs.ensure_not_checked_out_elsewhere(repo)?;
+    let head = repo.head().context("could not inspect HEAD before forgetting")?;
+    let head_is_selected = head.id().is_some_and(|head| head.as_ref() == id);
+    if head_is_selected && parent.is_none() && head.referent_name().is_none() {
+        anyhow::bail!("a detached root commit cannot leave an unborn HEAD");
+    }
+    let transition = match (repo.workdir(), head_is_selected) {
+        (Some(workdir), true) => {
+            let new_tree = match parent {
+                Some(parent) => repo
+                    .find_commit(parent)
+                    .context("could not find the parent commit")?
+                    .tree_id()
+                    .context("could not read the parent tree")?
+                    .detach(),
+                None => repo
+                    .write_object(&gix::objs::Tree { entries: Vec::new() })
+                    .context("could not prepare the empty root tree")?
+                    .detach(),
+            };
+            preflight_tree_transition(repo, workdir, old_tree, new_tree)?;
+            Some((workdir.to_owned(), new_tree))
+        }
+        _ => None,
+    };
+    drop(head);
+    drop(commit);
+
+    let committer = repo.committer().transpose()?;
+    match parent {
+        Some(parent) => refs.update(repo, parent, b"forget commit".as_bstr(), committer)?,
+        None => refs.delete(repo, b"forget root commit".as_bstr(), committer)?,
+    }
+    if let Some((workdir, new_tree)) = transition
+        && let Err(err) = apply_tree_transition(&workdir, old_tree, new_tree)
+    {
+        let rollback = match parent {
+            Some(parent) => refs.rollback(repo, parent),
+            None => refs.rollback_deleted(repo),
+        };
+        return match rollback {
+            Ok(()) => Err(err),
+            Err(rollback) => Err(err.context(format!("references could not be rolled back: {rollback:#}"))),
+        };
+    }
+    Ok(parent)
+}
+
+fn preflight_tree_transition(repo: &gix::Repository, workdir: &Path, old: ObjectId, new: ObjectId) -> Result<()> {
+    let mut index = gix::tempfile::writable_at(
+        std::env::temp_dir().join(format!(
+            "tix-forget-index-{}-{old}-{:?}",
+            std::process::id(),
+            std::thread::current().id()
+        )),
+        gix::tempfile::ContainingDirectory::Exists,
+        gix::tempfile::AutoRemove::Tempfile,
+    )
+    .context("could not create a temporary index for forget preflight")?;
+    index
+        .write_all(&std::fs::read(repo.index_path()).context("could not read the index before forgetting")?)
+        .context("could not copy the index for forget preflight")?;
+    index.flush().context("could not flush the forget preflight index")?;
+    let index = index.take().context("the forget preflight index disappeared")?;
+    let refresh = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .env("GIT_INDEX_FILE", index.path())
+        .args(["update-index", "-q", "--refresh"])
+        .output()
+        .context("could not refresh the index before forgetting")?;
+    if !refresh.status.success() {
+        anyhow::bail!("{}", refresh.stderr.to_str_lossy().trim());
+    }
+    run_read_tree(workdir, Some(index.path()), true, old, new)
+        .context("local changes conflict with forgetting this commit")
+}
+
+fn apply_tree_transition(workdir: &Path, old: ObjectId, new: ObjectId) -> Result<()> {
+    let refresh = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["update-index", "-q", "--refresh"])
+        .output()
+        .context("could not refresh the index before applying forget")?;
+    if !refresh.status.success() {
+        anyhow::bail!("{}", refresh.stderr.to_str_lossy().trim());
+    }
+    run_read_tree(workdir, None, false, old, new).context("could not update the index and worktree")
+}
+
+fn run_read_tree(workdir: &Path, index: Option<&Path>, dry_run: bool, old: ObjectId, new: ObjectId) -> Result<()> {
+    let mut command = Command::new("git");
+    command.arg("-C").arg(workdir).arg("read-tree");
+    if let Some(index) = index {
+        command.env("GIT_INDEX_FILE", index);
+    }
+    if dry_run {
+        command.arg("-n");
+    }
+    let output = command
+        .args(["-m", "-u"])
+        .arg(old.to_string())
+        .arg(new.to_string())
+        .output()
+        .context("could not run git read-tree")?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!("{}", output.stderr.to_str_lossy().trim())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated().config_overrides([
+                "user.name=author".to_owned(),
+                "user.email=author@example.com".to_owned(),
+            ]),
+        )?)
+    }
+
+    #[test]
+    fn forgets_a_tip_atomically_and_preserves_untracked_files() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("forget_commit.sh")?;
+        let repository = open(fixture.path())?;
+        let top = repository.head_id()?.detach();
+        let parent = repository
+            .find_commit(top)?
+            .parent_ids()
+            .next()
+            .expect("top has a parent")
+            .detach();
+
+        assert_eq!(perform(&repository, top)?, Some(parent));
+        let state = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            state.head,
+            gix_testtools::repository::Head::Symbolic {
+                name: b"refs/heads/main".into(),
+                id: parent,
+            },
+            "the attached branch is retargeted to the parent"
+        );
+        assert_eq!(
+            std::fs::read(fixture.path().join("tracked"))?,
+            b"base\n",
+            "the selected commit's tracked change is discarded"
+        );
+        assert!(
+            !fixture.path().join("added").exists(),
+            "the selected commit's added file is removed"
+        );
+        assert_eq!(
+            std::fs::read(fixture.path().join("untracked"))?,
+            b"untracked\n",
+            "unrelated untracked files survive"
+        );
+        assert_eq!(
+            state.index_tree,
+            Some(repository.find_commit(parent)?.tree_id()?.detach()),
+            "the index matches the parent tree"
+        );
+        for name in ["refs/heads/main", "refs/patches/forget"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                parent,
+                "{name} follows the forget"
+            );
+        }
+        for name in ["refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                top,
+                "{name} remains immutable"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn refuses_conflicting_local_changes_without_mutating_repository_state() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("forget_commit.sh")?;
+        std::fs::write(fixture.path().join("tracked"), b"local\n")?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let repository = open(fixture.path())?;
+        let top = repository.head_id()?.detach();
+        assert!(
+            perform(&repository, top).is_err(),
+            "overlapping local changes are rejected"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "a failed preflight leaves refs, index, commits, and worktree unchanged"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn forgetting_the_checked_out_root_leaves_an_unborn_branch() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
+            Command::new("git").arg("-C").arg(fixture.path()).args(args).status()
+        };
+        assert!(git(&["init", "-q", "-b", "main"])?.success());
+        assert!(git(&["config", "user.name", "author"])?.success());
+        assert!(git(&["config", "user.email", "author@example.com"])?.success());
+        std::fs::write(fixture.path().join("tracked"), b"root\n")?;
+        assert!(git(&["add", "tracked"])?.success());
+        assert!(git(&["-c", "commit.gpgSign=false", "commit", "-q", "-m", "root"])?.success());
+        std::fs::write(fixture.path().join("untracked"), b"keep\n")?;
+        let repository = open(fixture.path())?;
+        let root = repository.head_id()?.detach();
+
+        assert_eq!(perform(&repository, root)?, None);
+        let state = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            state.head,
+            gix_testtools::repository::Head::Unborn(b"refs/heads/main".into()),
+            "deleting the root branch leaves symbolic HEAD unborn"
+        );
+        assert!(state.index.is_empty(), "the index becomes empty");
+        assert!(
+            !fixture.path().join("tracked").exists(),
+            "tracked root content is removed"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("untracked"))?, b"keep\n");
+        Ok(())
+    }
+
+    #[test]
+    fn forgetting_without_a_worktree_only_retargets_references() -> gix_testtools::Result {
+        let source = gix_testtools::scripted_fixture_read_only("forget_commit.sh")?;
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        assert!(
+            Command::new("git")
+                .args(["clone", "-q", "--bare"])
+                .arg(source)
+                .arg(fixture.path())
+                .status()?
+                .success()
+        );
+        let repository = open(fixture.path())?;
+        assert!(repository.is_bare(), "the scenario has no worktree");
+        let top = repository.head_id()?.detach();
+        let parent = repository
+            .find_commit(top)?
+            .parent_ids()
+            .next()
+            .expect("top has a parent")
+            .detach();
+        assert_eq!(perform(&repository, top)?, Some(parent));
+        assert_eq!(
+            repository.head_id()?.detach(),
+            parent,
+            "HEAD's branch moves without checkout"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn refuses_to_forget_a_checked_out_detached_root() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
+            Command::new("git").arg("-C").arg(fixture.path()).args(args).status()
+        };
+        assert!(git(&["init", "-q", "-b", "main"])?.success());
+        assert!(git(&["config", "user.name", "author"])?.success());
+        assert!(git(&["config", "user.email", "author@example.com"])?.success());
+        assert!(
+            git(&[
+                "-c",
+                "commit.gpgSign=false",
+                "commit",
+                "--allow-empty",
+                "-q",
+                "-m",
+                "root"
+            ])?
+            .success()
+        );
+        assert!(git(&["checkout", "-q", "--detach"])?.success());
+        assert!(git(&["branch", "-D", "main"])?.success());
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let repository = open(fixture.path())?;
+        let root = repository.head_id()?.detach();
+        assert!(
+            perform(&repository, root).is_err(),
+            "detached HEAD cannot become unborn"
+        );
+        assert_eq!(gix_testtools::repository::snapshot(fixture.path())?, before);
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 216b294e7d9..04671e43e49 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -3,6 +3,7 @@ use std::{ffi::OsStr, io::Write, process::Command};
 use anyhow::{Context, Result};
 
 pub(crate) mod create;
+pub(crate) mod forget;
 pub(crate) mod refs;
 pub(crate) mod reword;
 pub(crate) mod time_travel;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index f3fea1a50c7..bd881e7664b 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1716,6 +1716,21 @@ fn event_loop(
                         Err(err) => app.notice = Some(format!("new commit: {err:#}")),
                     }
                 }
+                Effect::Forget(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match forget_commit(&repository_path, repository_is_bare, id) {
+                        Ok(parent) => {
+                            app.notice = Some(format!("forgot {}", id.to_hex_with_len(7)));
+                            if let Some(parent) = parent {
+                                app.select_commit(parent);
+                            }
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.notice = Some(format!("forget: {err:#}")),
+                    }
+                }
                 Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2732,6 +2747,13 @@ fn create_commit(
     edit::create::apply(repository, prepared, &edited).map(Some)
 }
 
+fn forget_commit(repository_path: &Path, bare: bool, id: gix::ObjectId) -> Result<Option<gix::ObjectId>> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository before forgetting commit")?;
+    repository.object_cache_size(None);
+    edit::forget::perform(&repository, id)
+}
+
 fn run_external_diff(
     terminal: &mut ratatui::DefaultTerminal,
     mut command: gix::diff::blob::platform::prepare_diff_command::Command,
@@ -3443,6 +3465,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
         KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
         KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
+        KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
@@ -4315,6 +4338,7 @@ mod tests {
         for (key, expected) in [
             ('r', Action::Reword),
             ('n', Action::NewCommit),
+            ('d', Action::Forget),
             ('t', Action::TimeTravel),
         ] {
             assert_eq!(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7b6b793b71c..279a7eefde1 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -679,6 +679,13 @@ pub(crate) fn draw_with_worktree(
             if app.can_create_commit() {
                 footer_spans.push(Span::raw(" · n new"));
             }
+            if app.can_forget() {
+                footer_spans.push(Span::raw(if app.forget_confirmation_visible() {
+                    " · d again forget"
+                } else {
+                    " · d forget"
+                }));
+            }
         } else if !app.history_display_expanded {
             footer_spans.push(Span::raw(" · e edit"));
         }
diff --git a/gix-tix/tests/fixtures/forget_commit.sh b/gix-tix/tests/fixtures/forget_commit.sh
new file mode 100644
index 00000000000..9964e4396bd
--- /dev/null
+++ b/gix-tix/tests/fixtures/forget_commit.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+set -eu
+
+# The top commit changes and adds tracked files; an unrelated untracked file must survive forgetting it.
+git init -q -b main .
+git config user.name author
+git config user.email author@example.com
+printf 'base\n' >tracked
+git add tracked
+GIT_AUTHOR_DATE='2000-01-01T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-01T00:00:00 +0000' git commit -q -m base
+printf 'top\n' >tracked
+printf 'added\n' >added
+git add tracked added
+GIT_AUTHOR_DATE='2000-01-02T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-02T00:00:00 +0000' git commit -q -m top
+git update-ref refs/patches/forget HEAD
+git update-ref refs/tags/keep HEAD
+git update-ref refs/remotes/origin/keep HEAD
+printf 'untracked\n' >untracked
diff --git a/gix-tix/tests/fixtures/generated-archives/forget_commit.tar b/gix-tix/tests/fixtures/generated-archives/forget_commit.tar
new file mode 100644
index 0000000000000000000000000000000000000000..79d27c24ed211d6cc2267ca07577256f809a9a15
GIT binary patch
literal 76288
zcmeHw4UAjab)I$|#~s>koWO>&No&8QCY~AX@c(aSw4=3lB&}vwE6LI*+C)FIkL2SF
zR~$YrAF0t;t8J1NsM9ueV8boqv_X)x4br+lLDM2>5dWYp5Ic?08rarxn;>=LHV%vi
zwQH|qq)5N-ockUh$@w8i!?C<eVpl`Hckj9Po^$TG=bU@)x$(r2k$;l-6mq#E{EJWT
zUwM{FX7j0JI+@PM`$8t2JCYlD&(J{IYuQc9y6>iBXraN~H^9RI&}!PHTTXeTjS)5Z
zY_^x~{%^d^9_glkDw#{Ck0eLhD+B!XPJg!%ISe$9+juZB5MQgdM%^>c|6%2SA(tM@
z|4|bL@Jau~(uHTAU0zu|eQJ5-*~?EIc&nuUkn%sBN{!|JffHgIfUU9o-v%qMpGPwP
ztM#&TXLMuUYyM}_sb2jL3SeQZ|Ba3$0pwH5mzMD3VgCQZz2je<`IAeZ^Z!0{<jC9J
z`NU8BwIfG<{2v@S^3c~&=I!|ZyI*<r&z@+#`um^!i68q~<CojN@_m2wjlb~yN8V_c
z%f^n7`d_*CMgOnD`SG(oaK7skKk)9~|JLJw<(Y?m?3aG@Bk%f1t8(mb{??H<bu5yV
zOQ%nxy+@9utz=~V|2+2jU;V}-|N1|k{rtauNBsj|`?Ftv^@n5EKJ})r|L5h{yH=aO
z_v-h2@_WwQddqQC7=H%GfXx4<Q}G6`GIUAK|Kaq%RI-ptjrG5wF+F^Rfc}Z5v*EU!
zQSiY&=%3Ey3uF2ZPtKuh^wB@zHmhsZ`p|%Osjv_FXY#rHnEt!q^q^ktME}Gs$7vi;
zBc%VX_Ft|~|I6m-N<E<VcLno0_y1+{b|s&huQ-{Moz0|^*=)I-$>cM0_I$CBtYnim
zewOA^V<+LRT=X6LvNQi%_Sz^Ge_&=G@;{Z&j@SRgV5)BVAEeap^nM@mKb<S2#`3>|
z!jXL&%m0y~_B#S_Xa27{c6l@lz<%U^p)lV6KMV%yp?_k-K3Ln2W7v=UFQmr)-@~B)
zSpFXdmLJ?UI`h9_w@T{|j{h&49Q%I`fo=NepQyOaHRnKMLiQp5Gx;>)#SUToulM-B
zvHU*_CVOz(komvvy0=E7`pdxgqyJ;Wa4i21fo(eUPc+)zdaUKfpaqm}x$Rcmvo{(w
z=l(mf2mN!IOrbaaBbO_T<^TO-es2gzA59di^@O(`i5#^~)-C6b5Z$6ku)I>U+GtrV
z*J?M)cFVDBOPIqc$G{&}tLZqFTgOub5n5!Qc;qO+tgKf(1%SWR`fV2h=2mfwrD9E|
z<Wz4vu?E7<r&BZ5=DJh2P`l~arIyF0Pzo>z&9dud)3S#G6{qRcOU|@61E8qGXARe@
zw%q2{tdtdCt#wCg14ye`bp)pAK3^4^cD=N2wbt#Hh3=KwO+ancw)~M<92px%VSq6G
zjhCJJ){>TeQX!PwdZoJ7ZrZIXaB$mhR_$WVAxzI9&QMvKU9NjA_*N7*Pi|Rdr((Bj
zty#-!qa(Hs71c1pwg*gAD{R}^bep%T^)<z^=@15vNG(8iwT$lBhwxyn+a7w4MyeHq
zFRRjYHw0oZRsb+`l+l*ljg4ySxYDBNwuqhG+P5}nDgX$J8K9N|ndP%B%WgVm@W7+1
z<)w7p*#xRdTnw~TZFGjBbcuH}59$^HiCDo`_qNk)R?Ch+GFSwFqO)$_uDb2!aWLJc
zgF@Od7bS~M&D{iks+43KAT-zkoi>#_RRM;Gvv?S!MXWd6YQ1Ga7skNqx1D+wb*&8-
zXswon;y$Z8%IStr6ujcX+N=VVo9k6!H}tyN@abld#?C7<f&6P|5!BWZ%XBL*L=@8E
zWQx;sxn-4XPEpJkfo)rLw;p@H({$PKR$F*o*+_;dlW5wXVrAFy0L61>IpH?2@rmkY
zP+L-7xXZ$rd+9$DkCdy9H9ce9jZ8SDb=Nxap0pL6JQl@Ib|)3N#~xm25;QxxVc&wd
z03+5h;XTi8a)R0QHJy*W@O8quY!^_p8^lCYP_piTf8`|z=T)2F1`Zc2O5s6Rd!Sb5
zq3{q(g9!t6<-`gjG=xm0@EM@P2t{FTB{zrYk*T(<X1gx(4-%{#6OkBeTd@u6?CF!I
zfTC1XMg**u$(XL?Y_x0aJY{CZ!9>CcR2C5uBpbWfBpZ8RRE)Mn0RtdHa$nLy;3==Q
zHeGEMyt+aDVu{|qR7rS{0Zd%AYv?rF!14|ff$>nm190>NW92Vj1JIu7JK-JWR?rY!
z4Ozz+0Yf3H=9cVQKw~qEE*U1nEK@F$?J&KZCPkEviyaEdtfJG}bPRF*M&snL6_nFS
zjVWVeMmC+8+l<vPIFhNvRmrY<z%ZpU&<#mbtNHV833M-$#W=C0NtMMNK_G8{gDFp>
zR9GKU%0qNi>y*+Y2|;j@t+w3NveT%!TbLr1c3ntDS{B>Y8srIrt2)bGyri6U9^qDs
zVS<qbce9GVLgG1hoKm}mRsz}GS?UZ=aM3fU3<`zOjpfDVQnKZ?txX%k3%F<i<H9BQ
zA_(%Ze4Al(*OglA3`8qB=~{N#h9-c=6o?S4cBur82JvfHd!6_ihQuWvL7-%aXsK+)
z<5BWc+v9_#Ly7<tyiDsJD2bjuD!it1Gp2Js_M#PwRoCjIs@E<;-nKzmJcCecI#5!8
zsd{9BvM73`LE?y7BK&GqZ17|`8mUx6;K@_53SJP(i|s0w=IvVugT88(UY&iwv@EM_
ztmF0?h++hpwq(>D;l`%hUc+<_F`!#n5S7TXxV^H9)p-@l5j7St$`e+ULLzD{Sf`)8
zxbh>b40v6=eD-8&_3Y{Ah$5Mcc1s3e#T=C>=@W^vb30LQ*J`HIguO^m5vS%kkqP-d
zInCN=aXsc1Uw{;`Vn$_)#k>~CWIZ0hnb`(uh9UvdN;c43-WGe4Y!Gku#^H7t3|OI8
zYDFh?`HP0(F1hVmStN*2>cWgmPNj4gv~o;)E5NVw5+VCf@p)iYUk9;!*nb6_`|Y*=
zG7>M=0WrF7uk-k?j{Qf=ZD#|pi1q!J)vnuhEZ$IGpiCiNNY^K56%I8ut^rF>FYppe
zL6qVryzWJf(%M{WizdE+x0O1T5O3X1#av8l`GN_oW+Zf_y4X}L-=LgD6{#UlDAqaS
zqsqBaT~?RGE<;yh^1&BzZ^h9ucQZ5qys*^TD7tRVp+e`tJb+G#MF#6u?@;}<S>RxZ
zP+)w8)k3#?OEhj-9UG4d!WJyK`cw<cI`I?gOWCP8EeB}aqbE|1i>P3{zZ+~sK<uXz
zV$y8w-3gnmL#yASdZKm^a9~$Jd8-7$O?4|C8o6``46y6iRkIs(_`V(pHc~CALy7&O
zfL6Wq-WjMXYHrh4AR`7z`uYTjRi~_@_f`3wSOYo()dupVBkloI1J7DZu*Yea)Szfa
z%p6%1O9FEQmI1z}qY+FK{ho<ZF=oZfHVg{m$)Ngh&5FGrCdgAb+lg~NQR~KWA_@wW
zm~hck!k4r<WI7pdPoPb5@%6g_T@DtXU(uQda9^>Um2V|kmc4d^CXs1S8l!#GUD=vU
zT90E`C#=VHJouu6IWgmxRGZRha%LC?6HzPX>bSIa=eGjs8)n;s*0!)qtNo4obfAYP
z(knO?RkKq65AfdFYB-COA>qj#5+5@PL8rSi%s?Q*6=ov6thyJ7-tt|&z+B#|zKl8$
zQKohvEe5I`l%64j8YLYjLEWVtFTO=uwvDDs^^}hQmcAZnx>Knar#h?)MKvfNor#oe
zn8wk`P{k<ivFMdL7l(348b^;=FIiDkF)V-V*fHy(wioV$B})l(WfjygJh2vZv&F>m
z;}OTROa5G2qL<tv?P*(MK1?e6aY|F+iO1voLthJQNjOf$$;RbMk%~uP=y-$<2ZPNn
zUA<37$3R+5YwB7uHgCr&H>Rwq<kXDL@~CM$YApgSgczCx+O1XLQf=B;3E>xpr2|u=
z<qt<K1A}mX2G05o3RJ=U1m1ZGu26|%vpQBFeF8qvdaO%lz(a4{ZMIeou*J!{=G)Pu
z9T@jeOaxeTvUmDLtw%A+R<rGd200O;?+UEx-d1O=$*xvG7Eg=_BYkPBixBLrp@#fn
z$XCF2Q&elX7D6i7ph?WLKnw9FP$BZAA_)!tY}jj1mVD_6SSr{iCLr1-$WmQ+Q}QU@
z440s#9#rTHJl_)$r>J01anQwkh!OAFOEj%r?4@g%V8Pt)>ZSFb_lQl4g$p|XbZ|`?
z;#()Iz#6sEC*G67sCBIh6JP~+pYp3rVd<pFxJ3t^*YZMGriU`hx&ACYwp&BsAOvK4
zB+%6D<#D4t1T5<>Or6;XR*6pbie#CtyD;*SuVvUFH!*!@gD~yxz2An@dIu3&0Q6NC
zC4EgIOq~$FX^mkf+4lW4hZ1{aiX0IpQG-4QGpSQyn<4hs3$v_N7=ElhQ15Hd$8=_$
ztZzXYVSx1KK-&^mFI=T?sCS+}!Lq8!k=3v0799<Y1<1c!b$1go4eJw~pT<`Lp@jL?
znRMJnVhOW;7;!F|UPn~*EPQ9G^(wb-A|lI@V;9Tld=rNNIpqIo!0Ae7_JMnVs0ZzG
z{yUw^<a_-;*;FPoj{iCY`gi<4&|-IX|6n%?>nNNfx>IErW&dCHDs?j#ZjWx)55VzF
z)c6S06|F`9G;}QOkVHIiZgwtbu~kAJ2^6W2n1e=)XRufm7_4N=TISX_B%(1_DTUy*
z;Z|$^b|@B05u?7x!1T30N&$OUbXy4+_O0U5DyIa7ngW{wZVpd9`I9M_eAaoot-3ei
zAzM3py=;gJLD3<MvI|50s5O~p)hn0IQ90bbEJ|aXgu?pl77?y{DHx`)as+>Pg*C$V
zy=sAX#Cfr8*VHApT<5lrZiyMvVT`J!%U&Mi5P)~>ts;rN7jqu&4DJ%r8NvN!^o$6C
zBfnm@n{<OU&@;2&$7cKukH>XK5bF)>d;RWK%lK~St}o0FzUfd!1CQVhbT=7DvZ=~6
zwnVXwC71=~JH6)~BD+*`;h^GP^O|(8*`i@46pdb8z8JNpxl_QNLN8y#Zjy&xZMav6
zMD?z;n>BT<+^<m<(d|(xr@AjnW5;~MNDb%9Lv4Q*Pb1hGrOksJ3@s>&f-yc18Fdj~
zB|d7M1^VIrRGkHSzyd5>+4~8B=)mrR;RAtjb{=~rs_<YF50O8hF_lXnxqv%?&8#)z
zr_&#59oiHi7_9>gElN1KwHF}l%<TYndKZs(L#Nw^rlXqJG_62C0|GCU^2TPSB~gR+
zZ^h~sXC?^Su%>RJ0^JAFd0PJgR#2?7t<+;;NKC^Sw++`@r$I7|=^ltUD@LQ4mk53U
zD#D5@dM<PQJ4ZL_S^sVN@8l%F0crtztpCY;F4?>O=Q62r{NEug|3^CO|L*%gyC?uU
zAF(9_amx^ZfQ58-2pcO-49Ci9zHrtxX$2BnVjdvnxuYxdNThXdOp|UhR6Vav>0(nE
zKpXI_AmR@CgD>(SI=SC~PzMQv!X|q|mIdveX>{N%B`U+6kzi{n5~t@PhTU|y2HOpI
zEgd6>qUt>B_%tAeP?C`j>Jd&5m=>PFUN+@>><+|G03u4i2xC6FA5Pv)Jr<pOZ}eVd
zVPsZT&-~wTaQMUY^}r;+p7S4PeR}f$<`5J-*8dMd0377}#~kZ10x&tjPiEs6ZvQ|_
zg&yA{08n>u5wNWQ5Zx4!EeH~&KYm+bApJ3_#C}9Vcz$dn6gqR;Y=I?Yzc(ZRIMpNA
zc$SZu@;jCt;k@@*D?I;QuN6~A(Sc2UX=bnapDyHj=YKXop8r0HM*4Tq`H!^<mN2XX
z7{p8%4;#kc)|Sl=#Ar)=Hl}g8y;0O4xCZul5bP&s0tR1sJ8Z}qCUb;)F3Oo$eVfol
z5HDD9N46-A6ypyT@bLUs5}VaOw&ATEkQmrw{-+B#>)EsZ=aYr;`TxV<lws#T9WAQL
zhW#zuto&NYEd8t{aa+b^rjc88Cep))w-6f!s!``>jSCKv1~vujhe7~+&zn|3T~i4g
z?H(eOOHN3=z_UiX30WmabLgiiLzr}i(Wxy#0KS9K7$=M=-pRYj@aqm7`pe*3Yr+m1
zTH^IhJPN+9b5!+GtqlaAJ)XHT=Mg-fmVvLb+Jr>`7o+%<Zc8a5G<wv!h`2TkTmtmM
zeKq((j6xKF$+d=$K+|&o^<dq=4^r(k4Ef$}(boqWN^BoPtKo4WT@kDx$4_ESJ?#KA
z6EguVU*KUA<J{#7sjqbqBrafyc%H~Y$4ORp8KiegHdhu<jHg!^ol$bJUnO>8EQXfR
zNBD>2w+Dx(Y)tvQ<S#vF5N=@jDh=KkrOuFy%ZN1RQ8q+~gU9ILq@%H`<8o#Jhdt0M
zujL2lgMq{oy+SuM{%c}kMAQ?G!MQF_R(5QV&*aocKK<1*%jZt>2#<Mm`NEY;OL&lu
zFw}c-G82g;+Fn!6;UO@;X2q)UqJ0Y<Ekql@$c59hUFQLZ>5atA_+B(k#N#M-bTTnR
z2Ut%pBvQ--b9D7)c9MOONDhQW&c4)gaJB{3_3R8rj?eZT1SO{QJ&I^gqu1+ED{ei{
z727aK5IEk=DbJ(k1Qm7kHbDb;QW*KM$E?LgE4f|gE$l?1H^*l5iyw`1`NEUN8Hhu8
z5__gYTRDAcb@|lk^DBtbkf@@%HRUC4UZ0L1J8^v`erz()#Q+P|^;DvPkeZ_sq9Er}
zp!KwHx`qb}nmj;It;c|tl7p}2DR7MTquZfcqJq>SU=&^#zBx_6XymKikQ>4&5cQ~H
zXqBA$*kjva2;ks?9A@3<UjO~$nFqA+n~v<U{$uIyv;VWX{Mh~<hK~C!JLvi^=lMj*
z*KH}wZ7}4QB32e5U$mM-aSThqLd3lU-LTQp;CZb15d2MZf^muki?ApbDM%P?+H@EU
z*r^IA!7;z6zKn)pQUIf0`&o2-Zs%%?>7`SZ`vWw{FJ8HPcJ;!=mE{ZPSC=kaIltnc
zLa8n$BNMv8BQ>IvRfM3{xM#CNy$SB@OgOi3J}!!X+RozjzM=qvGDb8@Aq}gO01rWs
zgoc=S4~hB+0(I$L^aJfR{A2R2fH-<=@m>(d#t<1qn-RO*5b11Oh#bWZ354i$)q2cI
z&EUOkV+<)v_RE9gdfz?_gyet4+i>eVO&{Cj`EJC1AJ8(eyZle3Qu)64k9;~gw*L-;
zD<J>Fx@ROp8Sf!+LaB9JzHi#iI`&;W{k42?X<^|)!>Ol_(?Z!fV1(+^8V;E{)>Xqy
zC_cU3YBjutM4|#63K8?S$bIYWV!Y}me4a}nCj=gf4hC)9YdEk2+6|b0El4i(1aP>c
z%(X&-Oc|db2Ru8*i|i|5U1-=i@{H&Oi-)Os9(X!PfncR)1Vqh-WfDZk-4cyVgC%Hx
zz&K@206B)v2GvwC`%7hpWFQy=oe2XVSgvJQ`lMUB=E*r)hO%@zjf1h!Bx!Dht3$!Z
z#*ruI^8p5@ZGyA2#yDxZ2mv*Qbl2fW_Ryo74rmv%8GQ%B5GHW`$~l9bf!%N~ww>ly
zAPEr0Bfy!OLn5Hf=?5GFcH)8HutL(LyFOO;$i|j6J!vR`cx+;RRY#8F)4==;qSxPh
z^3qd3EUa~<Zp=V&FP5ERdkxnTkou|=UtT$N`qCvVx=G6ix(!TNBLdAt>jT%y8*=!Z
zioEF$*Z-h%ASu}csSfm@ah-86V%b|ds?LA~n$KNRen+O_Vg*GeXgWpDfECbli>o*d
zOb_-XrxdJj=^ipC05y}C3acdNs^kz@w2*{Nexu|n4kAy_U?409lLQBn7p;`}{etJ#
zR~xt1a6Ew;2728@=uZ{C+NUpHIKQy)++{5MlYS|l5b&P^H4}hxj}~;<?XP+9;`TK!
zUPR4%Xuf9SsQdb=KXs*xIJRx|JSSxK+(qMl*;T<LYcMne5w4xFD?Fz>J?YK}6()4r
zAzsEq-V{8Jow!><Jj$(mv(|g>%1@bT_wEtgJ*J{yFS=@(K1@$a#cCNfrH(M&D#pTC
zmhD+C=(B;yqHsb$ns88+^;s)=B8q>6`Tg-RK@OZHar}w0SD4AwI^-2%ZKcLSyH%M3
z8u3E;8IQrtrgzut+B@M76v1PNWfWmYeL$E27p|<J;Q*F_WPkv;Z$Bp4lEz?7&XNVL
z%M*RAO@X3{Hh%=G0>-BuaNmHs@1XLFcLHI}j)AG8-OL+Jpf#B~XXHpenI7D13M2jr
zl6b1SN-$$4_Lwem(&h;s0Z9@Um<;VE0(5-#j-7xwj-4QKV<*b+VU?X}%oy!E=+HYx
z;X;3m4Rmc$NSmI%er)ONxl^lxVDo+X{H!(QW5<fUK;M@eql=)m1-HQjXAu(<kT=rI
z10jRQ!Lvt=G}vQk%7n{$YEV1o+yQt`mM%?tvFS{46ULLwK#Yu{PX$>VDxtN8Jf$fL
zupG!5(=Tf!+LA{J0waRlOP?#YPvd|<AS>9gMVbeAf)MbHg{tb!TG{~(L=;b+v=9Y-
z>&z*E9)Z}@A@GtgXqVJWTW};Iagj(r97;hh0?5E}RgyQ<K_e`)SYD!)s#7a_Q5LIJ
zk&?&<qH~FlIcNPb*K1qi0Im0Ts)IKGbC4GWd&B5VrQJlgB&81)b!0l0)mOy|ELjm!
z;blo&f|xCwJ(N<ADyTQzkIq>O2fdKZ%6So~FQO{6`b){gLnK}A!gpO7nCN<8ntt)c
zYhWJ5F*vEO>g)}44Tq&DiIim)t;ZjaPMkh}ik+Ug7L}(IPu&v^PwsYsV}mpceIhJa
z*P>*u=#5!<973tQa$5j#EsB*%N*VbVy>SDj@8KWxU{|3^<_RW~bdnU>TdqpcIOn^O
zs~z#F7{IW51g4gd`MiAI;0dKvsG7(4t&3|Q=C~pnk(oGdJ?@Kx6I}Sv!cL1tFfOpZ
z!s?7`$Hl@gy2H5q*Zo5ifpgVp*bCx0=S)(u2qh3P7iJ+EOa_T~^_vrRCL8V53Ua*J
zHOh5a^T4M*gaI2>_jae6wfHi;!q@L&9oe^t-%g`2f*u-#bktw_h4P3Rf$&;{mLl(<
zV#pIvTc*BIyG~e15ml2~oVYe$(dCT<PW>_m90V0G;MS1uMwIpVu};z+3+`tmu+!6r
zG69@2Y@WNAHrhrkh9-NNF}&tVrM~&hHMe)s6{lS=$+X^%3-18BYS-e6{wk`7v_aQj
zRN4j6y^N-1ePwze)j*(=ZFZTW0Y<d{Qg&~_qlE*7u2;z5_f<0wVZg%pvum677PI<^
zhSD(ynU)H&Pj~H9W_$Dxa;=o2@|I?4lu5wMfiEx&L~Uy;YE^1D1PKn~dQJX=oI(u&
z5OhGn%B~wrLia*prq5H`8b`yJ9cmL2SW*Bq>@BI!mP-h~V9YbYqi&6PAYpzZJtGb@
zV9mZ=E#q8)EW}tbg-^TmdeI0)uiuT-sM#Y_?u*t+n{5q*>1ZN4Lk+xpeHDvSrh8ya
z2-m0$)oZ~(o1-A`)lI0LSakd3V)qdC(Dr051>9;#PisuI@E+^WNUlj^@6#YeAH-<A
zd4b|`YQx*|rmUA<vL?-g($*RduuK`z5~_$%U#-?N>4k--oYvB2*$}I%#LEcaNnF34
zxSpU~xu@q4?+OOgwnRO=m<V?WaPf3up=3Z3LuOpzVjSXOc(%rE41$4>$EFkRe1Ne(
z?8EN<Uz`o>KmV8GozUa_?}JeA{>lux|EJkIbb(;D*l_d@(jmZohd3R&Js-^I|4_KG
zgqUDCX3`z5a6R!re$a|p;f9M{?2MjMXqy0Gjab4voT!rge7l?)(6R*7b!s305k55#
zdN|yvfzbTtHlo5gpnV^oGxwPPnN+_2{?9COf{*9FkHOLX9d!Ofciia!u<{H;qA>rv
z4*`ooT16%ubFgQ$2LP%SbO561AkP5l;7o)7b>i@ZHArE$Nvo5TQ`46~R3gz9(!W%Z
zHZ+`^6DNDI%ZfC-2005*>=8(3N<yVahTsOWcxiTZ$=un2qe7!AQ4rL0#smi0Q#50b
zoF5J+qY;S*e?UEU^77L1vWPcz9!k1$hOz}Y%pnz-mL#r;t5C=GN>#=O5COaAz48l7
z%BM?^t#AOs^bnhx(pJxB#5Jrt#Y_`qnx>2Ny$m?x)*H{~Y79t=;eDuN-{z^=ZTfy3
zW#w2ffB@ke>dw?-%n0&R0nbIN6RjS%t}=iUxq2}czQSH4zaTCJzW_(PMPkOw=~0bV
zfrC;@dkBArk+hCYwi0vS(E>v+O^hf)1j|4h^zv&k&;{i_Lb|f2SU3a%gYSG-24E9i
zgX6OZuxA7e(#ZlklJ_(bVu(|?^cuh#g9p=@#g+;3N)ZUhkMW6Gj%^J(g}GT}7pt`@
z*~qmnyESB|_pDSB!LY%0Z>u?j9KrMt6ACfG07`h5O$V@^BfbRzx()7i08E88tnrz`
zWsBfR*=Lll!4#BW7-bPMw4c#8)*b%m!fOl1xs-r27bsjj$!u<uKL5YOU9)pbt0&K$
zTU_GMV`U`0vSKgaxQ?K}m#oc_6)Vli27pNmi+t?xd0sz#;Y{Q-oj42D$rj@mK``bm
zCI-7%M;yqA`H}cdX7bh`Q?MPJHya4)>?F4%2pUEzz#5K=H1gcOKwbe5-{)BPjw36Y
z3_&oDGGH!X+%Dg)dL5S#=bQ2z+}NnItPL?$i>6lKge3{ek_(={*uAn3gOgMhF>$~z
zL~xQQG$pwi>1m!zpX+2EM~E6f-iL>)ML2K-%o_kFz&Zk2m9fPjg_~bpreq34$AZ7P
ze;M+<lk2&?VdgRW&`onmju!K29}pKQf=9QMjUn#?10nqn+2P9$59-Fmn~TYPKziUF
z`d>Di>_7jJ8lV5(2Q`PU($W7Q6?P8i@i_vrRI&qD(+~j(E;aOdBI<-Ut<0DZe?THH
zQD#6e+^*WtXhc|uF$I|-Q4>R-`wk!aL=)z40i`us33NWA5QvzSW_e$X>~gAFz&j9z
zjfLr-8Bhp0m`<i&xl=>@zOusk=CaWm1WVJz5al^ydT1yzaEZ=foKttHxl-Et7n8Ib
z*l2X@4U<emmLDilqI}g5o5g!|Knp#k!OJzcNKp@rTPK;57vK!ZB<u+{&F~hEN*gyJ
zF#l$2#t$Ikj-nwVHjxRDl+>Fpe3$^{C(zM+BYv<gI^0Q=WAs8_iNs2!LlyPXH9OK>
zgVYQlRH4v<`N2dfqKt82VqC8*;&duVRY4@Ti&d}obIk+<iu;UuNs|jr8-y-k+*QO6
z>2ZdgieEzGof=f@Q67D}gsUB>_K`v>7fxN^!e4UMWwYEr9Tdt)AjC%>{VNhU1gzyG
zN*&Q`)E4}1u9oPPUqzlqDwA+C!^g^XRuj@dFJp5HK?lT)0`COL4@^_jyn%tSa?sG^
z5#}DU+e}c4r$;$x&P?9^c1|P62^jbFV8as1raHtf_5*A#`e4vl2AVFr9HsMF{k>Eu
z2kSVsRR$Jld#tBJkwHjj<Bi(3BT+^*C>yRhYCOpJZFs%YC{$<!v+&9e=+Ourp#bw*
zTPUe$Mvk0TDIV?(q!6PBG}HJ2{2K}4&^4I+GIr5VKYMcdoSY%jIP}v<<c#Pqqx|Z$
z={3!KF``V5{&5RvC$66nYXlQ-Cn#dy?hXSpN5S|q1F$x3Q42@ot&IlkKq~S<7dk4&
zbNbQR<S8G5sP3@}@0AerlmDW!kw7_z6F2Cwhl^F1zsXBr@04How<2fkg+BvZ74{#e
zY>XyM(1}1;Ts6Wo4BsTl^?TEco9z+m1ELMi>44d+2^xbogMlwtqH8ahFd@naEM0QO
z+HbQv0WqdAZXf|2O}YU2d-cMlXXM(D2yR>nV+RH%c}dbC;Z~LCO>r_vW)h31m2fQ)
zq!~OEJ)%M0XnLpMO_z+40vMfXK&-yKn04FtD;HKyp7VPVvSMN}8RlN3q6Li@9wd9}
zVj8jmw%ud!sD#ilWu1O*c}4g<7?lc;*ZU<QA^o5J-=<T<fzbof`+aS6cl{rlezx!a
zk8CzI-v9COH_E>q{hx}?lH1sVp0wUVr2LGPPA2oS{CCcJx?Qij))Lar;aCWA0HW*)
zl%Z&cXK;|1p#oUSd7(h~z^}Oogp3vSy=mg$01)PGe8Da1^^H^*!|FSIui|Oo1%`mi
zplO~4XPy{-r8Y#Js{0N+quir+eusul?npH+P{8@a=o*_i4giIP*)M2N(A}*m9a%=R
z-a)r#&vY7<t!bz?>dloiZ1R}zS;4<JQ7b~LP^1EZyQM#bwNNdY#-IlWs<KIijV?)w
z8d004>du|kl;1P4fv{`|>P!cbb<>=%7GEX1Cbw^HN=h!oFd^QWmPXKVKjU_zU1U%w
zFahO_*I7ZQHP05=YJ}9*k*O++wa6?LN2$J~&FUk=S=6OmGi&o|3tfNo-SZUh-quFZ
zh1~=BRFTV_p2zBHTv|!%IP4Sp%xKu4x6q`UZFv8JPUGl^-d#mSMsB(?=j@~fIcF!j
zgm&PGClWkrhvRbmBRPq7Y(m_Cj2sQ+NIp+zo;ucW5?mtxRc)uG7tpSoQ9!o95`;>L
z`$C&M4-YG^WnFlNx`7f5zn`G{?i3GKl8F=~EJa@GhrW7vF9<`{OhFdc{z)^=kU}D<
z4$s3K&nrj`>zZPLrw|GU9ECjW!fwNML=zq6(q29h0nS&e^;P}3DAeK>iRNT9(b0=Y
zP9OoTH?>&MrRM{ES1u~)g5|3QqCiQ1wSyEf+jr(TkScbRQ39&1cyK?ZVG_NjM3^18
z)TFb(BP<_4MX;n?`xzG=35}g`SfQbl!Jm*sv<RZ2lh(L0$bNEO2h6WiDITFWV3ieC
zQ$5HDaB<V8&*WV*h3@ghIy}kGhpMM{sLrrG{cKacGwVYA&}5*U2bgd`0aQVQexY|y
zYtf*SO2OwP_(*1Sm~zT!L7LL-Nasrs#FT-pB?4Tghr;C{SebIE;RxnuB-QCk8`{6*
zLfMlP=owP1k2ymK^ydu58ElwnZU&}2(6Be17YKgjnWbw<Mq*1i95(DB;c)Ya;a8?O
z(QQQd1k8;Eop~fA_a*uQ0%i@E=^rxWVAmO`x&d7m_Qb?Q;^wq}3CLqJmc)HdOd~Dv
z;t7PHv-UlB0<iZpow#04;GmUsFLgs+(cWg9GlK9paDK%H*#nays*?(M;+jI9Ow0JT
zg`K`(&gn=%+M^<dJmi$`p#H8j7&`$h-P3@y2@PIjaD$F&!W>pH=ej2GhGW48n_!Uo
zod>)dq^ERLM}!7aHw+3H70>^fCPCQ}UqW4?5oCS_tf!nOvmYBur!Fk5N))^76PZO>
zU6;6LX$^a2*!EK<Pzma<$H7@Ye@Qe7Lm>09yw>4E!v+*1Fq^k32u8u74iERDVL?@C
z#Lb;!)&(9B#13G1<)8{;ZeEL;t|R*1d=oiFdBr4ihRd)d;wn&hYv?qCg9U06<e6^G
zLZ*Wy7}&{;+S(TMke%8M<ZcOy9y&_ZEZl<Mg;_R@=1|^u7mBc?q@@3g^In`Rp*0W1
z@f4>C*$dWp>?RzfU{)+?h%SOhQcqfTVFE4a?Ok%(k$9olwFLmi7`_(R@0?@?LOuKk
z>O&pnNmn2txTaXv1TzB0Ps<vNEIRBAy2vYU#hK?TK6(u>ck@85tB|9zScJzaQW8iu
z!d+{JFGD7A*`m)yvx-(O@Eg=;aF+>%K-3g4jHCI_slmyhgR9$Tv1QvV^W>AN2!69>
zmFFI0gcN}GE>Lw5RC)m$aM#y3P>CJKQ+1)>nsWxW<7LFZPAp-ZD;tpVHm-z#J{-Bq
zle^;2^VwQ&2UC60zlN6konUWX|Bf?|bl~@JI3=c_Q4h>Ahoo?gb{Hi55lo;pq6|Il
z=u{XmO$eEO9&)rIX2543S*DFvi{rIAJ#Zk6*ZyH8GO39Ss(?>5NH7wdd{!k}pps=I
zA3d86^S<r}`vmk|-((x`mQl8SC%*LC#<r>)XZE*}WosEjdy*NJIO~-nrb`YylH@5F
zf&gGwe1tX~MEWB05H>a<(>S@hGgbwmz1mYSHw5qscv#vZE_DJEvW2^Js3vVla6uh&
zMtjuJeWdm_6B{}2&33tNpYswye;qU<kg7T*$Ua26oO)KW%TyLRgD-k^0Aw~vb$=A$
zi;qRz1gF0A{&Cr<!Spw}B2I>pm=qqIaE76#vDhQ>!4K=ebGa>>lLzO<<u2mj=$zCy
zH<0_C03psfy!cDv=VccNO`0Sr;Qa|64R+x%-t&JmOQlAFJ;lfW+xMNN_|gVs{$I3C
zvP^dc6k?e$kZsEF5k7v&5}*bDTTkjszSl#}or2w9ulE)70rGEAy0|1|{E`M>xY%|e
z6M}Wr-xGm;nP7>GL?S0=F$At(OA-LlEkr;&i1L$?nvPl3D%CsY93`eCeE??Ss|IUi
zlGJ%p>fnBGF^w^0mNmg$|Ex20{Y9HyG18dh;!m&(?+=gw9>{8cC6#uTq#a5C)0NH=
z0ak-`Ls3lCf{C?#A)!VOLTW_z8=1rlRVxfU0!G*>&T3+#3O6W3o-_qJ4X<#4-oT+|
z+(?v~ArsTm42(VBp1G;m<l3@B3BwaoLhXok2VKAg6(t;|*6LgWLIZ@}!s3j=(&2?W
zlkV?~A~qfuVCX3gA#O8q5;D5Z7Xmwr!icZ_jnez}?S~!m|Ei60z_I@v;qLz5WGbKR
z&;OMj=l?wv=IHkSo(!}|6Qd!QbW#$?7Mv`Q$|m9Xe>y^Ui~FSz^)r8KWPt?2nG`16
zI|cypWOCMX5jJi3X(~g}`#VOB0E9_G*?V6=IBo<2Q!j{tKoDu(b6WtQXxk9pP=o>(
zvItMrMh^14KxfJ^!Z>`Wm{`yw|3JP5F?MAu+%8=u>2OLS2UXTFLd5rh;|f7sM#J2c
z^ylhn{aWDv^0yvCxqku6ue(9T54SHcs|<QWHIu&T{=ADPudJNCu<xXc*!{F(FM8Ok
z^iwJ#Atij4x`V3EPMm<*j=f7Xze0KLr=3F#C^!@bXB(am{BX8O?#Z|d^+Br#Y}(uv
z(}mXsiw*-e48?{%IJn}l_wgcvPW?2J@Bk%lUb7}{982-vM0pC=7Wep8Pwn0hKN$1d
ze-cjQKTJjcHr`PP9m@ZF7WcX6r}u9X8Nhn;Kc~}$<oNu@D2UMmv;WHE<Nk>#OfL!f
zoeHtX6a_#K#*7*3ddwJy?VldF<DcId7?Amoo721zc9+wBm-`?2x_AC33#t5(+z9&=
zfJSC&WDT~0-~0W-QQ#8@xBbF7<az=95lK}U5fczEL()H$&*jGSKLlRrroSIfcd!lb
zgZ>$O#`Hf}GHeTNd-@}?pV89W))@ZbKIos#r_*El50C1hYwSw@1b4fJ2H97E^xsYY
zPxqhy$>nG-^g$ZIgV*``PudLfv9fu)l26T7oJ`8jW<auRxtz)5GjsNQv5>4}lQw>q
z=2FIg!s85&t9t`q-)rpjIG&ua=Ck=iA%(a?>oGPxHXTO5)`NoVng0?3H)!2K%aO=K
z>VN4%HZ_+2gCh7o%56vg1P`^`2h858r2lU6Kby<++JBjRVI2S6i^oy?CT#}!So3+u
z$=F5wnNL@eb9OPAv{S`mGMi7O3&lBSE>pJi^QF1L<bQrHJLk)PbD=jf8fadOnFaW&
zJts17i=$hbOxG5;Df!x5raJSV!O^4OFx~$fa{i~X>GAzPqoGDO)IsJx%Z%s$Yk2<i
zGSzOjIM83@pCR?XWFa~B{~ah1b^s>wpY%^ScjS)A9m?I$W72;&`Jc)6`Tx_IasIda
zLHWRS^|Hg77vokRuQ=2rP55H?A;xoKi+yZ@4fu1&7;l1O!#BDeosyV3+Wttjflc?L
z))_=UBXNkP^}+=>9wV+1hOng3Ae|f%8nMRw7<!i`k2_0l4AU7#f5M$m_pE8$JfbZy
zU<6^(-8q}g4FnsA3_EHai(hl?8~pO}Yg331Ozr-HLfFx%e$wDx^FNvHyZ=3z&85fw
zzkYHZ_!I2<EieYuOX%rGn*QTSa^PrwU;)bfcO}c@h<1PXjQ^x~==J}kvdQuO-(fIK
znEr`uek4tjz(eZ)seC3o_WzEA8r?v9=${yDlcyWTUcX5H-Sq!-|N5UVWXJiR_rmKz
zyub6%y}$iT<l)rYPTlxlZ~xslf9_8||K(3wH-G5ww=O0>`?lzvm)`I<{`bdz=kD9z
zzH;;0Z~VoLw|?c!JO9(!SDuUiyO00EPyVepKK_o+eD*KB?*sq%pZrYetxv67`{U-j
z7k=Rb&piIU8*hC2EkFI1%$;mLIq~ZsN>(m?ITgS4U*0|I{@j;-<_ot!yma%wE<g3b
zN5B8gKmTg-7c29hc<YzHwf5Ur|J;4$xx&{U{_e`srGpsQ7{)*t=$ik|+(31PEwmr`
zUq}_k@_$%F@1uMV{S(RTe96wu6?1dxOr<hk$>fribS9Zh74w<-OfpxjlnV3Z;TqaY
z{$p|I)&CG6FpmEi4$J#1ednRaW}bfbN;2;xv&m#8^}gwur_X)%{ImA2J@HT9|Ao(e
zX6k+4cYNjF|5Uv4FKX}q=sO}u=0E<nNA}m!xYmP+fv)*q9!<pc{^bAI{yPkQ>7jq3
zQmB+Nl|r^s!0oxox%6DJk|`wZ`9iLkN~N8-N<KN48d6QzQ~vks{{^lI<M_YPbHJU4
zp83qDFI-BN&YoLde)hjVeB>`b^M<dEzS(gL4+sXj=6|s=l3wjg{ujpa-y<PL56~X^
zCsKB*!tBwRQlXM9CR1}syO6Wzb17#&SIFk`X?w0%I&k^l7ynmCV^4T2|9glvf}g(p
zx2Hdy_=AU!yyJs!c;5(G8H0RKG0-*t=N};d|2Y2pP*|pi{)xeYe244WUiyCuvEC^L
z5+~D1_?mEpHdWx6pt1ZP4$u234gdd7eG2~nx13sh^|9tVCx4@QEArc4{O7-#JNc<g
zzx<AGd@VNpelPwfspPqT_7ATgKlgLDfAc4QEcu0>{>A_Chj-rd%FqAd#kD8@-iLna
zy?^wf|5=***>8U3?|$JA{_2;0=fkyM`EPFXxBk_~-uAIqYma>IH|C0G=0E;#vfupO
zufFo<*FOBkrT_5eXFis5_S4yModd@}*Zdz*9Oypuf5iWd&;K7dv9|%(MSt9Fd25?8
z_xosH^vC_*qwz-ejOKNI{<Dkz<p;_BAIE?6aOy~Y_Rv2upD*Bymz^ujJK3C_nk&ww
zbE!fmT~6ialG$R~$>HUY6LT;9FPZM&|I6b}n6dsh5|VcT_3eM>?9;R7zx42tN8a^@
zk9HLp|9DMfplkl;hji=>h?#w?|EYX7IbQz<#P9tS>!E+5l1dlLbHyxkJrwihWOlAR
zSIVSvd1r2}lBtx6^OZtwNH@`5@*k-n`t1J{7MZd9zaPpDR@aaJ_?OR{_z&3!w14ee
z|L=qMKK<(5H+}R6PQ3GDv%fd}f4}&HfBm~wPA<Q%*vw!2^vg4UdiN8xKmN@}e(>)+
z_3TG}_D4VTk6yX=@R66#z3ZEUwK^{KpkP4ezux39vM%j4|I>xO{hw5NeExf6^aumK
zhC5fB8<B}lDo@;mfK2STLB`|N(Ti4+w<+PeAY3SdUvi`HM3J{MFXHOb8uBzuAblkA
zBQueFgZDXkL9yyu9nj^nHNPhA_rtk8qz!eDRhO5P_=T_G$X*j2k>sL_mfdcxyG`6h
z#+$=YMt_I%2#rrEh3UB8@9jD+Q7z#*pZx+Dpx$2dKbh*g|1&j?{}}+W2T&xS|9Cnb
z05-q#Kp?gJNasE=vgiCy=6m)3WGXj~|2Pb868ewl{$Zf{fox-S6_@z9cW^Pp>ISaK
zU0oePFFF5*JpY-_rN`%gMnH-_kbU$|fEDVkYHO>n=)NE9DgSZSt0(>=%bYM{|IfZr
zK5)e}&ioW|2)8W6V36GzxZb$nYXbxQ^B?O$%vk>iG{imUKYTsC^S^-j@A3RUAOh?H
hhFAFczMgbEmyD;z%HS^O8owH2V2pt=23|85`2SDbXC43m

literal 0
HcmV?d00001


From 57fcbeabd30d2f39e3f5805c37e377135cc1b678 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 06:26:34 +0200
Subject: [PATCH 056/282] feat: show net lines in tix diffstats

Keep Git-compatible per-file churn totals and scaled insertion/deletion bars, then append a right-aligned signed net line count computed as additions minus deletions. Color positive deltas green, negative deltas bright red, and zero neutrally; retain binary rows as Bin without inventing line information.

Use the shared summary renderer so whole-commit built-in views, pager input, external-diff summaries, and commented new-commit editor diffstats agree. Preserve parent and aggregate insertion/deletion summaries.

Cover positive, negative, zero, differently sized bars, binary files, streamed pager bytes, and the commit-editor template. Update the tix behavioral specification.
---
 gix-tix/spec.md            |  9 ++--
 gix-tix/src/edit/create.rs |  6 +--
 gix-tix/src/lib.rs         |  2 +-
 gix-tix/src/ui.rs          | 96 +++++++++++++++++++++++++++++++-------
 4 files changed, 88 insertions(+), 25 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6249c8e8ca2..bf123359fdd 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -250,9 +250,10 @@ space first; changes blocks adapt within the remaining history width.
 - `Enter` in history opens the whole selected commit against the active parent.
   `Enter` in a focused changes block opens only its selected path.
 - A whole-commit diff starts with commit identity and a Git-style per-path
-  diffstat in diff order, followed by parent/root, kind totals, and aggregate line
-  totals. It then shows the internal patch and invokes any per-path external diff
-  drivers.
+  diffstat in diff order. Each textual path retains Git's churn count and bar,
+  followed by an aligned signed net `additions - deletions` count. Parent/root,
+  kind totals, and aggregate line totals follow before the internal patch and any
+  per-path external diff drivers.
 - Diff preparation honors Git attributes, text conversion, binary detection,
   external diff commands, and the configured `core.pager` pipeline.
 - Binary, submodule, conflicted, and otherwise unavailable file diffs do not
@@ -315,7 +316,7 @@ space first; changes blocks adapt within the remaining history width.
   repository starts from the empty tree.
 - The Markdown editor buffer contains editable identities and dates, a `what`
   title, a `why` body, optional attribution trailers, and a commented Git-style
-  per-path diffstat. Commit hooks are not run.
+  per-path diffstat with signed net line counts. Commit hooks are not run.
 - After editing, tix revalidates the destination, applies configured signing,
   persists the already-prepared objects, and atomically advances every mutable
   direct ref pointing at the parent. This includes local branches, custom refs,
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index ae92bc0a9ac..0003abe288a 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -360,9 +360,9 @@ mod tests {
         assert!(
             prepared
                 .document
-                .windows(b"tracked".len())
-                .any(|window| window == b"tracked"),
-            "the editor buffer includes a commented per-file diffstat: {}",
+                .windows(b"tracked | 2 +- 0".len())
+                .any(|window| window == b"tracked | 2 +- 0"),
+            "the editor buffer includes a commented per-file diffstat with net lines: {}",
             prepared.document.as_bstr()
         );
         assert_eq!(
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index bd881e7664b..a1b492a4f0e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3973,7 +3973,7 @@ mod tests {
         diff.write_to(&mut streamed)?;
         assert!(
             streamed.starts_with(
-                format!("{title}\n topic       | 1 +\n topic-extra | 1 +\nroot · A 2 · +2 \n\n").as_bytes()
+                format!("{title}\n topic       | 1 + +1\n topic-extra | 1 + +1\nroot · A 2 · +2 \n\n").as_bytes()
             ),
             "the pager receives path statistics and the aggregate before the patch"
         );
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 279a7eefde1..1d37922467c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1048,7 +1048,21 @@ pub(crate) fn commit_diff_summary(
         .map(|(added, removed)| u64::from(*added) + u64::from(*removed))
         .max()
         .unwrap_or_default();
-    let graph_width = max_changes.min(40);
+    let graph_width = max_changes.min(40) as usize;
+    let delta = |added: u32, removed: u32| i64::from(added) - i64::from(removed);
+    let format_delta = |delta: i64| {
+        if delta > 0 {
+            format!("+{delta}")
+        } else {
+            delta.to_string()
+        }
+    };
+    let delta_width = line_counts
+        .iter()
+        .flatten()
+        .map(|(added, removed)| format_delta(delta(*added, *removed)).len())
+        .max()
+        .unwrap_or_default();
     let mut lines = paths
         .into_iter()
         .zip(line_counts)
@@ -1060,10 +1074,25 @@ pub(crate) fn commit_diff_summary(
                     let total = u64::from(*added) + u64::from(*removed);
                     spans.push(Span::raw(format!("{total:>count_width$} ")));
                     let scaled = |count: u32| {
-                        (u64::from(count) * graph_width / max_changes.max(1)).max(u64::from(count > 0)) as usize
+                        (u64::from(count) * graph_width as u64 / max_changes.max(1)).max(u64::from(count > 0)) as usize
                     };
-                    spans.push(Span::styled("+".repeat(scaled(*added)), color(Color::Green)));
-                    spans.push(Span::styled("-".repeat(scaled(*removed)), color(Color::LightRed)));
+                    let added_width = scaled(*added);
+                    let removed_width = scaled(*removed);
+                    spans.push(Span::styled("+".repeat(added_width), color(Color::Green)));
+                    spans.push(Span::styled("-".repeat(removed_width), color(Color::LightRed)));
+                    let delta = delta(*added, *removed);
+                    let delta = format_delta(delta);
+                    spans.push(Span::raw(" ".repeat(
+                        graph_width.saturating_sub(added_width + removed_width) + 1 + delta_width - delta.len(),
+                    )));
+                    spans.push(Span::styled(
+                        delta,
+                        color(match added.cmp(removed) {
+                            std::cmp::Ordering::Greater => Color::Green,
+                            std::cmp::Ordering::Less => Color::LightRed,
+                            std::cmp::Ordering::Equal => Color::Reset,
+                        }),
+                    ));
                 }
                 None => spans.push(Span::raw(format!("{:>count_width$}", "Bin"))),
             }
@@ -1931,6 +1960,20 @@ mod tests {
                     path: "old".into(),
                     lines: None,
                 },
+                crate::app::PathChange {
+                    kind: ChangeKind::Deleted,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: "gone".into(),
+                    lines: None,
+                },
+                crate::app::PathChange {
+                    kind: ChangeKind::Modified,
+                    group: ChangeGroup::Tree,
+                    source: None,
+                    path: "image.bin".into(),
+                    lines: None,
+                },
             ],
             ..Changes::default()
         };
@@ -1938,35 +1981,54 @@ mod tests {
             title.clone(),
             ["--- a/old", "+++ b/old"].into_iter().map(Into::into).collect(),
         )
-        .with_summary(commit_diff_summary(&changes, &[Some((2, 0)), Some((1, 1))], 3, 1));
+        .with_summary(commit_diff_summary(
+            &changes,
+            &[Some((2, 0)), Some((1, 1)), Some((0, 3)), None],
+            3,
+            4,
+        ));
         let mut terminal = Terminal::new(TestBackend::new(64, 9))?;
 
         terminal.draw(|frame| draw_file_diff(frame, &diff, 0, 0))?;
 
         assert_eq!(rendered_line(&terminal, 0).trim(), title);
-        assert_eq!(rendered_line(&terminal, 1).trim(), "new | 2 ++");
-        assert_eq!(rendered_line(&terminal, 2).trim(), "old | 2 +-");
-        let summary = "root · A 1 + M 1 = 2 · +3 -1";
-        assert_eq!(rendered_line(&terminal, 3).trim(), summary);
+        assert_eq!(rendered_line(&terminal, 1).trim(), "new       |   2 ++  +2");
+        assert_eq!(rendered_line(&terminal, 2).trim(), "old       |   2 +-   0");
+        assert_eq!(rendered_line(&terminal, 3).trim(), "gone      |   3 --- -3");
+        assert_eq!(rendered_line(&terminal, 4).trim(), "image.bin | Bin");
+        let summary = "root · A 1 + M 2 + D 1 = 4 · +3 -4";
+        assert_eq!(rendered_line(&terminal, 5).trim(), summary);
         let buffer = terminal.backend().buffer();
         let summary_x = |needle| {
             summary[..summary.find(needle).expect("summary term is present")]
                 .chars()
                 .count() as u16
         };
-        assert_eq!(buffer[(0, 3)].fg, COMPARED_PARENT_COLOR);
-        assert_eq!(buffer[(summary_x("A 1"), 3)].fg, Color::Green);
-        assert_eq!(buffer[(summary_x("-1"), 3)].fg, Color::LightRed);
-        assert_eq!(buffer[(9, 1)].fg, Color::Green);
-        assert_eq!(buffer[(10, 2)].fg, Color::LightRed);
-        assert_eq!(rendered_line(&terminal, 4).trim(), "");
-        assert_eq!(rendered_line(&terminal, 5).trim(), "--- a/old");
+        assert_eq!(buffer[(0, 5)].fg, COMPARED_PARENT_COLOR);
+        assert_eq!(buffer[(summary_x("A 1"), 5)].fg, Color::Green);
+        assert_eq!(buffer[(summary_x("-4"), 5)].fg, Color::LightRed);
+        let delta_x = rendered_line(&terminal, 1).find("+2").expect("positive delta") as u16;
+        let zero_x = rendered_line(&terminal, 2).rfind('0').expect("zero delta") as u16;
+        assert_eq!(
+            delta_x + 2,
+            zero_x + 1,
+            "deltas are right-aligned despite different sign widths"
+        );
+        assert_eq!(
+            delta_x,
+            rendered_line(&terminal, 3).find("-3").expect("negative delta") as u16
+        );
+        assert_eq!(buffer[(delta_x, 1)].fg, Color::Green);
+        assert_eq!(buffer[(zero_x, 2)].fg, Color::Reset);
+        assert_eq!(buffer[(delta_x, 3)].fg, Color::LightRed);
+        assert_eq!(rendered_line(&terminal, 6).trim(), "");
+        assert_eq!(rendered_line(&terminal, 7).trim(), "--- a/old");
 
         let mut streamed = Vec::new();
         diff.write_to(&mut streamed)?;
         assert_eq!(
             streamed,
-            b"0101010 mapped author subject\n new | 2 ++\n old | 2 +-\nroot \xc2\xb7 A 1 + M 1 = 2 \xc2\xb7 +3 -1 \n\n--- a/old\n+++ b/old\n"
+            b"0101010 mapped author subject\n new       |   2 ++  +2\n old       |   2 +-   0\n gone      |   3 --- -3\n image.bin | Bin\nroot \xc2\xb7 A 1 + M 2 + D 1 = 4 \xc2\xb7 +3 -4 \n\n--- a/old\n+++ b/old\n"
         );
         Ok(())
     }

From fca490473216570f0610f7283933011d29fa00ed Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 07:03:48 +0200
Subject: [PATCH 057/282] fix: recover tix before processing filesystem events

Treat the event-loop head as the repository-lifecycle boundary because the linked worktree and process working directory may disappear while terminal or filesystem input is pending. Recover to the lexically normalized common repository before watcher handling, cache invalidation, or redraw can open a short-lived fill repository.

Switch the surviving common repository to bare mode, discard worktree-only watchers, caches and diff workers, rebuild reference watching, and schedule history refresh from the surviving graph. If a repository vanishes in the narrow interval before reference inspection, return to the boundary instead of aborting.

Document the lifecycle invariant for future event-loop work and extend the isolated recovery regression to cover disappearance during event processing.
---
 gix-tix/AGENTS.md  |   4 ++
 gix-tix/spec.md    |  10 +++--
 gix-tix/src/lib.rs | 109 +++++++++++++++++++++++++++++----------------
 3 files changed, 80 insertions(+), 43 deletions(-)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index ea79bb28845..c6f6856879b 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -15,6 +15,10 @@
 
 ## Repository lifetime
 
+- Treat the event-loop head as a repository-lifecycle boundary. After any wait,
+  the original worktree directory and process CWD may no longer exist; recover
+  to the normalized common repository before processing watchers, loading view
+  data, or drawing.
 - Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle.
 - Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
 - The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bf123359fdd..3cdb17bd307 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -391,10 +391,12 @@ space first; changes blocks adapt within the remaining history width.
   semantic trigger, coalesced paths, phases, presentation count, elapsed time,
   and outcome. Logs use the platform application-log directory, retain seven
   days, and are best-effort.
-- If a linked worktree disappears, tix lexically normalizes and enters the common
-  repository, reopens it as bare, drops worktree state, keeps tree/history views
-  live, and reports recovery in the status line. If recovery fails, terminal state
-  is restored and the contextual error is returned.
+- After every event-loop wait, tix assumes that the original worktree and process
+  working directory may have disappeared. Before processing filesystem events or
+  redrawing, it lexically normalizes and enters the common repository, reopens it
+  as bare, drops worktree state, keeps tree/history views live, and reports recovery
+  in the status line. If recovery fails, terminal state is restored and the
+  contextual error is returned.
 
 ## Resource and responsiveness invariants
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a1b492a4f0e..e8c6f258021 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -966,6 +966,48 @@ fn event_loop(
     let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
     let result: Result<Option<Duration>> = (|| loop {
+        if let Some(mut recovered) =
+            recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
+        {
+            recovered.object_cache_size(None);
+            mailmap = recovered.open_mailmap();
+            fill_repository.path.clone_from(&repository_path);
+            fill_repository.bare = true;
+            fill_repository.retain = false;
+            fill_repository.retained = None;
+            app.set_worktree_changes_available(false);
+            worktree_watcher = None;
+            worktree_refresh_deadline = None;
+            worktree_watch_set_changed = false;
+            filesystem_responses.cancel_pending_worktree("worktree-unavailable");
+            worktree_changes = None;
+            line_diff_pool = None;
+            sync_line_diff_pool(
+                &mut line_diff_pool,
+                app.changes_mode.is_some(),
+                &repository_path,
+                true,
+                line_diff_parallelism,
+            )?;
+            tracing::warn!(common_dir = %repository_path.display(), "worktree disappeared; recovered with common repository");
+            ref_watcher = match start_ref_watcher(&repository_path, &repository_path) {
+                Ok(watcher) => Some(watcher),
+                Err(err) => {
+                    tracing::warn!(error = %err, "reference watcher recovery failed");
+                    schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                    None
+                }
+            };
+            ref_watch_set_changed = false;
+            app.manual_refresh = ref_watcher.is_none();
+            app.notice = Some("worktree removed; using the common repository without worktree changes".into());
+            if history_graph.is_some() {
+                refresh_pending = true;
+                refresh_from_filesystem = true;
+            }
+            dirty = true;
+            urgent = true;
+        }
         let mut worktree_watch_error = None;
         if let Some(watcher) = worktree_watcher.as_mut() {
             let mut received = 0;
@@ -1244,45 +1286,7 @@ fn event_loop(
             let response_ids = filesystem_responses.begin_reference_refresh();
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
                 Ok(repository) => repository,
-                Err(_err) if worktree_repository_is_gone(&repository_path) => {
-                    let mut recovered = recover_common_repository(&common_dir)
-                        .context("could not recover after the worktree repository disappeared")?;
-                    recovered.object_cache_size(None);
-                    repository_path.clone_from(&common_dir);
-                    repository_is_bare = true;
-                    mailmap = recovered.open_mailmap();
-                    fill_repository.path.clone_from(&repository_path);
-                    fill_repository.bare = true;
-                    fill_repository.retain = false;
-                    fill_repository.retained = None;
-                    app.set_worktree_changes_available(false);
-                    worktree_watcher = None;
-                    worktree_refresh_deadline = None;
-                    worktree_watch_set_changed = false;
-                    filesystem_responses.cancel_pending_worktree("worktree-unavailable");
-                    worktree_changes = None;
-                    line_diff_pool = None;
-                    sync_line_diff_pool(
-                        &mut line_diff_pool,
-                        app.changes_mode.is_some(),
-                        &repository_path,
-                        true,
-                        line_diff_parallelism,
-                    )?;
-                    tracing::warn!(common_dir = %repository_path.display(), "worktree disappeared; recovered with common repository");
-                    ref_watcher = match start_ref_watcher(&repository_path, &repository_path) {
-                        Ok(watcher) => Some(watcher),
-                        Err(err) => {
-                            tracing::warn!(error = %err, "reference watcher recovery failed");
-                            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
-                            None
-                        }
-                    };
-                    ref_watch_set_changed = false;
-                    app.manual_refresh = ref_watcher.is_none();
-                    app.notice = Some("worktree removed; using the common repository without worktree changes".into());
-                    recovered
-                }
+                Err(_err) if worktree_repository_is_gone(&repository_path) => continue,
                 Err(err) => return Err(err).context("could not inspect changed references"),
             };
             let next = history::snapshot(&repository, &revisions, &hide, worktrees)?;
@@ -2382,6 +2386,21 @@ fn recover_common_repository(common_dir: &Path) -> Result<gix::Repository> {
         .with_context(|| format!("could not open common repository at {} as bare", common_dir.display()))
 }
 
+fn recover_event_loop_repository(
+    repository_path: &mut PathBuf,
+    common_dir: &Path,
+    bare: &mut bool,
+) -> Result<Option<gix::Repository>> {
+    if *bare || !worktree_repository_is_gone(repository_path) {
+        return Ok(None);
+    }
+    let repository =
+        recover_common_repository(common_dir).context("could not recover after the worktree repository disappeared")?;
+    common_dir.clone_into(repository_path);
+    *bare = true;
+    Ok(Some(repository))
+}
+
 fn normalize_common_dir(common_dir: PathBuf) -> Result<PathBuf> {
     let current_dir = std::env::current_dir().context("could not obtain current directory")?;
     gix::path::normalize(common_dir.into(), &current_dir)
@@ -4122,6 +4141,18 @@ mod tests {
                 Some(true),
                 "recovery configures the common repository as bare"
             );
+
+            let mut stale_git_dir = git_dir.join("worktrees/deleted-during-event-loop");
+            let mut bare = false;
+            assert!(
+                recover_event_loop_repository(&mut stale_git_dir, &git_dir, &mut bare)?.is_some(),
+                "the event-loop boundary recovers before its next action"
+            );
+            assert_eq!(
+                stale_git_dir, git_dir,
+                "future event-loop opens use the common repository"
+            );
+            assert!(bare, "future event-loop opens treat the common repository as bare");
             return Ok(());
         }
 

From dcd79d6b47807a98b729a3b33e6273a7e343d478 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 10:09:01 +0200
Subject: [PATCH 058/282] feat: clarify active tix shortcut prefixes

Make the main footer show when the display or edit prefix is active instead of replacing the prefix label with an unbounded run of shortcuts. Enclose the applicable commands in a bold `v active (...)` or `e active (...)` group so direct shortcuts remain visibly outside it.

Keep display-toggle state dimming, omit edit operations that cannot act on the current selection, and show `no actions` when an edit prefix has no applicable command. Document the footer contract and cover grouping, emphasis, contextual edit actions, hidden-history availability, and the empty state.
---
 gix-tix/spec.md   |  7 +++-
 gix-tix/src/ui.rs | 88 ++++++++++++++++++++++++++++++++++++++++-------
 2 files changed, 81 insertions(+), 14 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3cdb17bd307..085227352de 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -155,7 +155,9 @@ without trading responsiveness for metadata that is not visible.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. `[` and overlay controls remain direct
-shortcuts.
+shortcuts. While active, the footer renders a bold `v active (` marker, every
+applicable display option, and a closing `)` so direct shortcuts remain visibly
+outside the prefix.
 
 ### Time-travel
 
@@ -352,6 +354,9 @@ space first; changes blocks adapt within the remaining history width.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
+- While active, the footer renders a bold `e active (` marker and only the edit
+  actions available for the current selection, followed by `)`. An empty group
+  says `no actions`.
 - While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
   meanings for dates, emails, references, and trailers.
 
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 1d37922467c..28132fcada8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -658,9 +658,9 @@ pub(crate) fn draw_with_worktree(
                         .iter()
                         .any(|decoration| decoration.kind == DecorationKind::Pin)
                     {
-                        " · t return"
+                        "t return"
                     } else {
-                        " · t travel"
+                        "t travel"
                     },
                 )
             } else {
@@ -670,22 +670,39 @@ pub(crate) fn draw_with_worktree(
             None
         };
         if app.edit_expanded {
-            if let Some(label) = time_travel {
-                footer_spans.push(Span::raw(label));
-            }
+            let mut options = Vec::new();
             if app.reword_shortcut_visible() {
-                footer_spans.push(Span::raw(" · r reword"));
+                options.push("r reword");
             }
             if app.can_create_commit() {
-                footer_spans.push(Span::raw(" · n new"));
+                options.push("n new");
             }
             if app.can_forget() {
-                footer_spans.push(Span::raw(if app.forget_confirmation_visible() {
-                    " · d again forget"
+                options.push(if app.forget_confirmation_visible() {
+                    "d again forget"
                 } else {
-                    " · d forget"
-                }));
+                    "d forget"
+                });
+            }
+            if let Some(label) = time_travel {
+                options.push(label);
+            }
+            footer_spans.push(Span::raw(" · "));
+            footer_spans.push(Span::styled(
+                "e active (",
+                Style::default().add_modifier(Modifier::BOLD),
+            ));
+            if options.is_empty() {
+                footer_spans.push(Span::raw("no actions"));
+            } else {
+                for (index, option) in options.into_iter().enumerate() {
+                    if index > 0 {
+                        footer_spans.push(Span::raw(" · "));
+                    }
+                    footer_spans.push(Span::raw(option));
+                }
             }
+            footer_spans.push(Span::raw(")"));
         } else if !app.history_display_expanded {
             footer_spans.push(Span::raw(" · e edit"));
         }
@@ -703,7 +720,12 @@ pub(crate) fn draw_with_worktree(
     footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
     footer_spans.extend([Span::raw(" · "), toggle("c changes", app.changes_mode.is_some())]);
     if app.history_display_expanded {
-        footer_spans.extend([Span::raw(" · "), toggle("d date", app.show_committer_date)]);
+        footer_spans.push(Span::raw(" · "));
+        footer_spans.push(Span::styled(
+            "v active (",
+            Style::default().add_modifier(Modifier::BOLD),
+        ));
+        footer_spans.push(toggle("d date", app.show_committer_date));
         footer_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
         let (name_label, names_visible) = match app.name_mode {
             NameMode::All => ("n names", true),
@@ -733,6 +755,7 @@ pub(crate) fn draw_with_worktree(
                 ),
             ]);
         }
+        footer_spans.push(Span::raw(")"));
     } else {
         footer_spans.push(Span::raw(" · v view"));
     }
@@ -2502,7 +2525,10 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
-        assert!(rendered_line(&terminal, 1).contains("t return"));
+        assert!(
+            rendered_line(&terminal, 1).contains("e active (r reword · n new · d forget · t return)"),
+            "the active edit prefix contains exactly its actionable commands"
+        );
         assert!(!rendered_line(&terminal, 1).contains("e edit"));
 
         decorations.remove(&selected);
@@ -2511,6 +2537,42 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn visually_groups_active_prefix_options() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.changes_mode = None;
+        app.configure_hidden_filter(true);
+        app.history_display_expanded = true;
+        let mut terminal = Terminal::new(TestBackend::new(180, 2))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let footer = rendered_line(&terminal, 1);
+        let view = "v active (d date · e emails · n names · m mailmap · t trailers · r no refs · h show hidden)";
+        assert!(
+            footer.contains(view),
+            "the view prefix encloses all of its applicable options"
+        );
+        let active = footer[..footer.find("v active").expect("the active view prefix is visible")]
+            .chars()
+            .count() as u16;
+        assert!(
+            terminal.backend().buffer()[(active, 1)]
+                .modifier
+                .contains(Modifier::BOLD),
+            "the active prefix label is emphasized"
+        );
+
+        app.history_display_expanded = false;
+        app.edit_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 1).contains("e active (no actions)"),
+            "an active prefix remains explicit when the current context offers no actions"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_worktree_labels_and_keeps_them_selected_when_refs_are_hidden() -> Result<(), Box<dyn std::error::Error>>
     {

From 23c2801c0b7fee47f8d989e351f746e1d213a705 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 10:15:07 +0200
Subject: [PATCH 059/282] feat: standardize transient tix messages

Make App own the single path for global user feedback instead of allowing event-loop and rendering code to write its footer notice storage directly. Global command results and worktree-disappearance recovery now use `leave_message()`, while pane-specific errors stay with their panes and the next recognized action clears the message centrally.

Explain an unchanged new-commit editor with `no commit created: no input was provided` instead of silently returning to history. Preserve empty edited messages as errors because those represent invalid supplied input.

Document the transient-message lifetime and cover footer replacement, the no-input text, and clearing on the next action.
---
 gix-tix/spec.md    |  5 +++++
 gix-tix/src/app.rs | 14 +++++++++++---
 gix-tix/src/lib.rs | 24 ++++++++++++------------
 gix-tix/src/ui.rs  | 16 ++++++++++++----
 4 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 085227352de..659fc22932b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -423,6 +423,11 @@ space first; changes blocks adapt within the remaining history width.
 - Main status remains readable regardless of pane focus. Errors are surfaced in
   the nearest relevant status line; diagnostics never replace user-visible
   errors.
+- Global command and recovery feedback uses one transient message channel. A
+  message replaces the main status line until the next recognized user action;
+  pane-specific errors remain in their pane status line.
+- Closing the new-commit editor without changing its prepared buffer leaves the
+  repository untouched and reports `no commit created: no input was provided`.
 
 ## Regression coverage
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ae19edf7f16..c7036ccf936 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -364,7 +364,7 @@ pub(crate) struct App {
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
-    pub(crate) notice: Option<String>,
+    message: Option<String>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) edit_expanded: bool,
@@ -438,7 +438,7 @@ impl App {
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
-            notice: None,
+            message: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             edit_expanded: false,
@@ -462,6 +462,14 @@ impl App {
         }
     }
 
+    pub(crate) fn leave_message(&mut self, message: impl Into<String>) {
+        self.message = Some(message.into());
+    }
+
+    pub(crate) fn message(&self) -> Option<&str> {
+        self.message.as_deref()
+    }
+
     pub(crate) fn configure_hidden_filter(&mut self, present: bool) {
         self.has_hidden_filter = present;
         if present {
@@ -647,7 +655,7 @@ impl App {
     }
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
-        self.notice = None;
+        self.message = None;
         if !matches!(&action, Action::Forget) {
             self.forget_confirmation = None;
         }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index e8c6f258021..b50b73039d9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -890,7 +890,7 @@ fn event_loop(
     app.set_worktree_head_unborn(worktree_head_unborn);
     app.commit_pane_background = commit_pane_background;
     if recovered_at_startup {
-        app.notice = Some("worktree removed; using the common repository without worktree changes".into());
+        app.leave_message("worktree removed; using the common repository without worktree changes");
     }
     app.manual_refresh = ref_watcher.is_none();
     let mut lane_receiver = None;
@@ -1000,7 +1000,7 @@ fn event_loop(
             };
             ref_watch_set_changed = false;
             app.manual_refresh = ref_watcher.is_none();
-            app.notice = Some("worktree removed; using the common repository without worktree changes".into());
+            app.leave_message("worktree removed; using the common repository without worktree changes");
             if history_graph.is_some() {
                 refresh_pending = true;
                 refresh_from_filesystem = true;
@@ -1684,14 +1684,14 @@ fn event_loop(
                         .and_then(|diff| show_commit_diff(terminal, diff, enhanced_keyboard));
                     match result {
                         Ok(true) => app.focus_history(),
-                        Err(err) => app.notice = Some(format!("diff: {err:#}")),
+                        Err(err) => app.leave_message(format!("diff: {err:#}")),
                         Ok(false) => {}
                     }
                 }
                 Effect::Reword(id) => {
                     match reword_commit(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
                         Ok(Some(new_id)) => {
-                            app.notice = Some(format!(
+                            app.leave_message(format!(
                                 "reworded {} as {}",
                                 id.to_hex_with_len(7),
                                 new_id.to_hex_with_len(7)
@@ -1700,7 +1700,7 @@ fn event_loop(
                             refresh_pending = true;
                         }
                         Ok(None) => {}
-                        Err(err) => app.notice = Some(format!("reword: {err:#}")),
+                        Err(err) => app.leave_message(format!("reword: {err:#}")),
                     }
                 }
                 Effect::NewCommit(parent) => {
@@ -1712,12 +1712,12 @@ fn event_loop(
                         enhanced_keyboard,
                     ) {
                         Ok(Some(new_id)) => {
-                            app.notice = Some(format!("created {}", new_id.to_hex_with_len(7)));
+                            app.leave_message(format!("created {}", new_id.to_hex_with_len(7)));
                             refresh_select_top_requested = true;
                             refresh_pending = true;
                         }
-                        Ok(None) => {}
-                        Err(err) => app.notice = Some(format!("new commit: {err:#}")),
+                        Ok(None) => app.leave_message("no commit created: no input was provided"),
+                        Err(err) => app.leave_message(format!("new commit: {err:#}")),
                     }
                 }
                 Effect::Forget(id) => {
@@ -1725,14 +1725,14 @@ fn event_loop(
                     fill_repository.retained = None;
                     match forget_commit(&repository_path, repository_is_bare, id) {
                         Ok(parent) => {
-                            app.notice = Some(format!("forgot {}", id.to_hex_with_len(7)));
+                            app.leave_message(format!("forgot {}", id.to_hex_with_len(7)));
                             if let Some(parent) = parent {
                                 app.select_commit(parent);
                             }
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Err(err) => app.notice = Some(format!("forget: {err:#}")),
+                        Err(err) => app.leave_message(format!("forget: {err:#}")),
                     }
                 }
                 Effect::TimeTravel(id) => {
@@ -1754,12 +1754,12 @@ fn event_loop(
                     match result {
                         Ok(Some(notice)) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
-                            app.notice = Some(notice);
+                            app.leave_message(notice);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
                         Ok(None) => {}
-                        Err(err) => app.notice = Some(format!("time-travel: {err:#}")),
+                        Err(err) => app.leave_message(format!("time-travel: {err:#}")),
                     }
                 }
                 Effect::VerifySignatures(ids) => {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 28132fcada8..ed40927ac89 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -789,8 +789,8 @@ pub(crate) fn draw_with_worktree(
         }
         footer_spans.push(Span::raw(" · q quit"));
     }
-    if let Some(notice) = &app.notice {
-        footer_spans = vec![Span::raw(notice)];
+    if let Some(message) = app.message() {
+        footer_spans = vec![Span::raw(message)];
     }
     if app.unseen_filesystem_redraw {
         footer_spans = notification_discs(footer_spans);
@@ -2362,7 +2362,7 @@ mod tests {
         );
         app.unseen_filesystem_redraw = false;
 
-        app.notice = Some("worktree removed; using common repository".into());
+        app.leave_message("worktree removed; using common repository");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert_eq!(
             rendered_line(&terminal, 1).trim(),
@@ -2372,13 +2372,21 @@ mod tests {
 
         app.history_display_expanded = true;
         app.update(Action::ToggleMailmap);
-        assert!(app.notice.is_none(), "the next action restores the normal status");
+        assert!(app.message().is_none(), "the next action restores the normal status");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains(" author subject"),
             "m restores the original author name"
         );
         assert!(footer_is_dim(&terminal, "m mailmap"), "disabled mailmap is dimmed");
+
+        app.leave_message("no commit created: no input was provided");
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
+        assert_eq!(
+            rendered_line(&terminal, 1).trim(),
+            "no commit created: no input was provided",
+            "an unchanged new-commit editor explains why nothing happened"
+        );
         app.update(Action::ToggleMailmap);
 
         app.update(Action::ToggleDate);

From 60d8bb430c1a60a6806bc005705f27815a9c43a3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 10:18:38 +0200
Subject: [PATCH 060/282] feat: prioritize tix prefixes in history status

Place the view prefix immediately after the history position and the edit prefix immediately after it, before navigation and other direct shortcuts. Keep active prefix groups in the same priority position so their available commands remain visible on narrow terminals.

Do not advertise the edit prefix while the view prefix is active because `e` then toggles email display. Preserve all key handling and contextual availability semantics.

Update the behavioral specification and footer regressions for inactive, active, deferred-progress, and narrow-history layouts.
---
 gix-tix/spec.md   |  3 ++-
 gix-tix/src/ui.rs | 63 ++++++++++++++++++++++++++---------------------
 2 files changed, 37 insertions(+), 29 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 659fc22932b..77b473a361d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -157,7 +157,8 @@ The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. `[` and overlay controls remain direct
 shortcuts. While active, the footer renders a bold `v active (` marker, every
 applicable display option, and a closing `)` so direct shortcuts remain visibly
-outside the prefix.
+outside the prefix. The history status starts with the history position, then the
+`v` prefix and the `e` prefix when it is addressable, before navigation shortcuts.
 
 ### Time-travel
 
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index ed40927ac89..e054264fbdb 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -635,10 +635,8 @@ pub(crate) fn draw_with_worktree(
         State::Complete => "",
         State::Cancelled => " · cancelled",
     };
-    let mut footer_spans = vec![Span::raw(format!(
-        "{}{status} · ↑↓/jk move · h/l pan",
-        history_position(app)
-    ))];
+    let mut footer_spans = vec![Span::raw(format!("{status} · ↑↓/jk move · h/l pan"))];
+    let mut edit_prefix_spans = Vec::new();
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · Enter diff"));
         let time_travel = if app.time_travel_shortcut_visible()
@@ -687,24 +685,24 @@ pub(crate) fn draw_with_worktree(
             if let Some(label) = time_travel {
                 options.push(label);
             }
-            footer_spans.push(Span::raw(" · "));
-            footer_spans.push(Span::styled(
+            edit_prefix_spans.push(Span::raw(" · "));
+            edit_prefix_spans.push(Span::styled(
                 "e active (",
                 Style::default().add_modifier(Modifier::BOLD),
             ));
             if options.is_empty() {
-                footer_spans.push(Span::raw("no actions"));
+                edit_prefix_spans.push(Span::raw("no actions"));
             } else {
                 for (index, option) in options.into_iter().enumerate() {
                     if index > 0 {
-                        footer_spans.push(Span::raw(" · "));
+                        edit_prefix_spans.push(Span::raw(" · "));
                     }
-                    footer_spans.push(Span::raw(option));
+                    edit_prefix_spans.push(Span::raw(option));
                 }
             }
-            footer_spans.push(Span::raw(")"));
+            edit_prefix_spans.push(Span::raw(")"));
         } else if !app.history_display_expanded {
-            footer_spans.push(Span::raw(" · e edit"));
+            edit_prefix_spans.push(Span::raw(" · e edit"));
         }
     }
     if app.tree_changes_visible || app.worktree_changes_visible {
@@ -719,31 +717,32 @@ pub(crate) fn draw_with_worktree(
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
     footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
     footer_spans.extend([Span::raw(" · "), toggle("c changes", app.changes_mode.is_some())]);
+    let mut view_prefix_spans = Vec::new();
     if app.history_display_expanded {
-        footer_spans.push(Span::raw(" · "));
-        footer_spans.push(Span::styled(
+        view_prefix_spans.push(Span::raw(" · "));
+        view_prefix_spans.push(Span::styled(
             "v active (",
             Style::default().add_modifier(Modifier::BOLD),
         ));
-        footer_spans.push(toggle("d date", app.show_committer_date));
-        footer_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
+        view_prefix_spans.push(toggle("d date", app.show_committer_date));
+        view_prefix_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
         let (name_label, names_visible) = match app.name_mode {
             NameMode::All => ("n names", true),
             NameMode::Author => ("n name", true),
             NameMode::None => ("n name", false),
         };
-        footer_spans.extend([Span::raw(" · "), toggle(name_label, names_visible)]);
+        view_prefix_spans.extend([Span::raw(" · "), toggle(name_label, names_visible)]);
         for (label, enabled) in [("m mailmap", app.use_mailmap), ("t trailers", app.show_trailers)] {
-            footer_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
+            view_prefix_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
         }
         let ref_label = match app.ref_mode {
             RefMode::All => "r all refs",
             RefMode::Default => "r refs",
             RefMode::None => "r no refs",
         };
-        footer_spans.extend([Span::raw(" · "), toggle(ref_label, app.ref_mode != RefMode::None)]);
+        view_prefix_spans.extend([Span::raw(" · "), toggle(ref_label, app.ref_mode != RefMode::None)]);
         if app.has_hidden_filter {
-            footer_spans.extend([
+            view_prefix_spans.extend([
                 Span::raw(" · "),
                 toggle(
                     if app.show_hidden {
@@ -755,10 +754,15 @@ pub(crate) fn draw_with_worktree(
                 ),
             ]);
         }
-        footer_spans.push(Span::raw(")"));
+        view_prefix_spans.push(Span::raw(")"));
     } else {
-        footer_spans.push(Span::raw(" · v view"));
+        view_prefix_spans.push(Span::raw(" · v view"));
     }
+    let mut ordered = vec![Span::raw(history_position(app))];
+    ordered.append(&mut view_prefix_spans);
+    ordered.append(&mut edit_prefix_spans);
+    ordered.append(&mut footer_spans);
+    footer_spans = ordered;
     if app.preview_author_copy && app.manual_refresh {
         footer_spans.extend([
             Span::raw(" · "),
@@ -1801,7 +1805,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · computing"),
+            computing.contains("1 commits · v view · e edit · computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -2287,7 +2291,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · ↑↓/jk move · h/l pan · Enter diff · e edit · [ align · o commit · c changes · v view · y copy · q quit";
+        let footer_text = "#1 · v view · e edit · ↑↓/jk move · h/l pan · Enter diff · [ align · o commit · c changes · y copy · q quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2558,8 +2562,8 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "v active (d date · e emails · n names · m mailmap · t trailers · r no refs · h show hidden)";
         assert!(
-            footer.contains(view),
-            "the view prefix encloses all of its applicable options"
+            footer.starts_with(&format!("0 commits · {view} · ↑↓/jk move")),
+            "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("v active").expect("the active view prefix is visible")]
             .chars()
@@ -2575,8 +2579,8 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).contains("e active (no actions)"),
-            "an active prefix remains explicit when the current context offers no actions"
+            rendered_line(&terminal, 1).starts_with("0 commits · v view · e active (no actions) · ↑↓/jk move"),
+            "the edit prefix follows the view prefix even when no action is available"
         );
         Ok(())
     }
@@ -4390,7 +4394,10 @@ mod tests {
             !rendered_row(&terminal).contains("0101010"),
             "[ restores natural post-graph placement"
         );
-        assert!(footer_is_dim(&terminal, "[ align"), "disabled alignment is dimmed");
+        assert!(
+            !app.align_metadata,
+            "alignment is disabled even when its later footer hint is clipped"
+        );
 
         app.update(Action::ScrollRight);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;

From 03b8f8f41355b5e3f7ac453de3a6941d5d06951a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 10:26:48 +0200
Subject: [PATCH 061/282] feat: streamline tix status shortcuts

Replace redundant prefix-key-plus-verb labels with compact action labels whose shortcut characters are underlined. Apply the convention consistently to the history footer, expanded view and edit groups, changes blocks, and commit-message status, while keeping navigation chords and other keys explicit when they cannot be embedded naturally.

Order the history footer as position, display and edit groups, top-level viewport actions, and finally navigation. Name the commit-message viewport toggle open message or close message so it cannot be confused with creating a commit in the edit group.

Show active prefix choices directly in parentheses, making the former active suffix unnecessary. Render the Enter key consistently as <enter> throughout history, changes, and diff status bars. Update the behavioral specification and terminal-buffer assertions to cover the labels, styling, ordering, and disabled state.
---
 gix-tix/spec.md   |  14 ++-
 gix-tix/src/ui.rs | 277 +++++++++++++++++++++++++++++-----------------
 2 files changed, 185 insertions(+), 106 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 77b473a361d..ad99cffce97 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -155,10 +155,14 @@ without trading responsiveness for metadata that is not visible.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. `[` and overlay controls remain direct
-shortcuts. While active, the footer renders a bold `v active (` marker, every
-applicable display option, and a closing `)` so direct shortcuts remain visibly
+shortcuts. The footer underlines the `v` in `view`; while active, `view (` contains
+every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
-`v` prefix and the `e` prefix when it is addressable, before navigation shortcuts.
+`v` prefix and the `e` prefix when it is addressable. Remaining history-level
+actions follow before movement, panning, and diff navigation shortcuts.
+All status lines embed and underline a shortcut character in its action label when
+possible; keys that cannot be expressed naturally in the label remain explicit.
+The Enter key is written as `<enter>` throughout.
 
 ### Time-travel
 
@@ -209,6 +213,8 @@ space first; changes blocks adapt within the remaining history width.
 
 - `o` or `]` toggles the commit view on the right. It uses at most half the
   terminal and reserves 80 content columns when space permits.
+- Its history-status action says `open message` or `close message`, avoiding
+  confusion with the edit group's commit-creation action.
 - The panel has a minimally shaded background derived from the detected terminal
   background, with the default background as fallback.
 - The title begins on the first content row and is bold. Body text follows, then
@@ -355,7 +361,7 @@ space first; changes blocks adapt within the remaining history width.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
-- While active, the footer renders a bold `e active (` marker and only the edit
+- The footer underlines the `e` in `edit`; while active, `edit (` contains only the
   actions available for the current selection, followed by `)`. An empty group
   says `no actions`.
 - While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index e054264fbdb..d6f831e8e85 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -173,7 +173,7 @@ pub(crate) fn draw_file_diff(frame: &mut Frame<'_>, diff: &BuiltInDiff, offset:
         body,
     );
     frame.render_widget(
-        Paragraph::new("↑↓/jk move · h/l pan · Enter/q/Esc back").style(Style::default().add_modifier(Modifier::DIM)),
+        Paragraph::new("↑↓/jk move · h/l pan · <enter>/q/Esc back").style(Style::default().add_modifier(Modifier::DIM)),
         footer,
     );
 }
@@ -568,20 +568,26 @@ pub(crate) fn draw_with_worktree(
                         ),
                         color(COMPARED_PARENT_COLOR),
                     ),
-                    Span::raw(" · p next parent · "),
+                    Span::raw(" · "),
                 ]);
+                spans.extend(shortcut("next parent", 'p', true));
+                spans.push(Span::raw(" · "));
             }
             if let Some(error) = &app.changes(pane).error {
                 spans.push(Span::styled(format!("diff: {error}"), color(Color::LightRed)));
             } else {
-                spans.push(Span::raw("↑↓/jk move · h/l pan · Enter diff"));
+                spans.push(Span::raw("↑↓/jk move · h/l pan · <enter> diff"));
+            }
+            spans.push(Span::raw(" · "));
+            spans.extend(shortcut("copy", 'y', true));
+            if let Some(label) = match app.changes_mode {
+                Some(ChangesMode::Both) => Some("cycle tree"),
+                Some(ChangesMode::Tree) => Some("close"),
+                None => None,
+            } {
+                spans.push(Span::raw(" · "));
+                spans.extend(shortcut(label, 'c', true));
             }
-            spans.push(Span::raw(" · y copy"));
-            spans.push(Span::raw(match app.changes_mode {
-                Some(ChangesMode::Both) => " · c tree",
-                Some(ChangesMode::Tree) => " · c to hide",
-                None => "",
-            }));
             frame.render_widget(
                 Paragraph::new(Line::from(spans)).style(Style::default().bg(PANE_STATUS_BACKGROUND)),
                 status,
@@ -615,8 +621,13 @@ pub(crate) fn draw_with_worktree(
         app.set_commit_bounds(area.height as usize, max_offset);
         if max_offset > 0 {
             frame.render_widget(
-                Paragraph::new("PgUp/C-b up page · PgDn/C-f down page · o to hide")
-                    .style(Style::default().bg(PANE_STATUS_BACKGROUND)),
+                Paragraph::new(Line::from(vec![
+                    Span::raw("PgUp/C-b up page · PgDn/C-f down page · "),
+                    Span::raw("cl"),
+                    Span::styled("o", Style::default().add_modifier(Modifier::UNDERLINED)),
+                    Span::raw("se"),
+                ]))
+                .style(Style::default().bg(PANE_STATUS_BACKGROUND)),
                 Rect::new(
                     outer.x.saturating_add(2),
                     outer.bottom().saturating_sub(1),
@@ -635,10 +646,9 @@ pub(crate) fn draw_with_worktree(
         State::Complete => "",
         State::Cancelled => " · cancelled",
     };
-    let mut footer_spans = vec![Span::raw(format!("{status} · ↑↓/jk move · h/l pan"))];
+    let mut footer_spans = vec![Span::raw(status)];
     let mut edit_prefix_spans = Vec::new();
     if app.changes_focus.is_none() {
-        footer_spans.push(Span::raw(" · Enter diff"));
         let time_travel = if app.time_travel_shortcut_visible()
             && decorations
                 .values()
@@ -656,9 +666,9 @@ pub(crate) fn draw_with_worktree(
                         .iter()
                         .any(|decoration| decoration.kind == DecorationKind::Pin)
                     {
-                        "t return"
+                        ("return", 't')
                     } else {
-                        "t travel"
+                        ("travel", 't')
                     },
                 )
             } else {
@@ -670,39 +680,39 @@ pub(crate) fn draw_with_worktree(
         if app.edit_expanded {
             let mut options = Vec::new();
             if app.reword_shortcut_visible() {
-                options.push("r reword");
+                options.push(("reword", 'r'));
             }
             if app.can_create_commit() {
-                options.push("n new");
+                options.push(("new", 'n'));
             }
             if app.can_forget() {
                 options.push(if app.forget_confirmation_visible() {
-                    "d again forget"
+                    ("d again forget", 'd')
                 } else {
-                    "d forget"
+                    ("d forget", 'd')
                 });
             }
             if let Some(label) = time_travel {
                 options.push(label);
             }
             edit_prefix_spans.push(Span::raw(" · "));
-            edit_prefix_spans.push(Span::styled(
-                "e active (",
-                Style::default().add_modifier(Modifier::BOLD),
-            ));
+            edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
+            edit_prefix_spans.push(Span::raw("dit ("));
             if options.is_empty() {
                 edit_prefix_spans.push(Span::raw("no actions"));
             } else {
-                for (index, option) in options.into_iter().enumerate() {
+                for (index, (label, key)) in options.into_iter().enumerate() {
                     if index > 0 {
                         edit_prefix_spans.push(Span::raw(" · "));
                     }
-                    edit_prefix_spans.push(Span::raw(option));
+                    edit_prefix_spans.extend(shortcut(label, key, true));
                 }
             }
             edit_prefix_spans.push(Span::raw(")"));
         } else if !app.history_display_expanded {
-            edit_prefix_spans.push(Span::raw(" · e edit"));
+            edit_prefix_spans.push(Span::raw(" · "));
+            edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
+            edit_prefix_spans.push(Span::raw("dit"));
         }
     }
     if app.tree_changes_visible || app.worktree_changes_visible {
@@ -715,48 +725,57 @@ pub(crate) fn draw_with_worktree(
         footer_spans.push(Span::raw(" · q/Esc history"));
     }
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
-    footer_spans.extend([Span::raw(" · "), toggle("o commit", app.show_commit)]);
-    footer_spans.extend([Span::raw(" · "), toggle("c changes", app.changes_mode.is_some())]);
+    footer_spans.push(Span::raw(" · "));
+    footer_spans.extend(shortcut(
+        if app.show_commit {
+            "close message"
+        } else {
+            "open message"
+        },
+        'o',
+        app.show_commit,
+    ));
+    footer_spans.push(Span::raw(" · "));
+    footer_spans.extend(shortcut("cycle changes", 'c', app.changes_mode.is_some()));
     let mut view_prefix_spans = Vec::new();
     if app.history_display_expanded {
         view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.push(Span::styled(
-            "v active (",
-            Style::default().add_modifier(Modifier::BOLD),
-        ));
-        view_prefix_spans.push(toggle("d date", app.show_committer_date));
-        view_prefix_spans.extend([Span::raw(" · "), toggle("e emails", app.show_emails)]);
+        view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
+        view_prefix_spans.push(Span::raw("iew ("));
+        view_prefix_spans.extend(shortcut("date", 'd', app.show_committer_date));
+        view_prefix_spans.push(Span::raw(" · "));
+        view_prefix_spans.extend(shortcut("emails", 'e', app.show_emails));
         let (name_label, names_visible) = match app.name_mode {
-            NameMode::All => ("n names", true),
-            NameMode::Author => ("n name", true),
-            NameMode::None => ("n name", false),
+            NameMode::All => ("names", true),
+            NameMode::Author => ("name", true),
+            NameMode::None => ("name", false),
         };
-        view_prefix_spans.extend([Span::raw(" · "), toggle(name_label, names_visible)]);
-        for (label, enabled) in [("m mailmap", app.use_mailmap), ("t trailers", app.show_trailers)] {
-            view_prefix_spans.extend([Span::raw(" · "), toggle(label, enabled)]);
+        view_prefix_spans.push(Span::raw(" · "));
+        view_prefix_spans.extend(shortcut(name_label, 'n', names_visible));
+        for (label, key, enabled) in [("mailmap", 'm', app.use_mailmap), ("trailers", 't', app.show_trailers)] {
+            view_prefix_spans.push(Span::raw(" · "));
+            view_prefix_spans.extend(shortcut(label, key, enabled));
         }
         let ref_label = match app.ref_mode {
-            RefMode::All => "r all refs",
-            RefMode::Default => "r refs",
-            RefMode::None => "r no refs",
+            RefMode::All => "all refs",
+            RefMode::Default => "refs",
+            RefMode::None => "no refs",
         };
-        view_prefix_spans.extend([Span::raw(" · "), toggle(ref_label, app.ref_mode != RefMode::None)]);
+        view_prefix_spans.push(Span::raw(" · "));
+        view_prefix_spans.extend(shortcut(ref_label, 'r', app.ref_mode != RefMode::None));
         if app.has_hidden_filter {
-            view_prefix_spans.extend([
-                Span::raw(" · "),
-                toggle(
-                    if app.show_hidden {
-                        "h hide hidden"
-                    } else {
-                        "h show hidden"
-                    },
-                    app.show_hidden,
-                ),
-            ]);
+            view_prefix_spans.push(Span::raw(" · "));
+            view_prefix_spans.extend(shortcut(
+                if app.show_hidden { "hide hidden" } else { "show hidden" },
+                'h',
+                app.show_hidden,
+            ));
         }
         view_prefix_spans.push(Span::raw(")"));
     } else {
-        view_prefix_spans.push(Span::raw(" · v view"));
+        view_prefix_spans.push(Span::raw(" · "));
+        view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
+        view_prefix_spans.push(Span::raw("iew"));
     }
     let mut ordered = vec![Span::raw(history_position(app))];
     ordered.append(&mut view_prefix_spans);
@@ -764,16 +783,19 @@ pub(crate) fn draw_with_worktree(
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
     if app.preview_author_copy && app.manual_refresh {
-        footer_spans.extend([
-            Span::raw(" · "),
-            toggle("R refresh", matches!(history_state, State::Complete | State::Cancelled)),
-        ]);
+        footer_spans.push(Span::raw(" · "));
+        footer_spans.extend(shortcut(
+            "Refresh",
+            'R',
+            matches!(history_state, State::Complete | State::Cancelled),
+        ));
     }
-    footer_spans.push(Span::raw(if app.preview_author_copy {
-        " · Y copy author"
+    footer_spans.push(Span::raw(" · "));
+    footer_spans.extend(if app.preview_author_copy {
+        shortcut("copY author", 'Y', true)
     } else {
-        " · y copy"
-    }));
+        shortcut("copy", 'y', true)
+    });
     if app.signature_failures > 0 {
         footer_spans.extend([
             Span::raw(format!(" · s {} ", app.signature_failures)),
@@ -791,7 +813,12 @@ pub(crate) fn draw_with_worktree(
         if history_state == State::Loading {
             footer_spans.push(Span::raw(" · Esc cancel"));
         }
-        footer_spans.push(Span::raw(" · q quit"));
+        footer_spans.push(Span::raw(" · "));
+        footer_spans.extend(shortcut("quit", 'q', true));
+    }
+    footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
+    if app.changes_focus.is_none() {
+        footer_spans.push(Span::raw(" · <enter> diff"));
     }
     if let Some(message) = app.message() {
         footer_spans = vec![Span::raw(message)];
@@ -1407,6 +1434,21 @@ fn toggle(label: &'static str, enabled: bool) -> Span<'static> {
     )
 }
 
+fn shortcut(label: &'static str, key: char, enabled: bool) -> Vec<Span<'static>> {
+    let key_start = label.find(key).expect("shortcut key is present in its label");
+    let key_end = key_start + key.len_utf8();
+    let style = if enabled {
+        Style::default()
+    } else {
+        Style::default().add_modifier(Modifier::DIM)
+    };
+    vec![
+        Span::styled(&label[..key_start], style),
+        Span::styled(&label[key_start..key_end], style.add_modifier(Modifier::UNDERLINED)),
+        Span::styled(&label[key_end..], style),
+    ]
+}
+
 fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
     let mut out = Vec::with_capacity(spans.len());
     for span in spans {
@@ -1739,6 +1781,14 @@ mod tests {
         app.finish_lane_computation(rows, lanes, lane_time);
     }
 
+    #[test]
+    fn embeds_status_shortcuts_in_their_labels() {
+        let spans = shortcut("copy", 'y', false);
+        assert_eq!(Line::from(spans.clone()).to_string(), "copy");
+        assert!(spans[1].style.add_modifier.contains(Modifier::UNDERLINED));
+        assert!(spans[1].style.add_modifier.contains(Modifier::DIM));
+    }
+
     #[test]
     fn counts_commits_until_the_graph_is_complete_then_tracks_the_selected_row() {
         let mut app = App::new(3);
@@ -1805,7 +1855,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · v view · e edit · computing"),
+            computing.contains("1 commits · view · edit · computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -1932,7 +1982,7 @@ mod tests {
                 .map(Into::into)
                 .collect(),
         );
-        let mut terminal = Terminal::new(TestBackend::new(40, 7))?;
+        let mut terminal = Terminal::new(TestBackend::new(48, 7))?;
 
         terminal.draw(|frame| draw_file_diff(frame, &diff, 0, 0))?;
 
@@ -1946,7 +1996,7 @@ mod tests {
         ] {
             assert_eq!(terminal.backend().buffer()[(0, y)].fg, color);
         }
-        assert!(rendered_line(&terminal, 6).contains("Enter/q/Esc back"));
+        assert!(rendered_line(&terminal, 6).contains("<enter>/q/Esc back"));
         Ok(())
     }
 
@@ -2119,7 +2169,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
         assert!(
-            !rendered_line(&terminal, 1).contains("e edit"),
+            !rendered_line(&terminal, 1).contains(" · edit ·"),
             "the view group keeps e reserved for toggling emails"
         );
 
@@ -2147,7 +2197,7 @@ mod tests {
         assert_eq!(style_at("Human"), Color::Green, "human trailer actors are green");
         assert_eq!(style_at("[Claude]"), Color::Green, "bot co-authors use agent styling");
         assert!(
-            rendered_line(&terminal, 1).contains("t trailers"),
+            rendered_line(&terminal, 1).contains("trailers"),
             "the footer advertises the trailer toggle"
         );
 
@@ -2291,7 +2341,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · v view · e edit · ↑↓/jk move · h/l pan · Enter diff · [ align · o commit · c changes · y copy · q quit";
+        let footer_text = "#1 · view · edit · [ align · open message · cycle changes · copy · quit · ↑↓/jk move · h/l pan · <enter> diff";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2315,12 +2365,30 @@ mod tests {
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
-        let commit = footer_text[..footer_text.find("o commit").expect("the commit toggle is present")]
+        let message = footer_text[..footer_text.find("open message").expect("the message toggle is present")]
             .chars()
             .count();
-        for x in commit..commit + "o commit".len() {
+        for x in message..message + "open message".len() {
             expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
         }
+        for (label, key) in [
+            ("view", 'v'),
+            ("edit", 'e'),
+            ("open message", 'o'),
+            ("cycle changes", 'c'),
+            ("copy", 'y'),
+            ("quit", 'q'),
+        ] {
+            let label_start = footer_text[..footer_text.find(label).expect("shortcut label is present")]
+                .chars()
+                .count();
+            let key_offset = label[..label.find(key).expect("shortcut key is in its label")]
+                .chars()
+                .count();
+            expected[((label_start + key_offset) as u16, 1)]
+                .modifier
+                .insert(Modifier::UNDERLINED);
+        }
         terminal.backend().assert_buffer(&expected);
 
         let row = terminal.backend().buffer();
@@ -2382,7 +2450,7 @@ mod tests {
             rendered_row(&terminal).contains(" author subject"),
             "m restores the original author name"
         );
-        assert!(footer_is_dim(&terminal, "m mailmap"), "disabled mailmap is dimmed");
+        assert!(footer_is_dim(&terminal, "mailmap"), "disabled mailmap is dimmed");
 
         app.leave_message("no commit created: no input was provided");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -2404,8 +2472,8 @@ mod tests {
         );
         assert!(!row.contains("refs/patches"), "special refs are hidden until requested");
         assert!(row.contains("subject"), "the commit subject remains visible");
-        assert!(footer_is_dim(&terminal, "d date"), "disabled date is dimmed");
-        assert!(footer_is_dim(&terminal, "n name"), "disabled name is dimmed");
+        assert!(footer_is_dim(&terminal, "date"), "disabled date is dimmed");
+        assert!(footer_is_dim(&terminal, "name"), "disabled name is dimmed");
 
         app.update(Action::ToggleName);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -2414,7 +2482,7 @@ mod tests {
             "the second n restores the author name"
         );
         assert!(
-            !footer_is_dim(&terminal, "n name"),
+            !footer_is_dim(&terminal, "name"),
             "the restored name mode is not dimmed"
         );
 
@@ -2429,7 +2497,7 @@ mod tests {
             !rendered_row(&terminal).contains("refs/patches"),
             "no refs hides special refs"
         );
-        assert!(footer_is_dim(&terminal, "r no refs"), "no refs is dimmed");
+        assert!(footer_is_dim(&terminal, "no refs"), "no refs is dimmed");
 
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -2441,7 +2509,7 @@ mod tests {
             rendered_row(&terminal).contains("refs/patches"),
             "all refs shows special refs"
         );
-        assert!(!footer_is_dim(&terminal, "r all refs"), "all refs is not dimmed");
+        assert!(!footer_is_dim(&terminal, "all refs"), "all refs is not dimmed");
 
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -2453,18 +2521,18 @@ mod tests {
             !rendered_row(&terminal).contains("refs/patches"),
             "refs hides special refs"
         );
-        assert!(!footer_is_dim(&terminal, "r refs"), "refs is not dimmed");
+        assert!(!footer_is_dim(&terminal, "refs"), "refs is not dimmed");
 
         app.has_hidden_filter = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
-            rendered_line(&terminal, 1).contains("h show hidden"),
+            rendered_line(&terminal, 1).contains("show hidden"),
             "the footer advertises the configured hidden-history toggle"
         );
         app.show_hidden = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
-            rendered_line(&terminal, 1).contains("h hide hidden"),
+            rendered_line(&terminal, 1).contains("hide hidden"),
             "the footer reflects the unfiltered view"
         );
 
@@ -2486,15 +2554,15 @@ mod tests {
             "the author takes the copy color"
         );
         assert!(
-            rendered_line(&terminal, 1).contains("Y copy author"),
+            rendered_line(&terminal, 1).contains("copY author"),
             "the footer previews the shifted shortcut"
         );
         assert!(
-            rendered_line(&terminal, 1).contains("R refresh"),
+            rendered_line(&terminal, 1).contains("Refresh"),
             "the footer previews the shifted refresh shortcut"
         );
         assert!(
-            !rendered_line(&terminal, 1).contains("r refs"),
+            !rendered_line(&terminal, 1).contains(" · refs"),
             "the shifted refresh shortcut replaces the reference toggle"
         );
         Ok(())
@@ -2538,14 +2606,14 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
         assert!(
-            rendered_line(&terminal, 1).contains("e active (r reword · n new · d forget · t return)"),
+            rendered_line(&terminal, 1).contains("edit (reword · new · d forget · return)"),
             "the active edit prefix contains exactly its actionable commands"
         );
-        assert!(!rendered_line(&terminal, 1).contains("e edit"));
+        assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 1).contains("t travel"));
+        assert!(rendered_line(&terminal, 1).contains("travel"));
         Ok(())
     }
 
@@ -2560,26 +2628,26 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let footer = rendered_line(&terminal, 1);
-        let view = "v active (d date · e emails · n names · m mailmap · t trailers · r no refs · h show hidden)";
+        let view = "view (date · emails · names · mailmap · trailers · no refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · ↑↓/jk move")),
+            footer.starts_with(&format!("0 commits · {view} · [ align")),
             "the active view prefix follows the history position"
         );
-        let active = footer[..footer.find("v active").expect("the active view prefix is visible")]
+        let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
             .chars()
             .count() as u16;
         assert!(
             terminal.backend().buffer()[(active, 1)]
                 .modifier
-                .contains(Modifier::BOLD),
-            "the active prefix label is emphasized"
+                .contains(Modifier::UNDERLINED),
+            "the prefix key is underlined in its verb"
         );
 
         app.history_display_expanded = false;
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · v view · e active (no actions) · ↑↓/jk move"),
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · [ align"),
             "the edit prefix follows the view prefix even when no action is available"
         );
         Ok(())
@@ -3004,7 +3072,10 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(footer_is_dim(&terminal, "o commit"), "the closed commit pane is dimmed");
+        assert!(
+            footer_is_dim(&terminal, "open message"),
+            "the closed commit pane is dimmed"
+        );
 
         app.update(Action::ToggleCommit);
         terminal.draw(|frame| {
@@ -3048,7 +3119,7 @@ mod tests {
             "the commit body remains separated from its title"
         );
         assert!(
-            !footer_is_dim(&terminal, "o commit"),
+            !footer_is_dim(&terminal, "close message"),
             "the open commit pane is not dimmed"
         );
 
@@ -3446,7 +3517,7 @@ mod tests {
             "repeated history navigation temporarily hides the changes pane"
         );
         assert!(
-            app.changes_mode.is_some() && !footer_is_dim(&terminal, "c changes"),
+            app.changes_mode.is_some() && !footer_is_dim(&terminal, "cycle changes"),
             "temporary suppression leaves the persistent changes setting enabled"
         );
         app.changes_suppressed = false;
@@ -3541,11 +3612,11 @@ mod tests {
         assert!(rendered_line(&terminal, 14).contains("↑↓/jk move · h/l pan"));
 
         assert!(
-            rendered_line(&terminal, 14).contains("Enter diff · y copy · c tree"),
+            rendered_line(&terminal, 14).contains("<enter> diff · copy · cycle tree"),
             "the changes pane advertises the next cycle mode"
         );
         assert!(
-            rendered_line(&terminal, 14).contains("y copy"),
+            rendered_line(&terminal, 14).contains("copy"),
             "the changes pane advertises path copying"
         );
 
@@ -3626,7 +3697,7 @@ mod tests {
         );
         assert!(
             rendered_line(&terminal, 14).contains(
-                "vs parent 1/2 0202020 · p next parent · ↑↓/jk move · h/l pan · Enter diff · y copy · c tree"
+                "vs parent 1/2 0202020 · next parent · ↑↓/jk move · h/l pan · <enter> diff · copy · cycle tree"
             ),
             "merge diffs keep parent controls alongside navigation"
         );
@@ -3641,7 +3712,7 @@ mod tests {
             "the compared parent's hash is inverted"
         );
         assert!(
-            !rendered_line(&terminal, 15).contains("p next parent"),
+            !rendered_line(&terminal, 15).contains("next parent"),
             "parent cycling is absent from the main status line"
         );
 
@@ -4448,7 +4519,9 @@ mod tests {
     fn footer_is_dim(terminal: &Terminal<TestBackend>, label: &str) -> bool {
         let y = terminal.backend().buffer().area.height - 1;
         let footer = rendered_line(terminal, y);
-        let x = footer[..footer.find(label).expect("toggle is visible")].chars().count() as u16;
+        let x = footer[..footer.rfind(label).expect("toggle is visible")]
+            .chars()
+            .count() as u16;
         terminal.backend().buffer()[(x, y)].modifier.contains(Modifier::DIM)
     }
 }

From 0bdd80df04e8656170c4531126df1eebd3145cb1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 13:10:33 +0200
Subject: [PATCH 062/282] feat: rebase linear descendants for tix history edits

Allow reword, commit insertion, and forgetting from arbitrary points in a linear history instead of limiting edits to the newest commit.

Introduce one transactional edit::rebase primitive that prepares all rewritten commits and cherry-picked trees in object memory, preserves forks, rejects descendant merges, and aborts the complete operation on conflicts. Mutable local references across the rewritten set move in one compare-and-swap transaction; tags and remote-tracking refs remain immutable.

Model tree handling explicitly with LeaveAsIs, LeaveAsIsAndMark, and CherryPick. The marker form writes tix-rebase: pending, and Repeat resumes from a marked base, cherry-picks the marked range, and clears the markers. Model signatures with RedoIfNeeded and InvalidateExisting, respecting repository signing configuration while applying one current committer identity and timestamp to automatically rebased descendants.

Preflight every affected accessible worktree through Git before refs move. Apply checkout transitions only after all preparation succeeds, and roll back already-updated worktrees and refs if a later checkout fails. Commit insertion preserves worktree bytes while updating affected indexes to the new committed tree. Stale unrelated linked worktrees are ignored.

Route reword, create, and forget through this primitive and remove the former parallel MutableRefs implementation. Permit edits with linear descendants while retaining merge safety, and update the behavioral specification.

Add scenario fixtures and snapshots for middle-stack rewrites, removal with tree transplanting, deferred rebase replay, and conflict atomicity.
---
 gix-tix/Cargo.toml                            |   2 +-
 gix-tix/spec.md                               |  57 +-
 gix-tix/src/app.rs                            |  30 +-
 gix-tix/src/edit/create.rs                    | 168 +---
 gix-tix/src/edit/forget.rs                    | 104 +--
 gix-tix/src/edit/mod.rs                       |  44 +-
 gix-tix/src/edit/rebase.rs                    | 825 ++++++++++++++++++
 gix-tix/src/edit/refs.rs                      | 174 ----
 gix-tix/src/edit/reword.rs                    |  52 +-
 ..._rebase__tests__reworded-middle-stack.snap |  56 ++
 gix-tix/src/history.rs                        |  62 ++
 gix-tix/src/lib.rs                            |  59 +-
 .../generated-archives/rebase_conflict.tar    | Bin 0 -> 70656 bytes
 .../generated-archives/rebase_edit.tar        | Bin 0 -> 75264 bytes
 gix-tix/tests/fixtures/rebase_conflict.sh     |  15 +
 gix-tix/tests/fixtures/rebase_edit.sh         |  22 +
 16 files changed, 1221 insertions(+), 449 deletions(-)
 create mode 100644 gix-tix/src/edit/rebase.rs
 delete mode 100644 gix-tix/src/edit/refs.rs
 create mode 100644 gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
 create mode 100644 gix-tix/tests/fixtures/generated-archives/rebase_conflict.tar
 create mode 100644 gix-tix/tests/fixtures/generated-archives/rebase_edit.tar
 create mode 100644 gix-tix/tests/fixtures/rebase_conflict.sh
 create mode 100644 gix-tix/tests/fixtures/rebase_edit.sh

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index 9f4572fed21..ea9e0e23481 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -26,7 +26,7 @@ sha256 = ["gix/sha256"]
 anyhow = "1.0.98"
 crossterm = { version = "0.29.0", features = ["osc52"] }
 directories = "6.0.0"
-gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "notes", "parallel", "revision", "command", "status"] }
+gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "merge", "notes", "parallel", "revision", "command", "sha1", "status"] }
 notify = "8.2.0"
 ratatui = { version = "0.30.2", default-features = false, features = ["crossterm", "unstable-rendered-line-info"] }
 terminal-colorsaurus = "1.0.3"
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ad99cffce97..937248ecbd0 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -288,8 +288,8 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Reword
 
-- `e`, then `r`, is available only after history completion and only when the
-  selected commit has no descendants in tix's complete cached graph.
+- `e`, then `r`, is available after history completion when no known descendant
+  of the selected commit is a merge commit.
 - The configured Git editor receives a document containing `Author`,
   `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
   message in a temporary `.md` file for syntax highlighting. Author identity and
@@ -302,9 +302,9 @@ space first; changes blocks adapt within the remaining history width.
   opt-ins. A case-insensitive existing trailer key suppresses its suggestion,
   regardless of value.
 - An unchanged editor document is a no-op. Otherwise tix recreates the commit,
-  signs it when commit-signing configuration is enabled, and atomically retargets
-  mutable local refs that pointed directly at the old commit. Tags and
-  remote-tracking refs remain unchanged; a detached `HEAD` is retargeted.
+  signs it when commit-signing configuration is enabled, and rewrites every
+  linear descendant with unchanged trees and corrected parentage. Mutable refs
+  follow every rewritten commit; tags and remote-tracking refs remain unchanged.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
   the main status line and do not leave a repository retained by the UI.
 
@@ -312,9 +312,9 @@ space first; changes blocks adapt within the remaining history width.
 
 - `e`, then `n`, creates a child of the selected commit, or a root commit for an
   unborn `HEAD`. It is available only with a live worktree, after history
-  completion, and when the selected parent has no known descendants.
+  completion, and when the selected parent has no known merge descendant.
 - Before launching the editor, tix resolves identities, signing configuration,
-  every mutable direct ref, linked-worktree safety, index conflicts, filters,
+  index conflicts, filters,
   candidate tree, per-path diffstat, and a provisional commit entirely through an
   in-memory object database. Cancellation and preflight failure write no object,
   reference, index, or worktree state.
@@ -327,23 +327,22 @@ space first; changes blocks adapt within the remaining history width.
   title, a `why` body, optional attribution trailers, and a commented Git-style
   per-path diffstat with signed net line counts. Commit hooks are not run.
 - After editing, tix revalidates the destination, applies configured signing,
-  persists the already-prepared objects, and atomically advances every mutable
-  direct ref pointing at the parent. This includes local branches, custom refs,
-  direct tix pins, and a detached `HEAD`, while excluding tags and remote-tracking
-  refs. An attached `HEAD` remains attached; an unrelated worktree `HEAD` is left
-  untouched. A ref changed by another process or a branch checked out in another
-  worktree aborts safely.
+  rebases linear descendants, persists the prepared objects, and atomically
+  advances mutable refs throughout the rewritten stack. This includes local
+  branches, custom refs, direct tix pins, and a detached `HEAD`, while excluding
+  tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
+  inaccessible or conflicting affected worktrees abort safely.
 
 ### Forget commits
 
 - `e`, then `d`, is available after history completion for a selected non-merge
-  commit with no descendants in the complete cached graph. The first `d` arms a
+  commit with no known merge descendant. The first `d` arms a
   `d again forget` confirmation; the second performs it. Navigation, refresh,
   cancellation, selection changes, and other commands disarm confirmation.
-- Forgetting does not require a worktree. Every mutable direct ref pointing at
-  the commit is atomically retargeted to its parent, or deleted for a root.
-  Tags and remote-tracking refs remain unchanged. A branch checked out in another
-  worktree aborts before mutation.
+- Forgetting does not require a worktree. Linear descendants are cherry-picked
+  onto the selected commit's parent, and mutable refs throughout the rewritten
+  stack move atomically. Empty commits only need parent rewriting. Tags and
+  remote-tracking refs remain unchanged.
 - When the selected commit is the current worktree `HEAD`, Git preflights and
   applies a two-tree index/worktree transition which discards only that commit's
   tracked delta. Conflicting staged, tracked, or untracked state refuses the
@@ -353,6 +352,28 @@ space first; changes blocks adapt within the remaining history width.
   unborn. A selected detached root is rejected because it cannot produce a valid
   unborn `HEAD`. Success refreshes history and selects the parent when present.
 
+### Transactional rebases
+
+- Reword, new-commit, and forget edits share one in-memory rebase primitive.
+  Forks are preserved, descendant merges are rejected, and all commit/tree
+  preparation—including cherry-pick conflict detection—finishes before objects
+  become reachable through refs.
+- `Tree::LeaveAsIs` rewrites parentage without changing trees;
+  `LeaveAsIsAndMark` additionally writes `tix-rebase: pending`; and `CherryPick`
+  transplants each tree delta, aborting the entire edit on unresolved conflicts.
+  A marked operation can be repeated from its marked base and clears all markers
+  after a successful cherry-pick.
+- `Signature::RedoIfNeeded` signs every rewritten commit when signing is
+  configured and otherwise removes stale signature headers.
+  `InvalidateExisting` empties existing signature values when signing is
+  configured, or removes them when it is not. Automatically rebased descendants
+  retain their author and receive one configured current committer identity and
+  timestamp for the operation.
+- All mutable local refs pointing anywhere into the rewritten set are changed in
+  one compare-and-swap transaction. A checkout failure rolls back already-applied
+  worktree transitions and the ref transaction; newly written unreachable objects
+  may remain for normal Git garbage collection.
+
 ### Editing shortcuts
 
 - `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index c7036ccf936..6b005d5aaf0 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -380,6 +380,7 @@ pub(crate) struct App {
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
     known_descendants: HashSet<ObjectId>,
+    known_merge_descendants: HashSet<ObjectId>,
     select_top_after_refresh: bool,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
@@ -454,6 +455,7 @@ impl App {
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
             known_descendants: HashSet::new(),
+            known_merge_descendants: HashSet::new(),
             select_top_after_refresh: false,
             signature_failures: 0,
             signature_verification_running: false,
@@ -492,6 +494,10 @@ impl App {
         self.update_worktree_head_descendants();
     }
 
+    pub(crate) fn set_known_merge_descendants(&mut self, ids: HashSet<ObjectId>) {
+        self.known_merge_descendants = ids;
+    }
+
     pub(crate) fn worktree_head_has_descendants(&self, id: ObjectId) -> bool {
         self.worktree_head == Some(id) && self.worktree_head_has_descendants
     }
@@ -1322,7 +1328,7 @@ impl App {
             && self
                 .selected
                 .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| !self.has_known_descendant(row.id))
+                .is_some_and(|row| !self.known_merge_descendants.contains(&row.id))
     }
 
     pub(crate) fn can_create_commit(&self) -> bool {
@@ -1331,7 +1337,7 @@ impl App {
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && match self.selected.and_then(|index| self.rows.get(index)) {
-                Some(row) => !self.has_known_descendant(row.id),
+                Some(row) => !self.known_merge_descendants.contains(&row.id),
                 None => self.worktree_head_unborn,
             }
     }
@@ -1343,7 +1349,7 @@ impl App {
             && self
                 .selected
                 .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| row.parent_ids.len() <= 1 && !self.has_known_descendant(row.id))
+                .is_some_and(|row| row.parent_ids.len() <= 1 && !self.known_merge_descendants.contains(&row.id))
     }
 
     pub(crate) fn forget_confirmation_visible(&self) -> bool {
@@ -2013,7 +2019,7 @@ mod tests {
     }
 
     #[test]
-    fn only_a_completed_history_row_without_descendants_can_be_reworded() {
+    fn completed_non_merge_stacks_can_be_reworded_from_any_row() {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         assert!(!app.can_reword(), "loading history cannot be reworded");
@@ -2021,11 +2027,8 @@ mod tests {
         assert_eq!(app.update(Action::Reword), vec![Effect::Reword(id(2))]);
 
         app.update(Action::MoveDown);
-        assert!(
-            !app.can_reword(),
-            "a commit with a visible descendant cannot be reworded"
-        );
-        assert!(app.update(Action::Reword).is_empty());
+        assert!(app.can_reword(), "linear descendants can be rebased after rewording");
+        assert_eq!(app.update(Action::Reword), vec![Effect::Reword(id(1))]);
     }
 
     #[test]
@@ -2042,7 +2045,7 @@ mod tests {
         assert!(app.forget_confirmation_visible());
         app.update(Action::MoveDown);
         assert!(!app.forget_confirmation_visible(), "navigation cancels confirmation");
-        assert!(!app.can_forget(), "a commit with a descendant cannot be forgotten");
+        assert!(app.can_forget(), "a commit with linear descendants can be forgotten");
         app.update(Action::MoveUp);
         assert!(app.update(Action::Forget).is_empty());
         assert_eq!(app.update(Action::Forget), vec![Effect::Forget(id(2))]);
@@ -2054,18 +2057,19 @@ mod tests {
     }
 
     #[test]
-    fn editing_requires_no_known_descendants_and_new_commits_support_unborn_head() {
+    fn editing_rejects_merge_descendants_and_new_commits_support_unborn_head() {
         let mut app = App::new(10);
         app.extend_commits(vec![row(2)]);
         complete(&mut app);
         app.set_known_descendants(HashSet::from([id(2)]));
+        app.set_known_merge_descendants(HashSet::from([id(2)]));
         assert!(
             !app.can_reword(),
-            "a descendant outside the visible projection still prevents rewording"
+            "a merge descendant outside the visible projection prevents rewording"
         );
         assert!(
             !app.can_create_commit(),
-            "a descendant outside the visible projection still prevents a child"
+            "a merge descendant outside the visible projection prevents a child"
         );
 
         let mut unborn = App::new(10);
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 0003abe288a..2c45abf09a9 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -1,31 +1,23 @@
-use std::{ffi::OsString, path::Path};
+use std::ffi::OsString;
 
 use anyhow::{Context, Result};
-use gix::{ObjectId, bstr::ByteSlice, objs::Write};
+use gix::{ObjectId, bstr::ByteSlice};
 
 use crate::{
     ChangeGroup, ChangeKind, ComparedParent, add_line_counts, load_tree_changes_without_lines,
     load_worktree_changes_without_lines, ui,
 };
 
-use super::{refs::MutableRefs, reword, time_travel};
+use super::{rebase, reword};
 
 pub(crate) struct Prepared {
     pub editor: OsString,
     pub document: Vec<u8>,
     parent: Option<ObjectId>,
     tree: ObjectId,
-    references: MutableRefs,
-    checkout: Checkout,
     objects: gix::odb::memory::Storage,
 }
 
-enum Checkout {
-    None,
-    Branch(gix::refs::FullName),
-    Detached,
-}
-
 pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
     repo.workdir().context("creating a commit requires a worktree")?;
     let head = repo.head().context("could not read HEAD before creating a commit")?;
@@ -37,31 +29,9 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
         repo.find_commit(parent)
             .context("could not find the selected parent commit")?;
     }
-    let (references, checkout) = match parent {
-        Some(parent) => {
-            let references = MutableRefs::pointing_to(&repo, parent)?;
-            if references.is_empty() {
-                anyhow::bail!("no mutable reference points to the selected parent");
-            }
-            references.ensure_not_checked_out_elsewhere(&repo)?;
-            let checkout = if head_id == Some(parent) {
-                match head.referent_name() {
-                    Some(name) => Checkout::Branch(name.to_owned()),
-                    None => Checkout::Detached,
-                }
-            } else {
-                Checkout::None
-            };
-            (references, checkout)
-        }
-        None => {
-            let name = head
-                .referent_name()
-                .context("an unborn HEAD must point to a branch")?
-                .to_owned();
-            (MutableRefs::unborn(&repo)?, Checkout::Branch(name))
-        }
-    };
+    if parent.is_none() {
+        head.referent_name().context("an unborn HEAD must point to a branch")?;
+    }
     let editor = repo.editor().context("no Git editor is available")?;
     let author = repo
         .author()
@@ -159,8 +129,6 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
         document,
         parent,
         tree,
-        references,
-        checkout,
         objects,
     })
 }
@@ -209,25 +177,18 @@ fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<Obj
     Ok(editor.write().context("could not build the worktree tree")?.detach())
 }
 
-pub(crate) fn apply(mut repo: gix::Repository, mut prepared: Prepared, edited: &[u8]) -> Result<ObjectId> {
+pub(crate) fn apply(
+    mut repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    mut prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
     let edit = reword::parse(edited)?;
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
     }
-    prepared.references.validate(&repo)?;
-    let references = match prepared.parent {
-        Some(parent) => MutableRefs::pointing_to(&repo, parent)?,
-        None => MutableRefs::unborn(&repo)?,
-    };
-    if references.is_empty() {
-        anyhow::bail!("no mutable reference points to the selected parent anymore");
-    }
-    references.ensure_not_checked_out_elsewhere(&repo)?;
-    let signing = repo
-        .commit_signing_options_if_enabled()
-        .context("could not resolve commit signing configuration")?;
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let mut commit = gix::objs::Commit {
+    let commit = gix::objs::Commit {
         message: edit.message,
         tree: prepared.tree,
         author: reword::actor(edit.author, edit.author_time, "author")?,
@@ -236,83 +197,32 @@ pub(crate) fn apply(mut repo: gix::Repository, mut prepared: Prepared, edited: &
         parents: prepared.parent.into_iter().collect(),
         extra_headers: Vec::new(),
     };
-    if let Some(options) = signing {
-        commit = commit.sign(options).context("could not sign the new commit")?;
-    }
-    let new_id = repo
-        .write_object(&commit)
-        .context("could not prepare the final commit")?
-        .detach();
-    let objects = repo
-        .objects
-        .take_object_memory()
-        .context("candidate object memory was unavailable")?;
-    for (id, (kind, data)) in objects.iter() {
-        repo.write_buf_with_known_id(*kind, data, *id)
-            .map_err(|err| anyhow::anyhow!("could not persist a prepared commit object: {err}"))?;
-    }
-    let log_message = gix::reference::log::message("commit", commit.message.as_bstr(), commit.parents.len());
-    let mut time_buf = gix::date::parse::TimeBuf::default();
-    references.update(
-        &repo,
-        new_id,
-        log_message.as_bstr(),
-        Some(commit.committer.to_ref(&mut time_buf)),
-    )?;
-    let checkout = match &prepared.checkout {
-        Checkout::None => Ok(()),
-        Checkout::Branch(name) => {
-            let workdir = repo.workdir().context("creating a commit requires a worktree")?;
-            let branch = name
-                .as_bstr()
-                .strip_prefix(b"refs/heads/")
-                .context("the destination isn't a local branch")?;
-            time_travel::checkout(
-                workdir,
-                [
-                    OsString::from("--no-guess"),
-                    gix::path::from_bstr(branch.as_bstr()).into_owned().into_os_string(),
-                ],
-            )
-            .and_then(|()| reset_index(workdir, new_id))
-        }
-        Checkout::Detached => {
-            let workdir = repo.workdir().context("creating a commit requires a worktree")?;
-            time_travel::checkout_detached(workdir, new_id)
-        }
+    let base_tree = match prepared.parent {
+        Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
+        None => repo.empty_tree().id,
     };
-    if let Err(err) = checkout {
-        let rollback = references.rollback(&repo, new_id);
-        return match rollback {
-            Ok(()) => Err(err),
-            Err(rollback) => Err(err.context(format!("the destination could not be rolled back: {rollback:#}"))),
-        };
-    }
-    Ok(new_id)
-}
-
-fn reset_index(workdir: &Path, id: ObjectId) -> Result<()> {
-    let output = std::process::Command::new("git")
-        .arg("-C")
-        .arg(workdir)
-        .args(["reset", "--mixed", "--quiet"])
-        .arg(id.to_string())
-        .output()
-        .context("could not update the index after checkout")?;
-    if output.status.success() {
-        Ok(())
+    let tree_mode = if base_tree == commit.tree {
+        rebase::Tree::LeaveAsIs
     } else {
-        anyhow::bail!(
-            "git reset failed with {}: {}",
-            output.status,
-            output.stderr.to_str_lossy().trim()
-        )
-    }
+        rebase::Tree::CherryPick
+    };
+    rebase::perform(
+        repo,
+        graph,
+        rebase::Edit::Insert {
+            anchor: prepared.parent,
+            commit,
+        },
+        rebase::Signature::RedoIfNeeded,
+        tree_mode,
+    )?
+    .selected
+    .context("inserting a commit did not produce a selection")
 }
 
 #[cfg(test)]
 mod tests {
-    use std::process::Command;
+    use std::{path::Path, process::Command};
 
     use super::*;
 
@@ -386,7 +296,8 @@ mod tests {
         );
 
         let edited = prepared.document.replacen(b"what\n\nwhy", b"title\n\nbody", 1);
-        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let after = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             after.head,
@@ -447,7 +358,8 @@ mod tests {
         let parent = open(fixture.path())?.head_id()?.detach();
         let prepared = prepare(open(fixture.path())?, Some(parent))?;
         let edited = prepared.document.replacen(b"what\n\nwhy", b"worktree\n\nstate", 1);
-        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let after = gix_testtools::repository::snapshot(fixture.path())?;
         let repository = open(fixture.path())?;
         let commit = repository.find_commit(new_id)?;
@@ -487,7 +399,8 @@ mod tests {
             "root-commit preflight is unobservable"
         );
         let edited = prepared.document.replacen(b"what\n\nwhy", b"root\n\nreason", 1);
-        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let repository = open(fixture.path())?;
         let commit = repository.find_commit(new_id)?;
         assert!(commit.parent_ids().next().is_none(), "the root has no parent");
@@ -544,7 +457,8 @@ mod tests {
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let prepared = prepare(open(fixture.path())?, Some(parent))?;
         let edited = prepared.document.replacen(b"what\n\nwhy", b"child\n\nreason", 1);
-        let new_id = apply(open(fixture.path())?, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let after = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             after.head, before.head,
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index 5f0536a92c6..6286e576790 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -3,72 +3,41 @@ use std::{io::Write, path::Path, process::Command};
 use anyhow::{Context, Result};
 use gix::{ObjectId, bstr::ByteSlice};
 
-use super::refs::MutableRefs;
+use super::rebase;
 
-pub(crate) fn perform(repo: &gix::Repository, id: ObjectId) -> Result<Option<ObjectId>> {
+pub(crate) fn perform(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    id: ObjectId,
+) -> Result<Option<ObjectId>> {
     let commit = repo.find_commit(id).context("could not find the commit to forget")?;
-    let parents: Vec<_> = commit.parent_ids().map(gix::Id::detach).collect();
-    if parents.len() > 1 {
-        anyhow::bail!("merge commits cannot be forgotten");
-    }
-    let parent = parents.first().copied();
-    let old_tree = commit
-        .tree_id()
-        .context("could not read the forgotten commit tree")?
-        .detach();
-    let refs = MutableRefs::pointing_to(repo, id)?;
-    if refs.is_empty() {
-        anyhow::bail!("no mutable reference points to the commit anymore");
-    }
-    refs.ensure_not_checked_out_elsewhere(repo)?;
-    let head = repo.head().context("could not inspect HEAD before forgetting")?;
-    let head_is_selected = head.id().is_some_and(|head| head.as_ref() == id);
-    if head_is_selected && parent.is_none() && head.referent_name().is_none() {
-        anyhow::bail!("a detached root commit cannot leave an unborn HEAD");
-    }
-    let transition = match (repo.workdir(), head_is_selected) {
-        (Some(workdir), true) => {
-            let new_tree = match parent {
-                Some(parent) => repo
-                    .find_commit(parent)
-                    .context("could not find the parent commit")?
-                    .tree_id()
-                    .context("could not read the parent tree")?
-                    .detach(),
-                None => repo
-                    .write_object(&gix::objs::Tree { entries: Vec::new() })
-                    .context("could not prepare the empty root tree")?
-                    .detach(),
-            };
-            preflight_tree_transition(repo, workdir, old_tree, new_tree)?;
-            Some((workdir.to_owned(), new_tree))
-        }
-        _ => None,
+    let parent = commit.parent_ids().next().map(gix::Id::detach);
+    let tree = commit.tree_id()?.detach();
+    let parent_tree = match parent {
+        Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
+        None => repo.empty_tree().id,
     };
-    drop(head);
     drop(commit);
-
-    let committer = repo.committer().transpose()?;
-    match parent {
-        Some(parent) => refs.update(repo, parent, b"forget commit".as_bstr(), committer)?,
-        None => refs.delete(repo, b"forget root commit".as_bstr(), committer)?,
-    }
-    if let Some((workdir, new_tree)) = transition
-        && let Err(err) = apply_tree_transition(&workdir, old_tree, new_tree)
-    {
-        let rollback = match parent {
-            Some(parent) => refs.rollback(repo, parent),
-            None => refs.rollback_deleted(repo),
-        };
-        return match rollback {
-            Ok(()) => Err(err),
-            Err(rollback) => Err(err.context(format!("references could not be rolled back: {rollback:#}"))),
-        };
-    }
-    Ok(parent)
+    Ok(rebase::perform(
+        repo,
+        graph,
+        rebase::Edit::Remove { target: id },
+        rebase::Signature::RedoIfNeeded,
+        if tree == parent_tree {
+            rebase::Tree::LeaveAsIs
+        } else {
+            rebase::Tree::CherryPick
+        },
+    )?
+    .selected)
 }
 
-fn preflight_tree_transition(repo: &gix::Repository, workdir: &Path, old: ObjectId, new: ObjectId) -> Result<()> {
+pub(super) fn preflight_tree_transition(
+    repo: &gix::Repository,
+    workdir: &Path,
+    old: ObjectId,
+    new: ObjectId,
+) -> Result<()> {
     let mut index = gix::tempfile::writable_at(
         std::env::temp_dir().join(format!(
             "tix-forget-index-{}-{old}-{:?}",
@@ -98,7 +67,7 @@ fn preflight_tree_transition(repo: &gix::Repository, workdir: &Path, old: Object
         .context("local changes conflict with forgetting this commit")
 }
 
-fn apply_tree_transition(workdir: &Path, old: ObjectId, new: ObjectId) -> Result<()> {
+pub(super) fn apply_tree_transition(workdir: &Path, old: ObjectId, new: ObjectId) -> Result<()> {
     let refresh = Command::new("git")
         .arg("-C")
         .arg(workdir)
@@ -159,7 +128,8 @@ mod tests {
             .expect("top has a parent")
             .detach();
 
-        assert_eq!(perform(&repository, top)?, Some(parent));
+        let graph = super::super::loaded_graph(&repository)?;
+        assert_eq!(perform(repository.clone(), &graph, top)?, Some(parent));
         let state = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             state.head,
@@ -213,7 +183,7 @@ mod tests {
         let repository = open(fixture.path())?;
         let top = repository.head_id()?.detach();
         assert!(
-            perform(&repository, top).is_err(),
+            perform(repository.clone(), &super::super::loaded_graph(&repository)?, top).is_err(),
             "overlapping local changes are rejected"
         );
         assert_eq!(
@@ -240,7 +210,8 @@ mod tests {
         let repository = open(fixture.path())?;
         let root = repository.head_id()?.detach();
 
-        assert_eq!(perform(&repository, root)?, None);
+        let graph = super::super::loaded_graph(&repository)?;
+        assert_eq!(perform(repository.clone(), &graph, root)?, None);
         let state = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             state.head,
@@ -277,7 +248,8 @@ mod tests {
             .next()
             .expect("top has a parent")
             .detach();
-        assert_eq!(perform(&repository, top)?, Some(parent));
+        let graph = super::super::loaded_graph(&repository)?;
+        assert_eq!(perform(repository.clone(), &graph, top)?, Some(parent));
         assert_eq!(
             repository.head_id()?.detach(),
             parent,
@@ -313,7 +285,7 @@ mod tests {
         let repository = open(fixture.path())?;
         let root = repository.head_id()?.detach();
         assert!(
-            perform(&repository, root).is_err(),
+            perform(repository.clone(), &super::super::loaded_graph(&repository)?, root).is_err(),
             "detached HEAD cannot become unborn"
         );
         assert_eq!(gix_testtools::repository::snapshot(fixture.path())?, before);
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 04671e43e49..626952ce025 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -2,9 +2,51 @@ use std::{ffi::OsStr, io::Write, process::Command};
 
 use anyhow::{Context, Result};
 
+#[cfg(test)]
+pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::HistoryGraph> {
+    use std::sync::atomic::AtomicBool;
+
+    if repo.head_id().is_err() {
+        return Ok(crate::history::HistoryGraph::default());
+    }
+    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+        crate::history::Authors::default(),
+    ));
+    let mut revisions = Vec::new();
+    for reference in repo.references()?.all()? {
+        let reference = reference.map_err(|err| anyhow::anyhow!("could not read test reference: {err}"))?;
+        if reference.name().as_bstr() != b"HEAD" && reference.try_id().is_some() {
+            revisions.push(
+                gix::path::from_bstr(reference.name().as_bstr())
+                    .into_owned()
+                    .into_os_string(),
+            );
+        }
+    }
+    if repo.head().is_ok_and(|head| head.referent_name().is_none()) {
+        revisions.push("HEAD".into());
+    }
+    let mut graph = None;
+    crate::history::load(
+        repo,
+        &revisions,
+        &[],
+        false,
+        &authors,
+        &AtomicBool::new(false),
+        |event| {
+            if let crate::history::Event::Complete(value) = event {
+                graph = Some(value);
+            }
+            true
+        },
+    )?;
+    graph.context("history traversal did not produce a graph")
+}
+
 pub(crate) mod create;
 pub(crate) mod forget;
-pub(crate) mod refs;
+pub(crate) mod rebase;
 pub(crate) mod reword;
 pub(crate) mod time_travel;
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
new file mode 100644
index 00000000000..7af41c2795d
--- /dev/null
+++ b/gix-tix/src/edit/rebase.rs
@@ -0,0 +1,825 @@
+use std::{
+    collections::{HashMap, HashSet},
+    path::PathBuf,
+    process::Command,
+};
+
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::{BStr, BString},
+    objs::Write,
+    refs::{
+        Category, Target,
+        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+    },
+};
+
+use crate::history::HistoryGraph;
+
+const MARKER: &[u8] = b"tix-rebase";
+const PENDING: &[u8] = b"pending";
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Signature {
+    #[allow(dead_code, reason = "available to edits which defer a rebase")]
+    InvalidateExisting,
+    RedoIfNeeded,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Tree {
+    LeaveAsIs,
+    LeaveAsIsAndMark,
+    CherryPick,
+}
+
+pub(crate) enum Edit {
+    Replace {
+        target: ObjectId,
+        commit: gix::objs::Commit,
+    },
+    Insert {
+        anchor: Option<ObjectId>,
+        commit: gix::objs::Commit,
+    },
+    Remove {
+        target: ObjectId,
+    },
+    #[allow(dead_code, reason = "available to resume a marked deferred rebase")]
+    Repeat {
+        base: ObjectId,
+    },
+}
+
+pub(crate) struct Outcome {
+    pub selected: Option<ObjectId>,
+}
+
+pub(crate) fn perform(
+    mut repo: gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    mut tree_mode: Tree,
+) -> Result<Outcome> {
+    let (root, replacement, inserted, removed, repeat) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false),
+        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false),
+        Edit::Remove { target } => (Some(target), None, false, true, false),
+        Edit::Repeat { base } => (Some(base), None, false, false, true),
+    };
+    if repeat {
+        tree_mode = Tree::CherryPick;
+    }
+
+    let affected = match root {
+        Some(root) => graph
+            .descendants_in_parent_order(root)
+            .context("the edited commit is not in the loaded history")?,
+        None => Vec::new(),
+    };
+    validate(&repo, graph, &affected, removed, repeat, tree_mode)?;
+
+    let signing = repo
+        .commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()
+        .context("could not own the Git committer")?;
+    repo = repo.with_object_memory();
+
+    let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut selected = None;
+    if inserted {
+        let mut commit = replacement.clone().context("an inserted commit is required")?;
+        commit.parents = root.into_iter().collect();
+        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark);
+        let id = write_commit(&repo, commit, signature, signing.clone())?;
+        selected = Some(id);
+        if let Some(root) = root {
+            rewritten.insert(root, Some(id));
+        } else {
+            rewritten.insert(id, Some(id));
+        }
+    } else if removed {
+        let root = root.context("a removed commit is required")?;
+        let parent = graph
+            .parents_of(root)
+            .context("the removed commit is not in the loaded history")?
+            .first()
+            .copied();
+        rewritten.insert(root, parent);
+        selected = parent;
+    }
+
+    let mut pending = affected;
+    if inserted || removed {
+        pending.retain(|id| Some(*id) != root);
+    }
+    for old_id in pending {
+        let old_parents = graph.parents_of(old_id).context("an affected commit is incomplete")?;
+        let mut commit = if Some(old_id) == root {
+            match replacement.clone() {
+                Some(commit) => commit,
+                None => repo
+                    .find_commit(old_id)
+                    .context("could not find commit to rewrite")?
+                    .decode()
+                    .context("could not decode commit to rewrite")?
+                    .into_owned()
+                    .context("could not own commit to rewrite")?,
+            }
+        } else {
+            repo.find_commit(old_id)
+                .context("could not find descendant commit")?
+                .decode()
+                .context("could not decode descendant commit")?
+                .into_owned()
+                .context("could not own descendant commit")?
+        };
+        let new_parents: Vec<_> = old_parents
+            .iter()
+            .filter_map(|parent| rewritten.get(parent).copied().unwrap_or(Some(*parent)))
+            .collect();
+        if Some(old_id) != root || repeat {
+            commit.committer = committer.clone();
+        }
+        commit.tree = rewritten_tree(&repo, &commit, &old_parents, &new_parents, tree_mode)?;
+        commit.parents = new_parents.into_iter().collect();
+        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark);
+        let new_id = write_commit(&repo, commit, signature, signing.clone())?;
+        rewritten.insert(old_id, Some(new_id));
+        if Some(old_id) == root {
+            selected = Some(new_id);
+        }
+    }
+
+    let objects = repo
+        .objects
+        .take_object_memory()
+        .context("candidate object memory was unavailable")?;
+    for (id, (kind, data)) in objects.iter() {
+        repo.write_buf_with_known_id(*kind, data, *id)
+            .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
+    }
+
+    let transitions = worktree_transitions(&repo, &rewritten, inserted)?;
+    let index_resets = inserted.then(|| inserted_index_resets(&repo, &rewritten)).transpose()?;
+    for transition in &transitions {
+        super::forget::preflight_tree_transition(
+            &transition.repo,
+            &transition.workdir,
+            transition.old,
+            transition.new,
+        )?;
+    }
+    let rollback_refs = update_refs(&repo, &rewritten, root.is_none(), selected, &committer)?;
+    for (transitioned, transition) in transitions.iter().enumerate() {
+        if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new) {
+            return rollback(&repo, &committer, &transitions[..transitioned], &rollback_refs, err);
+        }
+    }
+    let index_resets = index_resets.unwrap_or_default();
+    for (index, reset) in index_resets.iter().enumerate() {
+        if let Err(mut err) = reset_index(&reset.workdir, reset.new) {
+            for applied in index_resets[..=index].iter().rev() {
+                if let Err(restore) = std::fs::write(&applied.index, &applied.before) {
+                    err = err.context(format!("index rollback failed: {restore}"));
+                }
+            }
+            return rollback(&repo, &committer, &transitions, &rollback_refs, err);
+        }
+    }
+    Ok(Outcome { selected })
+}
+
+fn rollback<T>(
+    repo: &gix::Repository,
+    committer: &gix::actor::Signature,
+    transitions: &[Transition],
+    refs: &[RefEdit],
+    cause: anyhow::Error,
+) -> Result<T> {
+    let mut failures = Vec::new();
+    for transition in transitions.iter().rev() {
+        if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.new, transition.old) {
+            failures.push(format!("worktree rollback failed: {err:#}"));
+        }
+    }
+    let mut time = gix::date::parse::TimeBuf::default();
+    if let Err(err) = repo.edit_references_as(refs.iter().cloned(), Some(committer.to_ref(&mut time))) {
+        failures.push(format!("reference rollback failed: {err}"));
+    }
+    if failures.is_empty() {
+        Err(cause)
+    } else {
+        Err(cause.context(failures.join("; ")))
+    }
+}
+
+fn inserted_index_resets(
+    repo: &gix::Repository,
+    rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+) -> Result<Vec<IndexReset>> {
+    let mut repos = vec![
+        repo.main_repo()
+            .context("could not open the main worktree repository")?,
+    ];
+    for proxy in repo.worktrees().context("could not enumerate linked worktrees")? {
+        if let Ok(worktree_repo) = proxy.into_repo_with_possibly_inaccessible_worktree() {
+            repos.push(worktree_repo);
+        }
+    }
+    let mut seen = HashSet::new();
+    let mut out = Vec::new();
+    for worktree_repo in repos {
+        if !seen.insert(worktree_repo.git_dir().to_owned()) {
+            continue;
+        }
+        let Some(old) = worktree_repo
+            .head()
+            .ok()
+            .and_then(|head| head.id().map(gix::Id::detach))
+        else {
+            continue;
+        };
+        let Some(Some(new)) = rewritten.get(&old).copied() else {
+            continue;
+        };
+        if let Some(workdir) = worktree_repo.workdir().filter(|path| path.is_dir()) {
+            let index = worktree_repo.index_path();
+            out.push(IndexReset {
+                workdir: workdir.to_owned(),
+                index: index.to_owned(),
+                before: std::fs::read(index).context("could not preserve an affected index")?,
+                new,
+            });
+        }
+    }
+    Ok(out)
+}
+
+struct IndexReset {
+    workdir: PathBuf,
+    index: PathBuf,
+    before: Vec<u8>,
+    new: ObjectId,
+}
+
+fn reset_index(workdir: &std::path::Path, id: ObjectId) -> Result<()> {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["reset", "--mixed", "--quiet"])
+        .arg(id.to_string())
+        .output()
+        .context("could not update the index after inserting a commit")?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!("git reset failed: {}", String::from_utf8_lossy(&output.stderr).trim())
+    }
+}
+
+fn validate(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    affected: &[ObjectId],
+    removed: bool,
+    repeat: bool,
+    tree: Tree,
+) -> Result<()> {
+    for (position, id) in affected.iter().enumerate() {
+        let parents = graph.parents_of(*id).context("an affected commit is incomplete")?;
+        if parents.len() > 1 && (position > 0 || removed || tree == Tree::CherryPick) {
+            anyhow::bail!("descendant merge commits cannot be rebased");
+        }
+        if repeat {
+            let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
+            if !has_marker(&commit) {
+                anyhow::bail!("all repeated rebase commits must carry the pending marker");
+            }
+        }
+    }
+    if repeat
+        && let Some(base) = affected.first()
+        && let Some(parent) = graph.parents_of(*base).and_then(|parents| parents.first().copied())
+        && has_marker(&repo.find_commit(parent)?.decode()?.into_owned()?)
+    {
+        anyhow::bail!("the parent of a repeated rebase must not carry the pending marker");
+    }
+    Ok(())
+}
+
+fn rewritten_tree(
+    repo: &gix::Repository,
+    commit: &gix::objs::Commit,
+    old_parents: &[ObjectId],
+    new_parents: &[ObjectId],
+    mode: Tree,
+) -> Result<ObjectId> {
+    if mode != Tree::CherryPick || old_parents == new_parents {
+        return Ok(commit.tree);
+    }
+    let old_base = parent_tree(repo, old_parents.first().copied())?;
+    let new_base = parent_tree(repo, new_parents.first().copied())?;
+    if commit.tree == old_base {
+        return Ok(new_base);
+    }
+    if old_base == new_base {
+        return Ok(commit.tree);
+    }
+    let labels = gix::merge::blob::builtin_driver::text::Labels {
+        ancestor: Some(BStr::new(b"parent")),
+        current: Some(BStr::new(b"rebased parent")),
+        other: Some(BStr::new(b"commit")),
+    };
+    let mut outcome = repo
+        .merge_trees(old_base, new_base, commit.tree, labels, repo.tree_merge_options()?)
+        .context("could not cherry-pick a descendant tree")?;
+    if outcome.has_unresolved_conflicts(gix::merge::tree::TreatAsUnresolved::git()) {
+        anyhow::bail!("rebasing would cause a merge conflict");
+    }
+    Ok(outcome
+        .tree
+        .write()
+        .context("could not prepare a rebased tree")?
+        .detach())
+}
+
+fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<ObjectId> {
+    match parent {
+        Some(parent) => Ok(repo.find_commit(parent)?.tree_id()?.detach()),
+        None => Ok(repo.empty_tree().id),
+    }
+}
+
+fn marker(commit: &mut gix::objs::Commit, add: bool) {
+    commit.extra_headers.retain(|(name, _)| name.as_slice() != MARKER);
+    if add {
+        commit.extra_headers.push((MARKER.into(), PENDING.into()));
+    }
+}
+
+fn has_marker(commit: &gix::objs::Commit) -> bool {
+    commit
+        .extra_headers
+        .iter()
+        .any(|(name, value)| name.as_slice() == MARKER && value.as_slice() == PENDING)
+}
+
+fn write_commit(
+    repo: &gix::Repository,
+    mut commit: gix::objs::Commit,
+    signature: Signature,
+    signing: Option<gix::objs::commit::signature::Options>,
+) -> Result<ObjectId> {
+    let had_signature = commit.extra_headers.iter().any(|(name, _)| is_signature(name));
+    commit.extra_headers.retain(|(name, _)| !is_signature(name));
+    commit = match (signature, signing) {
+        (Signature::RedoIfNeeded, Some(options)) => commit.sign(options).context("could not sign rebased commit")?,
+        (Signature::InvalidateExisting, Some(_)) if had_signature => {
+            let field = gix::objs::commit::signature_field_name(commit.tree.kind());
+            commit.extra_headers.push((field.into(), BString::default()));
+            commit
+        }
+        _ => commit,
+    };
+    Ok(repo
+        .write_object(&commit)
+        .context("could not prepare rebased commit")?
+        .detach())
+}
+
+fn is_signature(name: &BString) -> bool {
+    name.as_slice() == gix::objs::commit::SIGNATURE_FIELD_NAME.as_bytes()
+        || name.as_slice() == gix::objs::commit::SIGNATURE_FIELD_NAME_SHA256.as_bytes()
+}
+
+struct Transition {
+    repo: gix::Repository,
+    workdir: PathBuf,
+    old: ObjectId,
+    new: ObjectId,
+}
+
+fn worktree_transitions(
+    repo: &gix::Repository,
+    rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+    inserted: bool,
+) -> Result<Vec<Transition>> {
+    if inserted {
+        return Ok(Vec::new());
+    }
+    let mut repos = vec![
+        repo.main_repo()
+            .context("could not open the main worktree repository")?,
+    ];
+    for proxy in repo.worktrees().context("could not enumerate linked worktrees")? {
+        if let Ok(worktree_repo) = proxy.into_repo_with_possibly_inaccessible_worktree() {
+            repos.push(worktree_repo);
+        }
+    }
+    let mut out = Vec::new();
+    let mut seen = HashSet::new();
+    for worktree_repo in repos {
+        if !seen.insert(worktree_repo.git_dir().to_owned()) {
+            continue;
+        }
+        let Some(old) = worktree_repo
+            .head()
+            .ok()
+            .and_then(|head| head.id().map(gix::Id::detach))
+        else {
+            continue;
+        };
+        let Some(new) = rewritten.get(&old).copied() else {
+            continue;
+        };
+        if worktree_repo.workdir().is_none() && worktree_repo.is_bare() {
+            continue;
+        }
+        let old_tree = worktree_repo.find_commit(old)?.tree_id()?.detach();
+        let new_tree = match new {
+            Some(new) => repo.find_commit(new)?.tree_id()?.detach(),
+            None if worktree_repo.head()?.referent_name().is_some() => repo.empty_tree().id,
+            None => anyhow::bail!("a detached checked-out root commit cannot be removed"),
+        };
+        if old_tree == new_tree {
+            continue;
+        }
+        let workdir = worktree_repo
+            .workdir()
+            .filter(|path| path.is_dir())
+            .context("an affected worktree is inaccessible")?
+            .to_owned();
+        out.push(Transition {
+            repo: worktree_repo,
+            workdir,
+            old: old_tree,
+            new: new_tree,
+        });
+    }
+    Ok(out)
+}
+
+fn update_refs(
+    repo: &gix::Repository,
+    rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+    unborn: bool,
+    inserted: Option<ObjectId>,
+    committer: &gix::actor::Signature,
+) -> Result<Vec<RefEdit>> {
+    let mut edits = Vec::new();
+    let mut rollback = Vec::new();
+    for reference in repo.references()?.all()? {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => anyhow::bail!("could not inspect a reference before rebasing: {err}"),
+        };
+        if matches!(
+            reference.name().category(),
+            Some(Category::Tag | Category::RemoteBranch)
+        ) {
+            continue;
+        }
+        let Some(old) = reference.try_id().map(gix::Id::detach) else {
+            continue;
+        };
+        let Some(new) = rewritten.get(&old) else { continue };
+        let name = reference.name().to_owned();
+        edits.push(ref_edit(name.clone(), old, *new));
+        rollback.push(reverse_ref_edit(name, old, *new));
+    }
+    if let Some(head) = repo.try_find_reference("HEAD")?
+        && let Some(old) = head.try_id().map(gix::Id::detach)
+        && let Some(new) = rewritten.get(&old)
+    {
+        let name = head.name().to_owned();
+        edits.push(ref_edit(name.clone(), old, *new));
+        rollback.push(reverse_ref_edit(name, old, *new));
+    }
+    if unborn {
+        let name = repo
+            .head()?
+            .referent_name()
+            .context("an unborn HEAD must point to a branch")?
+            .to_owned();
+        let new = inserted.context("an unborn insertion must create a commit")?;
+        edits.push(RefEdit {
+            name: name.clone(),
+            deref: false,
+            change: Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustNotExist,
+                new: Target::Object(new),
+            },
+        });
+        rollback.push(RefEdit {
+            name,
+            deref: false,
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(Target::Object(new)),
+                log: RefLog::AndReference,
+            },
+        });
+    }
+    if edits.is_empty() {
+        anyhow::bail!("no mutable reference points to an affected commit");
+    }
+    let mut time = gix::date::parse::TimeBuf::default();
+    repo.edit_references_as(edits, Some(committer.to_ref(&mut time)))
+        .context("could not update references after rebasing")?;
+    Ok(rollback)
+}
+
+fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
+    loop {
+        if err
+            .downcast_ref::<std::io::Error>()
+            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
+        {
+            return true;
+        }
+        let Some(source) = err.source() else { return false };
+        err = source;
+    }
+}
+
+fn reverse_ref_edit(name: gix::refs::FullName, old: ObjectId, new: Option<ObjectId>) -> RefEdit {
+    RefEdit {
+        name,
+        deref: false,
+        change: match new {
+            Some(new) => Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustExistAndMatch(Target::Object(new)),
+                new: Target::Object(old),
+            },
+            None => Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustNotExist,
+                new: Target::Object(old),
+            },
+        },
+    }
+}
+
+fn ref_edit(name: gix::refs::FullName, old: ObjectId, new: Option<ObjectId>) -> RefEdit {
+    RefEdit {
+        name,
+        deref: false,
+        change: match new {
+            Some(new) => Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
+                new: Target::Object(new),
+            },
+            None => Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
+                log: RefLog::AndReference,
+            },
+        },
+    }
+}
+
+fn log_change() -> LogChange {
+    LogChange {
+        mode: RefLog::AndReference,
+        force_create_reflog: false,
+        message: BString::from("tix rebase"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use gix::bstr::ByteSlice;
+
+    use super::*;
+
+    fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated().config_overrides([
+                "user.name=rebasing committer".to_owned(),
+                "user.email=rebasing@example.com".to_owned(),
+                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?)
+    }
+
+    #[test]
+    fn rewords_a_middle_commit_and_reparents_all_linear_descendants() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+        let old_tip_tree = repo.find_commit(old_tip)?.tree_id()?.detach();
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.message = "rewritten middle".into();
+
+        let outcome = perform(
+            repo.clone(),
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIs,
+        )?;
+        let new_middle = outcome.selected.expect("replacement selects the rewritten commit");
+        let new_tip = repo.head_id()?.detach();
+        assert_ne!(new_tip, old_tip, "the descendant is rewritten");
+        assert_eq!(
+            repo.find_commit(new_tip)?.parent_ids().next().map(gix::Id::detach),
+            Some(new_middle),
+            "the descendant follows the replacement"
+        );
+        assert_eq!(
+            repo.find_commit(new_tip)?.tree_id()?.detach(),
+            old_tip_tree,
+            "a reword preserves descendant trees"
+        );
+        insta::assert_snapshot!(
+            "reworded-middle-stack",
+            gix_testtools::repository::snapshot(fixture.path())?.to_string()
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn removes_a_middle_commit_by_cherry_picking_its_descendant() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip_tree = repo.find_commit(repo.head_id()?)?.tree_id()?.detach();
+
+        let outcome = perform(
+            repo.clone(),
+            &graph,
+            Edit::Remove { target: middle },
+            Signature::RedoIfNeeded,
+            Tree::CherryPick,
+        )?;
+        assert_eq!(outcome.selected, Some(base), "removal selects its parent");
+        let tip = repo.head_id()?.detach();
+        assert_eq!(
+            repo.find_commit(tip)?.parent_ids().next().map(gix::Id::detach),
+            Some(base),
+            "the descendant is transplanted onto the removed commit's parent"
+        );
+        assert_ne!(
+            repo.find_commit(tip)?.tree_id()?.detach(),
+            old_tip_tree,
+            "the removed commit's tree contribution is absent"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn a_marked_rebase_can_be_repeated_and_clears_its_markers() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        let marked = perform(
+            repo.clone(),
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::InvalidateExisting,
+            Tree::LeaveAsIsAndMark,
+        )?
+        .selected
+        .expect("marking rewrites the selected commit");
+
+        let graph = super::super::loaded_graph(&repo)?;
+        perform(
+            repo.clone(),
+            &graph,
+            Edit::Repeat { base: marked },
+            Signature::RedoIfNeeded,
+            Tree::CherryPick,
+        )?;
+        let mut id = Some(repo.head_id()?.detach());
+        while let Some(current) = id {
+            let commit = repo.find_commit(current)?.decode()?.into_owned()?;
+            assert!(!has_marker(&commit), "repeating clears every pending marker");
+            id = commit.parents.first().copied();
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn rewrites_every_fork_without_flattening_it() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tree = repo.find_commit(middle)?.tree_id()?.detach();
+        let tree_hex = tree.to_string();
+        let middle_hex = middle.to_string();
+        let side = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args([
+                "-c",
+                "commit.gpgSign=false",
+                "commit-tree",
+                &tree_hex,
+                "-p",
+                &middle_hex,
+                "-m",
+                "side",
+            ])
+            .env("GIT_AUTHOR_DATE", "2000-01-04T00:00:00 +0000")
+            .env("GIT_COMMITTER_DATE", "2000-01-04T00:00:00 +0000")
+            .output()?;
+        assert!(side.status.success(), "the side commit fixture is created");
+        let side = ObjectId::from_hex(side.stdout.trim())?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["update-ref", "refs/heads/side", &side.to_string()])
+                .status()?
+                .success(),
+            "the side tip is made visible to history loading"
+        );
+        let graph = super::super::loaded_graph(&repo)?;
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.message = "fork point".into();
+        let rewritten_middle = perform(
+            repo.clone(),
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIs,
+        )?
+        .selected
+        .expect("the fork point is rewritten");
+
+        let main = repo.head_id()?.detach();
+        let side = repo.find_reference("refs/heads/side")?.id().detach();
+        assert_ne!(main, side, "the two descendant lines remain distinct");
+        for (name, tip) in [("main", main), ("side", side)] {
+            assert_eq!(
+                repo.find_commit(tip)?.parent_ids().next().map(gix::Id::detach),
+                Some(rewritten_middle),
+                "the {name} fork follows the rewritten fork point"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn a_conflicting_cherry_pick_leaves_repository_state_unmodified() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let objects_before = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["count-objects", "-v"])
+            .output()?
+            .stdout;
+
+        assert!(
+            perform(
+                repo,
+                &graph,
+                Edit::Remove { target: middle },
+                Signature::RedoIfNeeded,
+                Tree::CherryPick,
+            )
+            .is_err(),
+            "an unresolved cherry-pick aborts the complete rebase"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "refs, index, and worktree remain unchanged"
+        );
+        assert_eq!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["count-objects", "-v"])
+                .output()?
+                .stdout,
+            objects_before,
+            "failed in-memory rebases write no objects"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/refs.rs b/gix-tix/src/edit/refs.rs
deleted file mode 100644
index 6a3e7c616e9..00000000000
--- a/gix-tix/src/edit/refs.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-use anyhow::{Context, Result};
-use gix::bstr::{BStr, ByteSlice};
-use gix::refs::{
-    Category, Target,
-    transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
-};
-
-use crate::history;
-
-#[derive(Clone)]
-pub(super) struct MutableRefs {
-    names: Vec<gix::refs::FullName>,
-    old: Option<gix::ObjectId>,
-}
-
-impl MutableRefs {
-    pub(super) fn pointing_to(repo: &gix::Repository, id: gix::ObjectId) -> Result<Self> {
-        let mut names = Vec::new();
-        for reference in repo.references()?.all()? {
-            let reference = match reference {
-                Ok(reference) => reference,
-                Err(err) if is_missing_ref(&*err) => continue,
-                Err(err) => anyhow::bail!("could not inspect references pointing to commit: {err}"),
-            };
-            if !matches!(
-                reference.name().category(),
-                Some(Category::Tag | Category::RemoteBranch)
-            ) && reference.try_id().is_some_and(|target| target.as_ref() == id)
-            {
-                names.push(reference.name().to_owned());
-            }
-        }
-        if let Some(head) = repo.try_find_reference("HEAD")?
-            && head.try_id().is_some_and(|target| target.as_ref() == id)
-        {
-            names.push(head.name().to_owned());
-        }
-        Ok(Self { names, old: Some(id) })
-    }
-
-    pub(super) fn unborn(repo: &gix::Repository) -> Result<Self> {
-        let head = repo.head().context("could not read unborn HEAD")?;
-        if !head.is_unborn() {
-            anyhow::bail!("an unborn HEAD is required");
-        }
-        let name = head
-            .referent_name()
-            .context("an unborn HEAD must point to a branch")?
-            .to_owned();
-        Ok(Self {
-            names: vec![name],
-            old: None,
-        })
-    }
-
-    pub(super) fn is_empty(&self) -> bool {
-        self.names.is_empty()
-    }
-
-    pub(super) fn contains(&self, name: &gix::refs::FullNameRef) -> bool {
-        self.names.iter().any(|candidate| candidate.as_ref() == name)
-    }
-
-    pub(super) fn validate(&self, repo: &gix::Repository) -> Result<()> {
-        for name in &self.names {
-            let actual = repo
-                .try_find_reference(name)?
-                .and_then(|reference| reference.try_id().map(gix::Id::detach));
-            if actual != self.old {
-                anyhow::bail!("a reference changed while editing");
-            }
-        }
-        Ok(())
-    }
-
-    pub(super) fn ensure_not_checked_out_elsewhere(&self, repo: &gix::Repository) -> Result<()> {
-        if history::worktree_checkouts(repo).iter().any(|checkout| {
-            !checkout.is_current
-                && checkout
-                    .reference
-                    .as_ref()
-                    .is_some_and(|name| self.contains(name.as_ref()))
-        }) {
-            anyhow::bail!("an affected branch is checked out in another worktree");
-        }
-        Ok(())
-    }
-
-    pub(super) fn update(
-        &self,
-        repo: &gix::Repository,
-        new: gix::ObjectId,
-        message: &BStr,
-        committer: Option<gix::actor::SignatureRef<'_>>,
-    ) -> Result<()> {
-        repo.edit_references_as(
-            self.names.iter().cloned().map(|name| RefEdit {
-                change: Change::Update {
-                    log: LogChange {
-                        mode: RefLog::AndReference,
-                        force_create_reflog: false,
-                        message: message.to_owned(),
-                    },
-                    expected: self.old.map_or(PreviousValue::MustNotExist, |old| {
-                        PreviousValue::MustExistAndMatch(Target::Object(old))
-                    }),
-                    new: Target::Object(new),
-                },
-                name,
-                deref: false,
-            }),
-            committer,
-        )
-        .context("could not update references")?;
-        Ok(())
-    }
-
-    pub(super) fn delete(
-        &self,
-        repo: &gix::Repository,
-        _message: &BStr,
-        committer: Option<gix::actor::SignatureRef<'_>>,
-    ) -> Result<()> {
-        let old = self.old.context("cannot delete an unborn reference")?;
-        repo.edit_references_as(
-            self.names.iter().cloned().map(|name| RefEdit {
-                change: Change::Delete {
-                    expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
-                    log: RefLog::AndReference,
-                },
-                name,
-                deref: false,
-            }),
-            committer,
-        )
-        .context("could not delete references")?;
-        Ok(())
-    }
-
-    pub(super) fn rollback(&self, repo: &gix::Repository, current: gix::ObjectId) -> Result<()> {
-        let current_refs = Self {
-            names: self.names.clone(),
-            old: Some(current),
-        };
-        let committer = repo.committer().transpose()?;
-        match self.old {
-            Some(old) => current_refs.update(repo, old, b"tix edit rollback".as_bstr(), committer),
-            None => current_refs.delete(repo, b"tix edit rollback".as_bstr(), committer),
-        }
-    }
-
-    pub(super) fn rollback_deleted(&self, repo: &gix::Repository) -> Result<()> {
-        let old = self.old.context("an unborn reference was not deleted")?;
-        let deleted = Self {
-            names: self.names.clone(),
-            old: None,
-        };
-        let committer = repo.committer().transpose()?;
-        deleted.update(repo, old, b"tix edit rollback".as_bstr(), committer)
-    }
-}
-
-fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
-    loop {
-        if err
-            .downcast_ref::<std::io::Error>()
-            .is_some_and(|err| err.kind() == std::io::ErrorKind::NotFound)
-        {
-            return true;
-        }
-        let Some(source) = err.source() else { return false };
-        err = source;
-    }
-}
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index a5fb0c98e77..738cf96b7a7 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -1,7 +1,7 @@
 use anyhow::{Context, Result};
 use gix::bstr::{BString, ByteSlice};
 
-use super::refs::MutableRefs;
+use super::rebase;
 
 const AUTHOR: &[u8] = b"Author: ";
 const AUTHOR_DATE: &[u8] = b"AuthorDate: ";
@@ -67,18 +67,17 @@ pub(super) fn missing_agent_trailers(message: &[u8]) -> [Option<&'static [u8]>;
     ]
 }
 
-pub(crate) fn apply(repo: &gix::Repository, old_id: gix::ObjectId, edited: &[u8]) -> Result<Option<gix::ObjectId>> {
+pub(crate) fn apply(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    edited: &[u8],
+) -> Result<Option<gix::ObjectId>> {
     let edit = parse(edited)?;
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
     }
 
-    let refs = MutableRefs::pointing_to(repo, old_id)?;
-    if refs.is_empty() {
-        anyhow::bail!("no mutable reference points to the commit anymore");
-    }
-    refs.ensure_not_checked_out_elsewhere(repo)?;
-
     let mut commit = repo
         .find_commit(old_id)
         .context("could not find commit after editing")?
@@ -89,34 +88,14 @@ pub(crate) fn apply(repo: &gix::Repository, old_id: gix::ObjectId, edited: &[u8]
     commit.author = actor(edit.author, edit.author_time, "author")?;
     commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
     commit.message = edit.message;
-    commit.extra_headers.retain(|(name, _)| {
-        name.as_slice() != gix::objs::commit::SIGNATURE_FIELD_NAME.as_bytes()
-            && name.as_slice() != gix::objs::commit::SIGNATURE_FIELD_NAME_SHA256.as_bytes()
-    });
-    if let Some(options) = repo
-        .commit_signing_options_if_enabled()
-        .context("could not resolve commit signing configuration")?
-    {
-        commit = commit.sign(options).context("could not sign reworded commit")?;
-    }
-    let new_id = repo
-        .write_object(&commit)
-        .context("could not write reworded commit")?
-        .detach();
-    if new_id == old_id {
-        return Ok(None);
-    }
-
-    let log_message = gix::reference::log::message("commit", commit.message.as_bstr(), commit.parents.len());
-    let mut time_buf = gix::date::parse::TimeBuf::default();
-    refs.update(
+    let outcome = rebase::perform(
         repo,
-        new_id,
-        log_message.as_ref(),
-        Some(commit.committer.to_ref(&mut time_buf)),
-    )
-    .context("could not update references to the reworded commit")?;
-    Ok(Some(new_id))
+        graph,
+        rebase::Edit::Replace { target: old_id, commit },
+        rebase::Signature::RedoIfNeeded,
+        rebase::Tree::LeaveAsIs,
+    )?;
+    Ok(outcome.selected.filter(|new_id| *new_id != old_id))
 }
 
 pub(super) fn write_headers(
@@ -366,7 +345,8 @@ mod tests {
                        CommentChar: ;\n\
                        \n\
                        rewritten title\n\nrewritten body\n\nAssisted-by: GPT 5.6\n;Co-authored-by: GPT 5.6 <codex@openai.com>\n";
-        let new_id = apply(&repository, old_id, edited)?.expect("the edited commit differs");
+        let graph = super::super::loaded_graph(&repository)?;
+        let new_id = apply(repository.clone(), &graph, old_id, edited)?.expect("the edited commit differs");
         let commit = repository.find_commit(new_id)?;
         let decoded = commit.decode()?;
         assert_eq!(
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
new file mode 100644
index 00000000000..33e89295f05
--- /dev/null
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
@@ -0,0 +1,56 @@
+---
+source: gix-tix/src/edit/rebase.rs
+expression: "gix_testtools::repository::snapshot(fixture.path())?.to_string()"
+---
+HEAD refs/heads/main -> C2
+
+[refs]
+refs/heads/main = C2
+refs/patches/middle = C1
+refs/patches/tip = C2
+
+[commits]
+C0
+  tree T2
+  author author <author@example.com> 946684800 +0000
+  committer committer <committer@example.com> 946684800 +0000
+  
+  base
+
+C1
+  tree T0
+  parent C0
+  author author <author@example.com> 946771200 +0000
+  committer committer <committer@example.com> 946771200 +0000
+  
+  rewritten middle
+
+C2
+  tree T1
+  parent C1
+  author author <author@example.com> 946857600 +0000
+  committer rebasing committer <rebasing@example.com> 978307200 +0000
+  
+  tip
+
+[index]
+tree = T1
+100644 B1 stage=0 "base"
+100644 B2 stage=0 "middle"
+100644 B0 stage=0 "tip"
+
+[worktree]
+100644 file "base" = "base\n"
+100644 file "middle" = "middle\n"
+100644 file "tip" = "tip\n"
+
+[objects]
+C1 = 347d88644e1829f6255a5d6dc8721a29fa8352f4
+C0 = 5295d5ce934d18b6a1f48c3b7d836d53b55304e5
+T0 = 559dc660acc84805fedbcb75588371240372c173
+T1 = 569961a34e2a909d8c7a2940ed4ad365504e64ed
+T2 = 8552142164d268c95f60dabb74465a2f4ffb51b7
+B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
+B1 = df967b96a579e45a18b8251732d16804b2e56a55
+C2 = e2722ab1d7aeafc5fb8cddb4a8e504cfa7855b85
+B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 2aeb3440df0..6ae03b4394e 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -194,6 +194,68 @@ impl HistoryGraph {
         self.parents.iter().map(|parent| self.id(*parent)).collect()
     }
 
+    pub(crate) fn parents_of(&self, id: ObjectId) -> Option<Vec<ObjectId>> {
+        let index = self.index(id)?;
+        Some(self.parents(index).iter().map(|parent| self.id(*parent)).collect())
+    }
+
+    pub(crate) fn commits_with_merge_descendants(&self) -> HashSet<ObjectId> {
+        let mut pending: Vec<_> = self
+            .commits
+            .iter()
+            .filter(|commit| commit.parents.len() > 1)
+            .flat_map(|commit| {
+                let range = commit.parents.clone();
+                self.parents[range.start as usize..range.end as usize].iter().copied()
+            })
+            .collect();
+        let mut ancestors = HashSet::new();
+        while let Some(index) = pending.pop() {
+            if ancestors.insert(index) {
+                pending.extend_from_slice(self.parents(index));
+            }
+        }
+        ancestors.into_iter().map(|index| self.id(index)).collect()
+    }
+
+    pub(crate) fn descendants_in_parent_order(&self, root: ObjectId) -> Option<Vec<ObjectId>> {
+        let root = self.index(root)?;
+        let mut included = HashSet::from([root]);
+        loop {
+            let mut changed = false;
+            for index in 0..self.commits.len() {
+                let index = CommitIndex::new(index).expect("an existing graph index fits into u32");
+                if included.contains(&index) || !self.parents(index).iter().any(|parent| included.contains(parent)) {
+                    continue;
+                }
+                included.insert(index);
+                changed = true;
+            }
+            if !changed {
+                break;
+            }
+        }
+        let mut out = Vec::with_capacity(included.len());
+        while out.len() < included.len() {
+            let before = out.len();
+            for index in &included {
+                if out.contains(index)
+                    || self
+                        .parents(*index)
+                        .iter()
+                        .any(|parent| included.contains(parent) && !out.contains(parent))
+                {
+                    continue;
+                }
+                out.push(*index);
+            }
+            if out.len() == before {
+                return None;
+            }
+        }
+        Some(out.into_iter().map(|index| self.id(index)).collect())
+    }
+
     fn parent_ids(&self, index: CommitIndex) -> gix::traverse::commit::ParentIds {
         self.parents(index).iter().map(|parent| self.id(*parent)).collect()
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b50b73039d9..dd95f7502a4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1236,6 +1236,7 @@ fn event_loop(
             match result {
                 Ok((graph, result)) => {
                     app.set_known_descendants(graph.commits_with_descendants());
+                    app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     history_graph = Some(graph);
                     let result = result?;
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
@@ -1399,6 +1400,7 @@ fn event_loop(
                 Event::Complete(graph) => {
                     history_finished = true;
                     app.set_known_descendants(graph.commits_with_descendants());
+                    app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     history_graph = Some(graph);
                     selection_relation = None;
                     app.selection_relation = None;
@@ -1689,7 +1691,20 @@ fn event_loop(
                     }
                 }
                 Effect::Reword(id) => {
-                    match reword_commit(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
+                    let result = history_graph
+                        .as_ref()
+                        .context("reword requires a completed history graph")
+                        .and_then(|graph| {
+                            reword_commit(
+                                terminal,
+                                &repository_path,
+                                repository_is_bare,
+                                graph,
+                                id,
+                                enhanced_keyboard,
+                            )
+                        });
+                    match result {
                         Ok(Some(new_id)) => {
                             app.leave_message(format!(
                                 "reworded {} as {}",
@@ -1704,13 +1719,20 @@ fn event_loop(
                     }
                 }
                 Effect::NewCommit(parent) => {
-                    match create_commit(
-                        terminal,
-                        &repository_path,
-                        repository_is_bare,
-                        parent,
-                        enhanced_keyboard,
-                    ) {
+                    let result = history_graph
+                        .as_ref()
+                        .context("creating a commit requires a completed history graph")
+                        .and_then(|graph| {
+                            create_commit(
+                                terminal,
+                                &repository_path,
+                                repository_is_bare,
+                                graph,
+                                parent,
+                                enhanced_keyboard,
+                            )
+                        });
+                    match result {
                         Ok(Some(new_id)) => {
                             app.leave_message(format!("created {}", new_id.to_hex_with_len(7)));
                             refresh_select_top_requested = true;
@@ -1723,7 +1745,11 @@ fn event_loop(
                 Effect::Forget(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    match forget_commit(&repository_path, repository_is_bare, id) {
+                    let result = history_graph
+                        .as_ref()
+                        .context("forget requires a completed history graph")
+                        .and_then(|graph| forget_commit(&repository_path, repository_is_bare, graph, id));
+                    match result {
                         Ok(parent) => {
                             app.leave_message(format!("forgot {}", id.to_hex_with_len(7)));
                             if let Some(parent) = parent {
@@ -2713,6 +2739,7 @@ fn reword_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
     bare: bool,
+    graph: &HistoryGraph,
     id: gix::ObjectId,
     enhanced_keyboard: bool,
 ) -> Result<Option<gix::ObjectId>> {
@@ -2736,13 +2763,14 @@ fn reword_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    edit::reword::apply(&repository, id, &edited)
+    edit::reword::apply(repository, graph, id, &edited)
 }
 
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
     bare: bool,
+    graph: &HistoryGraph,
     parent: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
 ) -> Result<Option<gix::ObjectId>> {
@@ -2763,14 +2791,19 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    edit::create::apply(repository, prepared, &edited).map(Some)
+    edit::create::apply(repository, graph, prepared, &edited).map(Some)
 }
 
-fn forget_commit(repository_path: &Path, bare: bool, id: gix::ObjectId) -> Result<Option<gix::ObjectId>> {
+fn forget_commit(
+    repository_path: &Path,
+    bare: bool,
+    graph: &HistoryGraph,
+    id: gix::ObjectId,
+) -> Result<Option<gix::ObjectId>> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before forgetting commit")?;
     repository.object_cache_size(None);
-    edit::forget::perform(&repository, id)
+    edit::forget::perform(repository, graph, id)
 }
 
 fn run_external_diff(
diff --git a/gix-tix/tests/fixtures/generated-archives/rebase_conflict.tar b/gix-tix/tests/fixtures/generated-archives/rebase_conflict.tar
new file mode 100644
index 0000000000000000000000000000000000000000..9a97d11f4a0c7c67b4390c173315197017ee57bf
GIT binary patch
literal 70656
zcmeHw4Uk+{b*2ms#WV|e2`nU)pXb)#nUSV{r+-Exk8F7)+hfa;kw(ZwBadHqzn*EU
zr(e5Yw?>03Z&D<cVmAr9RDNp7RuZz1rAV?_V6%i;Hh~aa3xN=`37Bk_r8XNv1;gS^
znW9pau-|vieXn2tXnJNeEe!51ThsmCz31M0?m6e4bMCq4#uNL7{z>AK&t~`WFFxIW
z<yk73$)%F%WO_#4=V#K{ec7S+3=Oorrroft>uySh78=}j1H3T+;;WVBuv;Q(b~^w0
zY<e{R!=4zx=lmxYPCf9z;?m0TV~a}<oVjPuTjl)cGMR3^_kZJUW?v`&r_!lZdS7zS
zd(sEs3!ML(m3pKPRz{CrAQ%w-uhdG;<>3u@5dVYOyZJwrq`ok`F0~=Q!1@2!;^_q-
z<3;%Yrbn;7_phw)-#_pFy=mXRTVDJ5J3q2--%q>?ub)GiSL6Si-~YO=elhX!55Dcy
z@4fl!|LH*UeNV)5SNGjqu2dbo#b@dC@#FaO1N%}|GUC1J@*m}`g|ANU`xhHePaOEI
zAN|SqZT#T3KbLy#7v6gF|9;npUh&djKR);D#edk8nxlViGzNtK8&269V#DPBo#}t6
zWF9hMr2h|bQVi%|{u51mbx1_8i}_FGGWpT`4}bbq|0n+^)*QPu90J(Q{O9u{`~L<^
zfA{<+*6m7duiNGPZ)yK!d-T6_K9wKoe|tR<ec<JDMf=d9*?g&#nMv8Rh1r6WPTJYD
z?Kq`uGM6ispo-6yosp5)2YKHEk7WH{bKQ%>5&eRp-N=6^jHC7c2GCb~{uA|<w-#%<
zvErIjyy&)?anD|_`!?P6bY;N&XJ=;e-S&Srn}@&fdK%qs-50q1zyH=mp;AkDYmvx)
z>uAk#F3Y4_6bY7BY*gw^tLa*;ddY4&mTd`fIHefq!)i7h$8u|U3MaBf@`*?G1I*G|
z#Zv(ITd7@gFFGZwu*p)fhEsGZmz-GLE?%5WO<5ajPR&B?hGQ3-9-Bfbz#ufsu9Zy7
z9txD5hEpp#lin17q7I+cU9Zw~8=KQoR)96v9H|W;%|^u$n5O%DRcP3?;+oZ5vzr#W
zS8O!^wOQTtM`m$kY#4<B!t^&@a%!6kTJ|o5P;_hM%4(}&H!HxwCA(3v3sr|OJ%>0$
zWo>q`<~5;PD{k)Ev`S9dZdIGpme)c@Y#l19VT3IYn5vZ7wzc6lE>>!*ie=Lw3>=<1
zKz6lE!&!GREp0qlYqp2pqmfG4;L9pE+;xE%j1>UPJj!T`?)rMAd06M7;5Lb!t=hNN
z?PhTeKv>KGwG_xSpKV%p!!d&g9$hUjrEAUxP|eB3K<Rr9hNANl?<5}7EdUa+g0Jo+
zr_rdC9D!u82ml3V&AwD|TaCjYx(x?~v|}zx7M!ZP0sK@b$<{H^AP02XRBl%V7$VN%
zW?++8ue+66(<-|S46Js^sZ~(dT6clgN>OIqCv`_D-O!1GS6o;d6`*osts>-xURUb=
zycwji^GZyZ{#CSy+13#YyOri53Tb{kMfO~5T1A^I3VspTwpDX$u{S#nmmP1mgw~ae
zWSGK4lRk@;T*m_x&z&a2twZpkx*61_lo#r<Fy`+0pNdCH6~~&KvaUqNoZ^~m9l0%S
zMaK_B@sr(2MXs`kry2y!POjS*Aud3OH88yA*$pz7U0YRt?1rxl=dxWu(QXhE4MEA8
z1NxPhm^iP}05x#9AW;er!Ww{D<wKz%mIe_9<Vwa0BQ%6eo#DHI4kHwWxOKWYM2|$Z
zX*F6kk$;e2rI?7sSj&p7TlXG6dJHH^MP)?5YKesDTF!c_%Fa_}mK`t>Mxe5YkRaLE
z#RkdP1EFHHMG6=Iktz2jEd-v@T64qIRza)lq%W4}?n{Lek7)oASL`Y}%{H*SV~Rj{
zsNexOdV;a?m#+b6&-9(pj#4Y;5L69WchPa`W`?Y)TePde9GhWu$S@gZiE@!-2ljFr
z6j3@Zb|@sX3QlvwF_Y^z8YhJ<p`0=`SjGlNHk_E-h*dE-PE(Pql3nwFVM=A78<M74
z_4#fA^Ijr}k+G#omBnpAAa8(!2~VU{SRc}vhv=x(D5W_i1VJWSX}T*Vr(Sh8!6M~W
zO{R=<S!h+NkSB@ovKKEZWu2tx7Nii2EVvsL^c51%x$G2MO|%lo?vRLAn&6^mP#F{o
zqZ`YM%cW$~ZCM*Ogcop82gZd;@I?^hVfi-0=&UQX*cpgcbkeo#k_}A&k0}r#SnXmF
z6phKRV(oR}s~8fOc)P@BR<u~M;_)cyspauO!{LkoRNZc_d6-G`>{g*Q<;|G#eC#nR
z7OSk*IICW(0D0TO%;Fh@TEl^o0!-B+W0XbFvvp36s3k(LR@nwkmZFhzB?O){730<f
zp*+^AU}^5(LKyTpv-Ad-mSwetb=+RXq!>Y_Eg5x3sIlR;R>9680(8rBq7qpa-D@jY
zomZe7QDXt2++js2B%;=wb^L(`m)^9(jgyr#_a05H+<W{XqDYw0Zpr|xn4>Z!eI!wG
zE+uNMYSna_u;&RX;#55+GA6&rCs`XUuEpHKqmUw2%&2U!nAgNKS+@sprurbw%t(N=
zq75{c`eJXK4dTsU9QMOtKnmSbD>|;rUo;GN!EIGbB0-E&7baX%Dy6%im1Ekj74U*B
z7qb5ppL=HYwNX02{>vlotK0sY5r1JD#PGh2>_21w(Q>=C0a(ELe$i^x>>3tts4q~a
zuwSI>6SNA4ni|)D1*jKziKQS)@e^M6qDE<LthPiGpTpa7jY^2OW~X8<*jm1Tfz^zJ
zu2d77s_7e))2Jdf<O#((IX<eC8`WiXLF_VgB_<zy5%*Rc9dkEA1HcPQt&M`~RvjvI
z4$K4Slvrf2ZgmgUUz-IEh6n}5S6D4{%eO@1mescLs32^@lB-QLv8)q6p}v%ys?&6U
z#sNK%a$H0O<GtNrBLZSKoe+~|b8shYwhpa+lj@1uLBN4s#>`tq2yUud@zBVnLm+@H
z$F7>)c8BllfgmH*lG-z|TNKc$m)<+u>WZ4%^cBd6F(o~H0>p|_($V{>{Iy5}Is?@P
z(xoHr0aOFcS_`npX_r)?XhsZ=%!?%f9)V?m@9Ag+Y@*+1qEw7o@r(_F!gw;MKAg8=
zZ-xnS4`TZe=Ml9o944ZmK#2(#JtlNXt3%kyczXhEl8dk34d`;P`2332B!K&h<+OY&
z%ChXW>NJT=gVGr7qt43Kc+$EZ!#ZN!uH(TM9n6s_zogofMw2tcFqnv1F;~Z>wcEcH
zNY5}^9<;W(En4ku)Sm}>cp}|`V_r2Y_5T3x&CR+qPZ<(s?vVJHQV7cKN-*035w0*5
z=_b`dAiB$U^a8v*sJ@Ik5K*RfAT734J19Lx0yRoHOoEzAJ6?Q?v~24Qm+C1W0W5tz
z&~ztKk4>~m7m8|7J~|aC+Axiy<DrUC+GEkPH7*XNkTi}SupYOfsA5R|z<~qSgW6uW
z50)$?(3MqC!|=pf&`B0!hYv>_&o27Bwm>hr#kr?#4SpC`@*_)A;fcrN{6k+0Y)Lpy
z#mUCyN|B03An1664hMtH4qd%RN5?>#4Qt|jGIq$0l`l+K6Um7w<?^U$J8I1XErb|i
z0`1m{P^mU;tc36jL(+k%(e#I-mVrUI&w<l^g924>KZbXn#E>KoOzT*I^fCBAYq1WU
z0S~=3x6xcNz~;xVm~Z>{w_#jGF%e+V@ox5uTDM}9%|^=!4RS0rze}*DyIY;M#yeWY
zw0L4f80kw}U4&qJ4K>prhI|%eH$k<AYayhPjX8;V7Un|y2~>!DsmO^2eb((&C`-Qd
z1S}P7V`C6)V<f2#yy^5P-VBv+W$r|UzQFT=h&V<CgNlPL-a8oamc2yN+Qsg94Nq9W
z`yIWsZo5rvS}a`H0ic6x+)Tc8#0soYD}Cg)6h^IURd@oHfcFW%$^@29nv9!t;CW3i
zgk^dtqvZ7m=&{}00S-by`Xhm+uGdB5MtKP4$zPb-+z3*Mj(3Y>Vb?7PdBN8*?2wz7
zzO(HR?bf~TLuuWE2rU5ms$(X7O(HxyA$rpqJ7Kc^{Z);t8{hD-6lHHD=ySkH?FxN{
z*jq15vRYy1W9@=^U4uTLoOQIe326k*r9TJSmbiN1DuqM6{rnD=RZWhhepa{WXkg4i
z{#~rO8<1&OpXmHFz7hx}@LQYdxQ)aTX8kbYTr|D5sOnny?yl4-+`fs3EK81DEW`6n
z+yKZS|4$uGS30xz+yg{CXp8vYbap1!?f=Q7W@bkF|2JU%x4Hk1-6*W1aE|Csm0ghi
zf7z?l&0M%WI$b|diuopLd<5!>RwDo!I+k`wBH6swoy%!#mC#25MJgobpb_I4ELH^u
zE7`IZx%CZ+Xv|egA$V=L)!Mrqip5gIsP8c_eeI1>z}^+zRsx27E4#GHDS@G;z@~tk
z!&6WGcnT(;b&_tY&P{m8*7ja68{$Gxa0sL1!jRu@ji*`l?CBF!4!16g(ikV9us*v*
zgzH`khH0!E!5>~>jj(;MTHqaV9&6cEb%`z3xb34`VrJ?vM%B_~FOP8uz`OQVk;LAM
zIS+RRcM0i?;QlgtMg(EjY9+ftH&`7#Gy8pP#^3O`U3Ubr-oU=s?{1}p?`Gchh55lZ
z?OD;lBX|Sd4F-~Is4|T$QEX!gW`X&3@41J_E>&GPsJPd>D&1=|X_(23M$aui7_}z3
zQ^1}=FJHxOl80SwxL1fo^{%uURduaguTd7!?NKVHx-Uv&$9%&`4du&2ZGQz%BiI_H
z&C_(SF&`ZljPZHMsEhb2@qX)Gpda2()mfki%)!Eyy`K<>HtY@<J`fmZC$U$e3J*5%
z5cz{SrgG^c7jVb0nYBv%wEIJ?Lz@Bwqji9wMF}Uhb_0Z+*$-g5cky^9bh>?LI;x3H
z(+cxvK;VVWys?>SNmQZzTd|r&&cwvlt%-+Gf$jt8Jgxr#D=609R_Zb_B&OkRw*}W*
zyFn6+=^iF=T8u`+mk53UD#D5@dM>>F-J=_It^YRtci5vX?xhwmVEs?#vdQlCKRc5e
z#sA%a<$qs${oi{3XA1>D`4L+}5Vs5g2uMhGhp@5Y#Bi*j>I-LGla?T{CFTKAo;$k2
zM<T7eW14i6q2hThN*9~T0NQ|W1rc|MpzuXLL?`zf5b7XdP}pRz%d()|GmUP0ONq*G
zdnDLeip1%;h+#J!uEACvUQ5RaqNqC0+CB|PA(UjKgL;G$1g3?ju$N8w9=i-N6o81*
zFT$9Q&WGbyQU{~scSf&9=7wfvb@BhY(^&QUx@UI4K>pA4@;`!tNBaK_5CD70|KPDM
zBLK_^dNLcoaQg>ZD)jg+0f4&O7Xf_*fas=(Y(bDH{qcQ;f%M0y61x!zVgBeN6xzIP
zw!jjy-y0GDWc3I(p5<d${+eZn$oD>Jh56t0nlW`0?HTJ!GlTd)ozHf!|C!u~|NSW%
z>fi11Kh`Q(!mtit5EmKG-`*&Z%@4$AOMEuixYSxNXb@Z-`#cEtlQRL^UwPYPNDdPo
z;hu|9CRX1DbP>c0mffK(ibKWt^9y*G|8<IurV?BCR`*B@4B-ECKHZc5Czs5R&VSwr
zO4%v@)6t@;Y}nt@XXV#IX6a`wiQ6(RGmYG$Gm#!XyoJ~>P>ni2ZCr4WG_WaHKNJGs
zd)~AP>Y7T}X!j7ITy#R}1)kMg4TRvx(H#0IN)RUPVYF*Y5P<JsG{y;Iim&BeWcYO(
z4*g~Dtu<f=?O5XVFdhY8$2qE6vDyLx&>qiRnezx9Ps_kpS!uwcfQwQ5N|&S*5gOfZ
zJ&3qA3|s>A!hJRPLX1Kbfyvdnk3iFN0QF$qzz<SsHw^jSYSPz-Ih5EwhE~Jl!g)oo
zf*e1IHT1Lt&`it(bNMI_n;7RVUr2qegCKDMOT_a;7CO#pWtTDaPSNJdf*IrK6-H+i
zUF=thofwOuW%LpLA^GjW;VBzaJ}vo64;q9U7`{q_H%6&5B;yPs&3Tj!5#pdRIymWQ
z?C7|J=i{&kdgV3!;Cv8}c%ql+hQ@ylER2YH!ZA441<Fc}jp;Kv)sRnZ<?h83$9aUu
zJUVmg?CAwONJkjzJwHAZi6mNHL(btLFu!WWD)EAS5gsi>8^Fkg)3a6M0f));#KZAH
zbDD_9QEdNsVu}v1u3ku_m<i_S=*{#v`y!DX2#cJ4yy@U<3#{wuDU2MS{vE_jOz3+Q
z(Vj+^Yf&q1J;D{+5J(U>-bpEspyn7Ab@Vnt19)5r`QSloe%?y<>%4`XNc85wlz#D}
zan78&%QypZ2v1_qbZAS*Pp>Q<JAQHrQ5q6eRI?_$#KX&z@dHPer{V|36CDIFXDz1^
zb%fOHmk<Rxp8~C?iPJSaSkT}Bf=Vq0v=kkDHBW(Kv>)w<YKaO`i-1vh9rz}jfY3-+
zTOl`uQy}VA#n1{V_29vN7y>xBAa}BEbguvY@ytD1_)SL!tp7;;*JJ-@vbmA{zms{~
zZQ1Rv|8kyBlziQmvfMgDeko#Q5%NW=ITXjR1S~|{OVAA)Ee)E-nh(L>Feex%Sg-(#
zVxEG8(WVWD!GP_mfD#<@i|Wg07$yZU`n8)y*Qa)_wqP%1RqhYaAb;@enR{1GJ-D=Z
z>g3A8sk0}S{8K2E`DA2FH+ZB*bi9HP)GGIEu2FA{J3C{}C7h3o;-8i?zuZ$4Kv2er
zW+|j$brRqq2$Ikc6Yn8WA3>ll-HU#py@r2`Ul9=d56oW;!q^xhgJ?5imm4DOjSG>Z
z*dc)sovc^~t<)6W%QnUiWyx-7a8&O*hk=m%FMI25ji>2j8{7aw?Drlm16#}gR4SG0
ziT}u@lOy}@Mo<Ohe^~d7L@47uBu*$c56kxryHUfwi>JR9A6%H5J5_gT>BF>8u6<sJ
z>eDI?nL5@vLrf?>xz=pfy}3l93>^v)^A|~dYpp`O;wF5WOCTo%9*PbIZQQFP5fOYp
zF#np6T<8hla7USIg#?*0K0yw6wv89rSHikbw{hed(F+z2Q}aCVWRL>EN>2%hstwB|
zh>p7`8kq)5(EfmN%A5dl44n<Csbcn*N({+BFa|mk20*Y}%dqrGw{*>ubF>U)X?Ge2
zW1&gX+z3~Pf{%?OPtNB93{KkwXJ?IZ(r^(1Y7FU)!;kEtM>ieNE@m_O4um00;N;m8
z20Pn!!#&n=8k>P6Kp2kzXKD_KfHtQea0u9m2ZF;2Nt4d{SluJ*o7UvGnF+*W6Z0!N
zavYxq=BE(7e&^BC_q<U^>uk-Kf#O~)Ifd5hs?NSD#b=g|9Y1{<i*C~Lf%bt3Yeb-#
zXno*XX+sX5Q;|3Q;rbtR4pU0<K&k^hXk23)j9B)Tj;cLif#y@!gx`^gxL84vF`7=%
zyFm)*xy4nS2Brslk}L)5Te^qL2|&#_SYd_Jxgt3P=B-snf1~6I4kAxZVIV9AlLW~W
z=B<?Z{ix^GR_Yg5aXf(<2728<=uZW{+WXF&IypD@&>1ZJ<9;cg5b&P^HDiEsl@@f#
z?XCIXgZ*nh_#kRtMe|h~N8Q&}eAbmN;@Gy;^_-B|a~F;KWmg1~tijL>M7XxcuJD}F
z<hVN}voNM?hj<wec~kH>cH~MC@hBIsPFr_gk)Oh8SFaM>Ri>g~FFI<OK1_~F#Yzb^
zrH&BY3dX`%mi{Cc^w~gUQ8*zWO*p9X+O!ot62(74{QmfuAP3HpIQ~T0D{yk926=^8
zTd6VEYL;h#M!ZmZ#$yn(>D_WodnfdPB6tk3j3Vr)4+tD^>g*C44qzEb1_*%r_G6MQ
zX$;o*G)Z7tp6F|B3Nxx`^GC2EVEnlQ?(0zZ9aMhoav-ePF%WgMlX#;Ev?i=`w;ahQ
z(Sw>zVZ=W{5>Iqi2{>kK0K3RZn>%;}BuQL=8Cnel==kIvI|6YWJ3{2fj+EfTDmjzj
z80|aep?i!%h5i`p=-RwYZF+L~z{0&Jj;#oS&G*HV)7FHK9V_-IeP3>jE`sJJ+y-Oh
zA|@svZKRn8LI#h6XSW(@Fkom(go}D=P&?*a26#`FE=_u|;Y@H7#*^rGMn=)6f-DZ@
z&{{*9(i8<)4rGn#m9-LW$)f~;5kcyu&lTIJaX=uDC2ZIt%>z6^2>8ZARq>`R?SKX%
ziYHH6h+=+g%qf8$VX~=1;3Z+uE~yna;YdW{B9VSLl!9CYkb$L&ByXr;j<C#Pd5M-Q
zPPODkS*%(?N+KVK@)94DXZ<nPs+-~ft@U=QjW+;ukQW7e!{|)8)j+o-r4JT$WV)2q
zSH%h}SrJm<Wl3Cu;1+TZr4*zJ>P_~dbK1f|FJ!ZF9z*Jjs0yv#Qo?wMr0ZVzmZgEQ
zju)os#~wQm;!zxfl6tC6UqIJzSc;NJNoL-<{r2eC@sr2c>9O-sc}nrr$#8gbr2`xr
zq*>@s!kl$JO5%!Mn3l&Ol*%i&2@vO_Sec}hk$=$(7f|{t{y`766sjbifSII|oT0&T
zRf@*R??$e+#iwEb!|oE8T0;1F@ua~MN~usakMUa<*Fem1MKmHaaoD=u7Y9eU@S%lk
zEf&GJK>7-+J+5mm7JkudjLU!BJ2VkE=ZuCuC!TY1l8Qwrfrz;<3(@vukcd~mIU#3~
z(V$k4<IS#8uFIMSI`tuJvr%<#x2sw6Prxg@d<E;su0?!5jlu|eXb{p-f9;o<N7M*}
z*F3Zoc?T6ko?y0x^^Mwf#7c^&8rR~)wfTxJuP1QompR}dsDJ^tihMVstj7;vWq>4P
z-WLn*XC$!G(}%(UP6;;86|jxA5sRV8Zek3txl*ZzpSk9CFS_Ei3z$snU31~xhOXMN
z_@cjxDk5#W>n|#8f#_~R)3UxYy)D&1pp$I2V9@|0+J7lKSnz1!K%wgvGWdPY@F5IX
z7=Lzk!`@_8KhaRy<{;BjLH6mcoyu&F{z0ylQdHj3ER8Y=m^ttTf&mFNH=|a$ibIf~
zFs|36KgcQ65CB036s+vJu_Saa6lVH7wXJb9jM<?!Ab}+XK;7Py`fRy~@C(K~6Fllx
znFkW)H_|iWKm*q7OO+DN705!26;tT6L$4Q&Q1tq(rW!T7gvxczwa!gn17R|nh)z)h
z?_6KS;uLldj0vF{wV}E#7-(}81ircn)f0<uk6i2=!T@bgcqyP(GxfB_R15F2{*2@r
zH}*aaLi9n5)`w3~Tu!Weo8E-=_~X{Nc~IP3#Q~NHBU(ZgG3s-b+Dv+G?jEPPuu(FT
z)luRJ1n?x5mlMkg%9X2n4)Ka$Ky6FZ!;7(ShX5B(=jMtABr#;h6)wgh-U!dusEzGl
zAmp)Whdb|K><{~}wf`4q1AEW^WoOc<QT*?ACh$7TY<K@pvv=qM!ECYN=pUp*fcp+{
zI&^zJKcoLc;l>hTg5{V=ceuiJ#RK_4D`th;S?pqa^kktv0m2%wgm*YmCHeWbI5nVU
z38>@LKma0qY9RD*XQu{2{LgJfg|kQdK0av<;QyIauIK)TOa?i@NBO^f3=Z$_cKIK=
z<FyU|E6p$@3jE)B2v`i#3Nq=KgFVAN08lBT0}xGnc?L)aXCefs6NeerAcff`t#(pQ
zO<w|0i9}mS|58EP&~S22ob1IeE7I^9<jg^_M<AUk36&lhg6qiQrP<Xbb7vcl3XP6L
zK~U2f6BuMq(TqKEemI<rMkF5m0kzoCGYgB0BHq+_DCx=>$`<4>hg4)*lDH<WLLJ*H
zRu~^Z1Z<u6$}cP_pH4%z((E;k0ZLmvpApxv?i4dkkZ2k%()Tjpj9YI!pQ|w-O@{ZO
zl6{G%X8ZL0Fv`lYU;qKa*VUb=$Cwf1rvjdfRy$ffZk=NQC35v*EPRE%NPa<F3Vs2O
zc#Fi0m(!yftpW$7mi7?-4kKv|n`}kqzM}<(UYZzDgb0>^Ht6N&VW11jeS~ymPqA<a
z1P0&9jtsyix(3H*5n#^<7^IU0bR_R-AjA--aOpLGH3ko+GmR}1<dq^2jvwO_wH(_T
zbP98`$}Uu@6_Sx_opGzkPVZT%B!Xds?cQc%3OR!5A0`xHf&rB9E}ITuJx6>C0(9%#
z>j0QCZCK+oh07Mfld{h!U4tno!7xf9BxpaQZ>%%?&xO|(j&msiXD(1Uf0WtW#(nyK
zoV#Wx7FLd)I5EG#p~p%{dS%6)xUh_%z{jnPq7^Gn$p(N)3yXa0@OdsDKXrHHIGs3i
z*3l;87cpVXTTBdgl8!i#5%VMQo6O{`L8c%(IB(Vw(%DXKM-ViORDjhT7ir|VeSy3J
zn0%jN;X95jX)*-CJj#H$fN{HYsp7R=LgY84Ik>S=XHgqssuoSHK!)WMlq45Cf3bTd
z9|oCJ6)|zZ&qZ*OD8!Q7jPx|mrB8Lj#}T5&kN4r>Y7q_`0rLjH39yEMRwZmPNa5yJ
zmnn$?(XpU!?q7y{@1%NeZx}viA3En;lB31^xeq26DT0T$l#L+o0s|ra582^M4iD<a
z#G4D|-XlG5fc}@s^xprROO4Kd?_xH0UZt)7K`LB3oX4jK$WqA;U`;{<B)HVj=ZUBj
z-n24hLi_=Vv_zQ!!EmW!L!%L4A;uJBibPH9_}q8+&?lNOhYKjJ(Mq868HGT^tTfB}
zVq}+7)dJpuu+vzWUe16*$icKT{mPvh;`fym&Nr8h)*x7#B!(!@5z|9Mk%3Ee2IHK%
zOU;$i*1wpfRmVo7W3T&(->5&s$tlWL6|q^oR|j*Ur!;uE1{W#nfpP07bMgY5nKB7`
z!c8;0g`?cUO$f}t*_`qNh`6I@CJ~#+gvgoHn=X8q0Olvq(R?F*uq`^=PLyNxLSKo*
zN~J>;_0lyv(j9};3?NjY(1Q8FL@A<-abaRyuPowpDo9m9B)5xIul94z1QQhZ3H7ul
z7n(E(ox`{*h#%794A&}t8jZJWP_0LK^zAgRcA(nF8Cp7Z>=YONqO&HO<^JiQP(}io
zeDu-3B7sA|TFyzSA)1Zag5S-RBE9k}$kRw=5^iSrSh>z>LK^60Y;G>-fS6IBogn#v
zX=;);FfdjQ8k#%;?;*R*7`1qMl!N9B^Y*rL96?UNxUUBrl29_$A$E`-U~|z2fyQQ_
z>9WgFI-k|wONDZK9jCU+zyfWL^>ipQ2<dFRUhO*)B~*j5oi#^|2N}N&t+yM63XNbE
zUfBUX8lfW;U|w?*B^Axck<%>3!@YqNVibX98sCF|BS9Rx29uw`F8c8YjxL^%GejDP
zejJIM5&dP9UuBza)65qmO7!R-w}7ri^;2Svfbp&cMeN(HVSsZKj4v|)YyBd%a5Uar
zufq<cA|G_2tztZ+AFWNA@*#-o9xL-+2|+*UFDe@elyf+7gC2XhScUnUyae`6`GtSW
za>ichGq6=*|B+>5G+}~H1j6E+5uRcACP}W}n{M3nN2m{oHaOV<+^h*2gEoVK&sm~t
z&zUeG$_Ol7a>m+kvoirP*cdmEU>;4n0Qr0F)am=>+K>otTnS?b1}14q(jnnimFUCb
zWRT1x7EdeTS|Ug@cqqC=gS^r7PQjZF86^cUI@5qyeS?U#@B5`wOGi)my$D$`v6u{V
z&{WZaMhp*<J#`Qb$pG8#F?du$=$NpMKeV_cbRLXK1;`8il8})8PycVjDd5299_jtQ
zHoCR`4^2PQbN@#sgZtk{{$C%1!~5IT|EcIKxb;owNo!3+%1>EoT-!X&e`l@xTD6L6
zEg<b2j)foxAj&R58H%=P1_y~5DuAV&7Yc+A{F;kENLW$dn<fqp0AcRNN8N&6-$;cq
ztiIFtDxL;jU<jxTn&xS6=854~YD3hiI`6<U$~}7LcW9@{9jWF83OIilU1I~s0iduj
z`vnaOy1O-{Bg<&kJLvZ8nX*yInuL0z-ds7uCXe}^75s}6wIZ|%MJf=uRr*6%3zed2
z40>>&Dw|Z;=#r$U5w&@u=3H)0_&pOF2+NkB&U6r2H_Zua@l~>Ga{K0nq~t;j6XLCD
zX#^ejGj7*g1qOuz6Hwk5)&!l_Jey~$5ze-bOjTK|MP{kkPxU2jRv#J8ye{RMS({f|
z==!7Y9-(;mHrER->>kLcvRv-;2v%3)(n?x~VV}@vM#BcZg(lr-!TT3<8b?R;?kXxW
za?_PLXD2PlIXlrMv;%kCk>F7~9GBxC$w_q0Cd3WM$k9-a<dbyfsbdW%!6ouv)plBX
z!Q6Ec3Z^Zv1ff#mzR(8G!^6sJTBq)(ZlDu}-*?b`cZ`QCNkj?~mLf0pLtj0-7la{e
zrXY)J|F{`vNFk9_hbQ5V=M|)ebWO3qQwW6vjzS)GVYgvBqKP(fX)o`H0Ou=}+KT?1
zm)YVLiRNT9(b4lrP9OoT4{NcYOOFKlu3S{o0n1knM1hk2Y6mG|`gi6qkScbRQ35K>
zcyK?ZArif&M2H=@)TFb(BP<_4MX;n?`xzG+35}g`SfQbl!0(Vmv<RZ2lh(L0NPco&
z2gI+e6pzpwu)+!}sV?LMxOmu~pYbb(g|70%Iy}jbgsP{nQJrCX`sq`>&2^!EXfn|D
z127y=09DYSU*@~3wP?^uoxw*W_((W9JabBDL7LKjQ|C(%#FT-oB?4U7L*eoetgu{a
zXA|aUBvp2$4eeiYq2$RK=o(V2hd4tB^mzv33^q(OHv>~1XxN+b1%e-WX6byAk=POr
zhYfp3INUs9=#?o>bQ=*q0dr$Pn~!A5eThDYfLQ}(^7Upq*mXv#u0z*_Jux<xczDvk
z1mxh9C2^l)lSoTEe*_`utbG-p0POutCYEan9JG?|r7p-T+S`nCMiBlw&ae0&yI?Xz
zbzA|Doma@?X&GN%*y#)AoQ?#f-6~?pLr(cN>aR$Hu_M6JRSifR)8I7*H|VIw%wZLC
zu4^1`I2L@c2?nX(e!#myx=KfNL}(y&!Jv>)@%*1@5|k|QCDbJvLFQ*bdP;f1{n$`C
zc4}coqS$4h$Slh0y2L$8tJo{Uwx1G#N>G124$k`dOQKO20-2BHwFVy=HlP@R*|=Cn
zFbWQJc(@l03#v*ZZtfhgPVtB!b^yaG2UQSr^IFt&9ntsZo5(TBD<+vURE8xHSAoJ?
zL#G)WEKr*u&va`RG94trz)o(|RyU!CT&vwc?iQiwp`%pI!Y%k+m}b*x4&{A!p$JP#
zO8URZ_u^y;t$8Spr#MZ>Ua-DnH{c)zv0_O>bP+s~deX836KFwi?~>Dw#0$l)EdVga
z@U_5x=Oi-_>ft}kKGad3bOjQEYl>w}Fe706w5-9%qQlOhi@fqyoO!<Dqt^g)HxJWw
z4sui$i||-QN&?A7xNGh3WyqXdw&+vQw4#*@{5tg+++{)`5H$r1;b{JIYH%{>;Oh2i
zY}qzSJo%(5g5RuJ<+%qL;S4}~7pS@j>U;qkaMxEkP>CJKQ+1)>nsWxW<7LFZPAp-Z
zE9;Q*Hm-z#J{&p6le^;2^T}Fo2UC60zlN6kogi;s|Bf?|bl`VUI3=c_Q4h>Ahon%A
zb{JFmCNR({QHGwjbt(*)CWNq`ha9bl8Su$RmT9Ba;&`pH2M(n1+CQvBCN+^k74WGB
z2}XjG&#Gh#RFaJ3qi54$+SmPHe*%5iH^~OHWt45PSK!5xe%shqmE+9*R<dj@V`z6V
z!xFh(XT)^Lfk%=wB|{JZ?23=jhJ#37WFErCMr0BvSFep#L1?%36!3-sUIGnETg0U@
zFd<vGONVOGx&#;0z%$yTw(cXf`!F_g-ka@m-9G0fg8n*aMj%y{B}hI*x}18}X%|+O
zc?Ml{?EnZjNp*h|;fs$&+ytk-^!{<#sR8>NT@fe4IGGe4WH>`mlUVE#`QV3j;JMtE
zP3FP5ak+~)I65cw%?;#!ComBw9A5k-@$<3^geFar6wv+{j|RK&7!Um4aH-Ttu&4O=
ze|x^O6kpna%>N74QI_effI=)22GXYtAK~MdECO2azjc?s<a<5j+%DJ&cDbjZ50HNg
z(!~WS<Cio5!^Qf6ObFIde;@+=GQkoViA0W0V+dTo79;?oQ;1;hAj*$QYC2|BD_1U?
zbCh67`Tz{$s|IUilGM3N>fnBGF^$18i<;oBm+MSjf6-=Fj5OxB_!H#9`vW9^2eR5<
zNu`|yX@?TPbfvvSfYe~!P!v<OU}9}wNT|_+kQ$NwMket>)iMK*fDyKevzpkb!VL<M
zyG+4$!%JMC*Kw#BHxi|$NW`=>17pv(XC78;a&5Ur2}2W7LhXn(2VKAg6-6AT*6LgW
zLIZ@}!s3j=(&2?WlkV+|A~qfuVCX3gA#O8~2^n4I3xR8k!icZ_4bS)Xe1IJC|Ei6$
z$Fct$<JSJ)WGa{J&Ht4d<^R1Q<k9K>JsN0{CPqUp>7*o(EjU>ql}y6%|8#_I757Ua
z>SzAe$N~w3Gbv2CcMJgH$t2fv5jJi3X(~g}``3&b0SJ?XvirV(aNGz4rd|*OfgsYn
z>$U(u(Y7JHp$G*oWD%aKjqK%lfi}xA!Z>`Wm{`yw|3JP5F?M7t?3b>R^KeWe2UXTF
zLd5rh;|f7sM#J2c^ylhn{c7O<^0yvCxqku6ue(mg54SHcs|<QWHIu&T-n@%P&o142
zYS&2@vHNMo9`mqQ>8DggLQ427bq7_S9XSHC9ebB(eu?tjPdkSgP*5lg&K5i$_~G<P
z?#Z|d^+Br#Y|`8n(}CAHiw*-e48?{%IJn}l_wg8lPW?2J@Bk$qK5va(IFRDMiP8kF
zE$;HI9^1MfelX^D{v@2pf0&B?ZM?$}I+Xvp4DNH$Pxs#>GJtjGe^00L$<hAbFeal5
zX782Bhy4>#U@r;zod}V~1O-44#te>iJ!Xu<_D>hw(a-M=3<&?@<}`1J-6h*^asMM<
zck_QTpUUma4zW)GXk?~F)?h36z1uGw1wMgr+bx_MTrZe^L{gQ9L<Gdk4(C6W%VtOO
ze*<WtbN&;u1-{qK?qdGa`Aljw|9d?Vec<(*{{(|t`;^`7BhLR;`d=>JlmB%lPf@zt
z26s~L1up+NH{1DG#bjYNm9n$5W$<P?o6gPHnRGr^c4lW&C1++9NgV7$nM}^u&kSe3
zUCmp3z0=rfaXdL<9m?c#vzggs(mKed&4r#g(WvKQr{-X*dQN29EoNp*r9;_NIakW3
z4;4x?NETYkCufSqL-y><Ay^XWLitcCo!MU3^7#}(-a5KAhkc|Hu3L?4yQO@tXdgN>
zn=h3zGbwwvFk5iaNjsaivHzJ(=5obSDhX8jo{j<7>f0skIP8Ja-R6G=N9}}hwqKT$
zyhHv^WoFVN{@*@|cU_Wmvz^a~|G$U%pO>lant}#bBz^5r|4-(VBmI9cX0N}5$bZg%
z!nrJWOkF?79tfQOt>phquE+jQ&y4cF^x$zA5A?F5su!cHk5?RNNHe||dWbP@e7=WF
z;DA4YjIky-CVZpI{t4Mrr|yTNws5-dx9&#t6Alh*S`Q?^_ZV@7ZHNWk4Qihu)g5b|
zkJY=hc-%?O#+uGB`UARB&9f$vd0boIh7rP~I&(Id48-f$8QyOlh@W@u3;goL9%xL%
zn1$~gOqtl>seUrBLHwUg_uT)Q%w$LU-;JOOc>U%W1LCRcM@;__liUc*KR?<K{&ywI
z)R4Tt1LHp^9=iSisZ4Ta<o~+?Bodzg1pIKr_;7-EsQ;&O(EmpJKf{=fPMBTupV*$;
zsuRYbU!4D~^#3$`J-7rimrACS=^1XJrSfUq2{!Wo4#Mp9zrTEw^K&1K{9*EzWAlG=
zu<_c`2j2QWU;gT6&%OQA|LkQ?{^Bhk{mch{?a$ugZGP+{Z~52n{@jPoH|t+{;LqQ_
zaqsj;zyGdpyyFe~X8-AH?*7A{|Dy+f=>7ZC7a#rmujJ}e&pz`T@4V&7<;R~|e(8tr
zJ@L%`S3UA8zy7gDKKp_H^^4^{c-<Wz{@a6p{@j0<c+=m0{K@1$`JvZ+<VWm(`GqIH
zcK-9_f4=^gU;Wkl|4)76fnPoMcQ3i`b9XIX|JX(l24kRu|1-0LE9|1g?&SYy|9=;#
z-f@+#`A=+bCuL{N43__y9{CRia3ueChUQ(Bru_dj<^NC4|IJk6wd3FZFFz6e{ZHQZ
zg-71`zSkf7#<Q`>=f1T3`}UXK@`;NV|L$Mi{XhQuS3dRG_b&bXOWwQo{@*TH#cw?I
zxmSPmO!PIk{N`<+F8sScdE2cYxbHpL&EI;-zkT+$hZ--r%Q<%8>FCpUKJ_8%D~G;*
z@t0Ok{OA|Ib$tE&x8DBwOTX~cPyP5Se&Ow_zkAO!fAx>+^<Vmf+z&tZneY44FV~O%
z^8Igm=)*VNch5p|R|6VV+7Sji_}{U2RCl|DcO(Dvi2oev|J%jz?#p$}e<EdLj~d(4
zb|GEJVkh01J(QU#+SzQjh@I@Toh;-J&F+v)2Fd?qx+nf4Ka(Hjf8YJAZolT`o9_SQ
zCr+JCuKu@ApIH3F;$OdLU-V~gu5Z8osN{Dy20HjZR~pJ-b|wFj|92$+hcX=<K)dEY
zku7It)1_24Ig>4xO8NZEOd(asW>ck98K+Uxv!!%8dnnxjV&IQ~^1t`~4}@>cjP(D3
zn7#f2mv1^ab>9PLlet1NlT6N}-f-_9e`?YBy*qyU&42OPPfonyRfm^8{<HD&f2_Xw
z9j}S(d-;oA@$~gKIfC#!!axWA!}mIj&u-*@4tv5Q`9F-==!Drd|A|5g&Ud>!n=a0j
z?R364o68=WDHjgqvv$Ew=4NNhDLdtK!Wi^xH}XF<(*Fmcbx+>+m;aYv|L*6WdFIit
zed$W#H=dq;`F!C$AHVR0@7wpvAAH3#d(!F%$nymQ9sEC}IM7|lf5iWd{QozCMmpv{
zKQojjcQOCi{~y_ZLz#>&pk4EyNTu_$@bu-=$;^yXNEea(+0N%nv*~==wu`CqY^K1a
zc}JgJtp7P&05r1yc7)~K74E<OKRy2J-~Y-#KJ~SKi2mk7UtE9cz!x6+_p5Jw*}hl4
z^_4g8u9;D-=P3p{_#by0UK~O{cOm}~5;QvhJA|p|0ogJC#pjRxKRW-@GgU)*&^7;w
z?H%&nSyu+F|A_YMj{nGI;S(MXHFov=1%Cef@=aHN_NmB=ZoTFBm2V#W^88Eh`Qgw1
z)a$=_?$7?syRFoxe(f_W?|jb(zy8OEmVfUrm+$}3r90hM{@1tu`08IQCx7N$G3U#b
z_vh^BT~9s`{pF85`KQ&T$G>_1`ZqrM|Gs?ScOLqB{?K3l*q<a1|KGQ~?8iR#hPS=v
z4L|og@s~gGpC5nj+i!gLw{H2}7eD-^>`!;i!|3OC1OpxXUn&o!54%|ZVPlN!zoAS<
z7tpTxPaMkS3x{%cHh;*;WbG6(7o@YP{0z1PbF;}zA?;-Ga)*xjLGnMD?uq})<!~p|
zNd9+C))0RB@gL5;_f4Nf^v4hU$cx`Ggl0w{pQjk;;Qzu7H}<zVrd`SZ<jDWKP4r$@
zv99?~q-K#k$4Qrq*+L$BeHq(MW*n!GN!xjP{+zTklgsZgOlYwDpXt{B^BLrS7|H+Z
zn%Zqu_T|4l`HAT-y=dQSuD<yGZPgnU`rg2R@W0;VGPD5=;{Tc6^Z%(d{C^|<AKH`z
zfY0O3CFeq9tewgiH=*Dr2HYU!@#^?_E6Ll`a9tQK6v8jLQGBex+u7%Fb#WDW+QyJR
z7WvV6kwl&Mxp_gc%4!YJ<+4S;Chqq{-VUS<c92z@mlXMh&m(0=109j%!t<8h!iDz@
z+(n37gjJN$-{CxR5p;chz0yRT)%q%vcn3WSMmPF02m_qjL1nJ@{UH8NCVT9^ByGYG
z|6ecW2iM=5EP{jE8I^c`Vqj$jm-x7saWTZoI<CoGSs6k%cVYh_!RRRe!w{yT2V~Fu
zCqN3dW~I5=Q*_r42Fm|bzT5uGFeltd{_h&)+pd^SBi1LKK}z2k6tc_Pt~V<9y@7#V
z{>OR{Gur<i4RIj<r+fTAnLPG{NBqA>6R-ssUg784dg*vJ8BdL}ziol8(W?;#Mi>}j
J;CluG{~sj5DP8~o

literal 0
HcmV?d00001

diff --git a/gix-tix/tests/fixtures/generated-archives/rebase_edit.tar b/gix-tix/tests/fixtures/generated-archives/rebase_edit.tar
new file mode 100644
index 0000000000000000000000000000000000000000..1dc9d0d9bcc072d44fa8e1122dcfa0ce0ccfa104
GIT binary patch
literal 75264
zcmeHw4Uk+}b>1wy7^WdEVlY2ROy0I;cV?vN|G&{_N4wgQmL1SaLK-26q@8`;{d%TX
zJ>9+ix;2{BY8~)TQ3*e`3p)<PfrOuOAP`uaz#3dJRUw$aBE%`mKmwElE{Fk#va!L5
zO}_7(`(D59o|&E*b&FlLyLL6*@7;Uux#ymH?m6e4du}u~HuO&%pIjz0#=rP<|CMKn
zcsiSiC*#SKyw9bQnX$~!F+&3_w`n&l>$;ngt_3=G-2iV4fV}NG!)}SB$)?lY<L>>&
z+ss(!_$T6Eg|Yas5hMK3_&cE+LFZ8$Pe=+xSIW&{BgXl^Tlt^MBuDap*aHLj9RJwD
z$@}hGTv|SMbaCmvGcOr<s~rFB<$t<c{wEWO<VgMxd?b1SHp}&q`0pjlQ|5`x|8lkH
zTp3=M`_2D!D$zav6Y*?fH2;S;BtGP$i>DXx<7xQ+<_E96`%w6nJ1=^FZyFnW&I|s_
zZ+&BI?A7lW8@uWIDDyo0|Mai^#?{|==f>Cn$qPSx+Y6GPU%lnAZ#;N*?3T7A!TPs-
z;_-vtUxoA5U+RMMjQ{-)_W$W;-*e#1SHAhCJKlNrKPUD-YvZ4d{nT2ySgeRm!unIM
zdFAciUxo8;zTO4rmd9TBXJ3hZ{6lYi-n(!4?(gnze&Eq)_S)FZkZeGfpQY2sj^WRX
z#!^;1^ooCJzx~AiU-_-qJv@EacV7BO&Z!f{?;QWV)>{v}=0W?rPk+bDj^^L_h04D7
zJzr}6<o_e{zu}bJA$FDXe|P#{BA!bmM*80n$HW8ekAJLbuMCL^_Avg5Y&tg@e{Yb6
z__sa&tBze94g>6E{ByaH|8I!H?t|_c|Ja&cuKF(r^o8TUt^Jqj(f^XUL~f-24T%2R
zfr+Q{nW8g0n@FUyg+elUuuz;WILSgf>l6#=l#?hFGnsTIIWiKrqvDhIU3>o5?Pg)s
z8O92*2l<~&rQ@UZ{|2yC&-lmMcGIAm--G;5B~l~*-=OHf9h{N;-;O#z`R{t?f7|~u
zsNU~o{%3O7FCG*E+rfE?@BgN<Y5O2lz<k<H#}oF!Sv!|ZI;C{7=wzV-Ce!(%6Hg>_
zBmHkXCVKL|lli||t6ds~;%CUR2mKEYz>)obBe<$P{;_(?U5zwr5m*6*OSM)r>e_2{
z^~7HvCVj>~lS<{f_kS`Y`G0*h-)ZfAx5o12YRp{?h4xuTs+My_2Hm1au-rnUTyI*<
zn$@Zo?WSYdmN17?jDSC^X2Wr;S`|+bL|~D9qM>~Nv$R@v6#)L0tCwq+oT8QAV5vyM
zDLCcJPNZ%ZE=?t-t@Tx>YN2++u?tO?O`#NE5SnFIi>7541xilCsTQ0mcN#!ZhtKLY
zx7@5XHfE%(0Bf!~QX4>;jj|&!4f=eQZ`jqss?}Vzn-<V3v>JfgtZaBav)D5>jKTn6
z@QoIo>c)bWy;~s^YSmJCrPZ*TWzgWV-6-4nibI&LLz<zoHoI7LoA9kFZSLN%icZOH
zRhl!F+X5oCb`{mo!<Gw5l}l{fTCX)Om8&aCWrGkpj-6USu4$QuvsS~fwCP~2+Agq1
zBju8zmsM)i)&!#8R{${MD7`Jz*4E0+Lpm1uT9ee-u6=8bt^xpIF$2_6ATxZnVc8AG
zbRKl9X?ZDKb=E;@4lX*%*aN>SIxf*p=0V*&AdxEgTD$Bt8s(xRkPH<8An&Z&m&>(Q
z;}Do`-9aHmtcH?#r&3!7eae(%YZz#-1CTbA+f@OEgtHh7+9cKMwQ{v-m1+%ita{n0
zmQmMQtAVWLf{eJw>W*@{;S&X~w6NC8Am#dMS=bF&m+RiR8KMz+WhM;&3R=WyYma5R
z73V?<X?`NX>ABdn3O1)G=8M3#t!k|rdDv;xh<LLlysm5{-IPf*<xR0-&2a(6t<7-4
ztwHfcb<?R0DKFe*q0impKOGGf%Z@cQZCwqGJB8Jnb@=wA6`t51#!sS?2wfwFCmRG!
zB-iXq5Eo#?Dki+^+6_)HySk$Du^YZlxEk996h(uSXb4GG9q_Nb#K5`b2DpLU1&dO6
z5LO@3>O2%4Vrej;&#s(UL4pQ|sUv(3$YF${Ft-jjyXcasHmpXgD)J8!tQZlI7-?CN
zHS6AEM~;F-iLmqtR4tM*YnHRtst|d~%#wqNgdV6YA|yyQqSzoCyI@rGwm<;`ATs2h
zq=mp!UTdz`v{mrx8u^PQx^XFU;4utf;<8-<(rg3EJBA31hYBu$0~7R>zdQ{<G1GU#
zJIbvXLvS@@-6hAVn-Q`qwSryo$JlhELxxE=i<FCGJ4`R9K@p|>B0>R~m3Nx!ju~99
z(I`1=3FUNBW6Ic=kqswOYeXvO9EYjERmrZppfIH}$PGzTsd)2l0pngIi*aI0lPZhb
zf<WGY29vHxsh~cjBM;G0u2M>KNC<+HY`IxmE;{u}Z39!J)T+vmaV+z#as~1v7F_nC
z1?8+06x~7;f{_Jxy$oC-@tiA8q18kyzU&T&c;yK$dWMvKp&+@jywtdqY}8uTx((q4
zTGT;t;Szii0=ZbeO*cC0N-ZJ-(F!DMmR+==3E(jWA_S{lD1f6e_!X?ZPILub;u3Ec
z`OFFzidHllCO@@YK4>@`5rBf1dDX>80<&9%*K}@1bk0W}vLcc4N|mGPw(^j-EsQLl
zL8vtxC@G*+H8f6H6h2$$;D}lx{A!hK@MJL@DwPA^$y1RMUJ%MdtumJ8&07e9K4+F*
zpVG3dwy=)dD;N|b$h0M+?g%$FYONJa=KurNN^_zTSr)ffm$5o8Lph?x0!F#h3R6gg
ztvT!1eW#XQwah@3<umslNi5%c?3E;uOh&sY9k3#f%9P~cSkbv0tF|f?gEV2!6I95l
zxK3zXeosuXHd<Vb)bbBPidYe&vPB|p6T@WP;lr8UglJ|&e4-U>kh!=i^(NRL-t?#8
zW)$>Up<8N&Cv^D>2jMQ%T9u+m5Tn!u8JC<&=`LhtpLVJSKV{1W>_4UFz^uMDN&DD;
zIh_0Hw*TOk8u|a)6dc~Sw*5!TZEFKCkM;eM)vDT6EZ$IGpiCiNNY^K56%I8ut^o^B
zFYppeL73tvxbB6G(%M*Qi6%aWx1}nT5O>v1L~5AU@&yxE%}D4<Rk5j>o<TW-DpEt9
zP^@#thm~`~x~wjUT?SMl^1&BzZ$*JvZ9UKdys*^T$k%EWhYFno^8h*}78$Ht-Cgz8
zW`Tn)LV@uVRtso(mT1(n+BO~)gbi47)yXE7b<!t*OVOz~O$TJ`gNc;mA}SQ`MT3n9
zh`k^oCe22FBy6@0t$u^*iP}M+fnCDLTLlPis$0=O&jlecz_xu?&2FdN_w+!pk!nfp
zk=QE<Xw?h$&W=z~bDO>b=`n_+2PZ%*J4Nlir^;`|8qgW2HjpnJaSxyxc-C5gJx;r%
z0!1@q=E%HQ5||^f4DdY}4q=+;_f(jQF)N<2VNe)P2Gxi2R^(xrATPn$4#fF}t&4|9
zC@4^3!iA3tU()K3>14b;zBb9l*Fyuk94tPsqBRBJo?<y8-wLuUyRAA+BGaHWM*FC<
zvNaL6?m)K=TX$%G@I^awc-kweHl@+zOg9WA!d9fF{nFa)-wLFsn=Kbw+uSy-_BQH`
z13f&UZox6Hnw9#0K=<ZG-I=Eh2~O^S_?T7*I^C6Fb_60=VLH^!s{KH8m+!y=bGcuA
z>9sGSOl@CU?5MV1dYTMslysN`)f(-1@h#G_tv6~^Px%O7>Fa@}JDGTBvdy|sRQ>Yd
z=}-ZOR`D`WF-&_be74HPp%{?H;r-SlRv1+b%kSU6-#Vr31#z%sDS@u6f*OV=)`Cv9
z7(a9<<hXXhn`;a7l3N^m+SZs46Uu&^(o}e&(J24W*8*D-j#F{6ak)~W;t?1+8luC&
zP_si<@6plGk!Hi1JRgr7v?Ha9lh$N>a$0A3*t8wC=0O%h3`_z=YgxEdn>JQL@P%P%
z-_&S&-BHWH5Zs%AGhTxNRcJqscdo<`$M(-?UqSS7_&}?X4xIrH-PKy7xom*VPh2(M
z_U&uKxQ1dPz`_&V(=Tk@ie5GwEho^)@xb^l!J6)Fb;g?LXcfcaiV<O?FKu-Zg6%cb
z41W;vS+LzC)f%pakV-bjB;r~a3-KpVA@Zam2O9iYw^yJndD0WGRIrVYL$r;Pr8?-Q
z!=rRFT*8&PlN9;_&-)VMC>0DU4!U^nqQ~1}iKZ3B?r{wcm_PSBu(WQ!U2Iw`T-X7i
zgKNSJzIE90tx+p^`1S;Pt!q_q0G2@aNw3NzmQI?C8+72gO*cSgdMLx3>-W)PyRi!z
z1b}Q#1e&^T7mpj|!5=4YVQSAtuu6EMTO`YL-G-4DJT1cxxQXdI+X>TdkNqZ`*4>G~
z0-&!tM$*$Hf}<1QH?6UoNwzt@s&RGG8y=Q|?2Y(1`!lIsVUsTQ)(f(%R@i-CyP#fI
zr}yj3I#S($G{VfKKL^^DxO(9#g+sml{7#ltO^&R7R=4PAV9Y`OU8>gBA=9uv(fMh7
zB@jxOZ|zCPZ6ua3>xU8NqUp6oRoB9IPq|v=_Dx7+S$yPT8J=-|10V<dKXo`=>C7Iu
z2Z(ymHs`;RnN+sh|C3InQlt2<8!-ND{|~g-t=&J^jlwz#=ZNl9*?HOjm%U2e%!S*d
z)Aa*zd=oZ40(C{J5daMxOFJZyY+mcm<qWn;=p%t56%cdKi17>-s{(_SY*~xk`i4X_
z<|?HSyf)lw?cEN=Vku(O^B5Rhd!rPvcSX0AfFW+B8m)3lV5ljuDd6UC)ssJwfXQc_
zpxdf*6CSd)z1PczxDezW!YI~Y$nUczlB|06^l>VO+m}UY^pj9npJ<Wbx|f1(8Y@TW
zhgVo5Y|pFadq<pyT6RTUVvAL7`{<UK89MY)wRG9bV;lnLuGlJ(h`pHeaA$Crkj@D1
zF9S0Y2%}al+6}tF>cGtG_pupo!{ZL!5yW}}`(D4-%0+xP<E}5v558%SiUuCR8(3Rs
zAj!Ha)7TQlHkMEply76tJw&2Zslh?Tz2+4`uhFDoCL<a?w|FXSO>w7ym_jdK!ETa^
zU2V8mNJRCnv>Fw4tz55B7SioeDyO<HN@K@-Lr)Fo%R_B{8Basl8l}zCbg(fWo)C)h
zdBCU(c`ETf>t2u_-cQw8pa;ys!j-+B0Ejm14j3K~7-uK2SE33JHt`VogE6LZ=@A!j
z$FZ5ULi)7vq1K^I0fNywz|f+ElUut1!p__bU>mz=v=chrJ~SQG#HMM5@iQRsLPy@%
z%(Nsb(EhDR)#A*=z}BtF`%!`J13{kFzfTnuYi}!cnHUn&a8IoT*IT<mGK@hFgE%8b
zqnVcoegG+giYqXex&GwQjk?x<oBlgF2{b@0pwIdr&t~G?>whMd814VufaQOzz5Z{%
z|Few(pz{%1LJ+qM0q|K!cZaaC;zV$)wBiY8U6Ym|u_fjKQl2}yGLJ-BcgHm8CPUeE
zTa+#~l>xK?-wGn`5JBOIe27l&Hz3qO!l1CpUYBJ-(KC(icuR@OaJwhiS_(z!xrksl
z9j?Jv9bQYv2%@k$&)Pl>NFkJDq=R~dV+5v!r?Hn!`5w6fG30{?(=Wo9kIsh^R}%-q
z6L*ELh31B4Wp&N}HK(!S;W{u0(0BghtY26DzYKzcNBaK_5CDUm|CnQ4MgS%!_{nVi
z!tL*CsnFxQ1OV#pTm)<?07N%MWD9~s>5t!37zjQ_mDr0&2+og9ghG36n=P=I?Dqx)
z0H=Bg8_)7FQ+~^`L!9>>YX#?j&22{1Q8cirFU|Cu|H)iW{?BxFH2=LJ8tUJj&VQ^`
zu!Lb9z#uL#p1-|OBAXwG(U$mZOygo}Ew4dvb?oyX*iX&`?0n^Ivms}g%n|OnC}(2z
zZ9o@6ykMy|v_)~K6n|m?56*ubVxy@<*4&i=iGe=zKbcGR<bTY@bEEtpH-b}kJOAlu
zQB^kRZ`ow!*Ft9LXDx}_GA=WX+@dp)9zMK<*f3CyIzMAvaF8^xDOf)c0^oVxv<m8)
zO4w+35usdg0_p{x)msgO;K<P&`YDPKChcytYfBJ-=U_C(31f=4@-8y`x($c^GWgaS
zu!D9j@p>j61z*QGs%oLq0s+t-&s>@F2rf^{z*kvrz@mVQQT$4mr4$Jo-e;XcTpKzr
z0eV4P4ZRSf5Jq5frS1{XU=E-ztQ+`2%I$_B-&;-k`Y?tP+sDvqcw9KH2v(5eCy|Dp
zb^w`48GkGv<Y5!z+~o_YuXPY4E?`M`p2z~?99E)?p?3;4R~C#IPp>dKqfo<smDq`q
z2wDb?@DIsv7Y<L^nDThZTYAtS+`#Zv8oDt`ogo=#5NXb%Y={sCkI}(NM`H)#5}uF4
z9>B_NdcpZ%An`;m(G89N8dw++^@L+^wHioPbZiWt$*GHcy36-09zVt-Jm%4vlV?va
z;6XCPQ1AJPR45c{xeYmohrs-b6)8va_9b|<5N!Y>7f#Psl?NQA)?)WZ`;BQV8bz^v
z6R~MJz`C%INHG)4(Sgm(1aXl_4unO{JkoS<wguMp%rttA&*lhXBqsGeiYTVx3)Qd{
zwI1M#Z5YH49Pi|m2T*gIiaM~3(Ey$hMm})BnxD7gn;~yuClc7~pVlv4G|rimcN=FQ
z4&h1cnRadI*y-iPqsLAxAxcA{imKM68@vC)RCNF03)9j46R{2kn6oY<Vs(Vn?2`}$
zIiCWpr-{=wJXp}+0fKTh0<shwd^Jx&W3(UMjMNepq!t0A@H*(tX#z$gUu{R+08K%t
zTa`k~<kSNPHlq;0!3DXSb)$3r_l{={XyG@A^jZI5`uEuX=}dNH|L<lT_gZ$R>%W}m
z6D41_rL0<=A-@!{vIu#i)f|drSOOLz?j`7kjg|(_W6g))Z<rH|lPs8rMKMo7!f4Zm
z!(hO6RY38N`GxgmI0%yh7<lbv(e=2Ut1YINPF3y?&>%l`_RPJ@Cr>Rco;<O<aPsVl
zCGQkUc|IN**9{)25uPX`1hv9Fn=R^%b7yDVxs3C1Vf@o_<}dUV1rU@mqFD-QSe*oT
z2!SLt#Ke0@)Q2CaOZTD|Xs_WP6ITVqzWwvp{4h3#$ROH`)a8aqd*ednD0WC7M5oHu
z0V^?$_p*(#OIfm49vs#C@lhZk|4Z&#t;*B%k#(N$M(p>1mVxc%e<G2{_QZc=lkt)L
zcO$q0@;|71hC-C_E)pjcnup~3y4|Q^-^JBmi>DUm=1$g~YVr^*l&u3ss6MUWkf~#x
zGt7kIQ>)Ep-JOfYO3<MYF@K5Nx7x}_%e9!tb1~$Ez(di&ppCnA2X;WK4)d=G$puUR
zhdat#D<sI2@d<Lkvu(V{z7p1jx{V{xh+eRGn40H-r~DKMR&rWERBTu#estU=(a1Dd
zg7ycDQ|1JaW9V#9O%=1hRAfj7f-!(h5CFk)EyL0$Xz7|K=V%$q(ncBwW1&gX+z3{O
zf{%?OSI*}H3{KnlXJ?IZ(x@Q>)ELqohaZWdOE(?JE@m@u2f+{~aN_K7L!BMF;T~!^
zjSXKCAdE+VGc|`qK%3JKI0WoOeZgS`q)BIetnQ(;4Qpz`j0EDbN%>{%IgU?*^3#Z3
zzw5~9m%Kt)>ulASf#O~)I{DVhijKZ2#b=g|9y@&+i*DTVfNla4)`&ne(fXjZ@`fBf
zry_6g;rj0*han|<Ak~2$G_EoZMl5?vd)4l+K=Zh3(nDl2DppWvoTgLw9<Ty1x44Sa
zz;t0xa!SGa7W9xg0i>D0R9NP4E=vx9d27Yd-zd3^gUD0U=m^WfBtbHTc`IRlKj_w~
z%k@huIG#Wa16Vf@`csCl_N8Y|o|v0^<ryse6J9Bv5b&OZG~<ABjTUsV)?4$`sm*Ji
zI)$3o(0s+lQTNqlZ|Vw)IJRwdJtt&hUPI$v*=3<5YcMne5w7jND?Fz-HBp<EQ5e^0
zhj<wmc~kH>a`<Wi@hF$B%~*F`m7g-xu3aOzYfME!EIMi#9Hu6uV!4Q#Qb(9>8GT_a
z%jPWS<7^<ZD4Y<GChSycb;b%G4&xtTey@K_kOOB)6o10R3NyJ}g}g$nt<;!nHA}M~
zBVH&!<1v`oV0WRa*a?522p&T$qX-f80AU84JiCO3eOLyP0RrHj{TOFU8iO@4Ll(Fo
zPxQ4mg%MS<c|BMbFy7dK_I0TH4k|x%#TV8@3``yFWZrNLt;y86M~>u^>A}sWFyfye
zi6=X&_%mj_&vcQKHh1y}NSw65WN0-IpyRQ3<S@i><S>aFIb4JftLRK&#whL>hweTK
z7kYiH1GRY>+T_%Q{R{UVKe{XgHs2Rd%vh5ib*#vP^nKMLbP+T+;5HcNEMj5;@<x(*
zAf)p+cy_Ci27S7wOt`401{E>q3c$OvbZOFyb!U>BFs?+uGct-k6=ZQJ1=bq!l%^=a
zav*C=udJ15OCBZgjR<lteXiI(jRFFJEMdbIX&&GSLcli`s<Jy{DFPaZD4slNA&l{@
zGN%ME!eCQ}z)QlQT~aM<z>$c=MI!xhC<VC)AOnkKN#0P!7-5;k@)9nUol4OSvsk5!
zltdm7olAVoIqUVgTG<c>XtfuqHr)WsL0%N>4Fj1{s{ynmr4JT$WIC7CSH%h}SrJmf
zWl3Cum@S+=lv0o?s5jM1&KU~_y^zhyc?hX5!YZ_SOUcATBwhEycR?B$?|5OFe(0g|
zU>>D0IH{-V%tfGv!%~z)$};oT9e0GskDWM5q{q*P<tfEe=Y+$Ps~zCjAk9K=5az7&
zVKP_v;*2~FkW^mPngDS=jFm}B8Tl8!coC(q;U8eItxzTN_>)PH<Oubbt5P(|`EKND
zTYM@7(CsdPsU>7SFP<=TLMauh<}rTj;_8bzu82lt#tvC`c;etN7e2JG)neiI3#_lO
z+Wp#cvG9s+(J$|HZ`VZNoHH8soOsSTlT<812}I0=S%`KfgG9V~%?Ue`jrz5M9B+1o
za$VLu@Tmu3hmERxyIswie-vKf3s<p@>{-NbrcoF{4-G;P_11nFc|?ssc+Epgk#|rr
z<OxPwroK_T4qI^%RTEmAv^HOX@>&e1ewhOff(jI<RgmvSl=bL-tPGHZ%===&{fq>5
zdiqc%fK!Cca~0D@+lWNaWH&Pg*IcR8GoQKUb}zc(wDTvK*4uL7-GQ#!vG@XCB^8Ob
z)AbjXwjp#kqiI=Bnck6VAkfJ++e}fPB8tD1?Jsz=u&>Z{3mN=AXXYUcSQvkHW!>Ij
zRzJ~D+U6kBQbG3VuARzkm;OPnl~PpR(ku-#379$X1%?3&H8;Xmse(h0;4rS&<UhzM
z)DQqZ0t!}k-B=R37YZ|dp4!$p8piBU>yW^b0-$bhNPV_kK==h?o(UdxE6f84^Bd_I
zai9Tf_T_RB=L%#Y#)>I?+M(BrMkspyc0-MtT|(u$##+Z_Qv+ct91BlV1Mgg4#p0Cd
z?i&-rHEKh3TQJb(C<r`t6RIZ`-5$Bv*@ZsZp3EhmTg}kZ8dEL2%lb2tYr@$3Gzfu%
z7_Il8q_~`1b2r>c>ybyS3G<+^v4R6ElSZ@zDx%lt%GFeIZtf*cb78$`2CJjQqX^)M
zUAPdt5TjhVrsoi^3I)`*L_NG14<ZD(cse&%Fd#`G)30DLcJW4dwnlC2gaQGNO*`Cq
zfU!TsVSE2C&Ib0L|I4J3qx&CsGJe-vW~cjqn!Q682xf~7M*kok0^E0q)1lk*i5dML
z2sf4x6D-F}y2BN&D;~%TS}`l!?qV0)z2_9#BtTdrmhcWIsw6+(Hm3%(ECF?#8t_2`
zPYnbf?(Wn;VE%I(QQ-_|-^b(4KJ!17z+JCh@&D;Ga)OWUfAA<cyuUl0|Ii(`IsmLZ
z!;mP<|IS0eVvv@RNyi-Q8SVjqatR1PG!60$kao^Q2v8>uPFO<}W}CFyNjWur2}C6l
zZ6W<j8EHd<$vJVd7rU%T!)u5$2gM$NbfzR!dSnQ$Ba4@2SC`D4Z8$14IuZpzO=nD?
zpFKr0_Q?6+U@{t!c<={QBS+3GEG~+8Q|F<iD`zO1pTitdk!eYynz#yeY`0Kmd;kfs
zecmgtu%vuC4cSVw*Ej|!ZS{OcRKvOx%rrr!Y1ELumjP$odgJ+AjR9#gybqP^%RDu^
z3GRnbR*nS&2nfEW?o2(#j37T1@LaUo(dtp_90Mqks~3IYE9^z`3*u7n3vk3+Bxbyv
z9@S_SI4HHWi|}_CNvqgoD=_yREihndVnh)lSOnRim!F4$E+qE|(vdyI!XXeCd?z|G
z0GsF<9G^viJtJU{P8QISyr+Q>L!82;*8tWSJebZ5woH&$ia^+Z^iR}sY-`Xd%*`r0
zU#^tNMm6h9t%B_Iu9b)*7}nqJZ8oNnBbfeSLLns>Knd@%K>+JH;#&})TjyQ}z?5ji
z8lNd#wg{e-eMUhIrl17FD2tGxy^Ow*&hWn)ytZ(hO9?o0LBjbX%;q-X@&6;-H9Nkr
zeB}7?`2}`8Qbf`#EAr^Y3kV8)#9A*{k;1fW0GPC}$j1(!=Y?Y@?+G2F6KBpk(q#N1
z28?-&Nx@Fm5eG72ek6XAnY=Z~6l@3Q%^E^F+sW++f`*X_u)0%28hLJCAg=%h-{V;L
zjzdeD3_&Q5GGH!H+%8@&yKR>c=bQ2z+}NnIs0}eyi>6lKgyj$vB^Nw@5xt@ZgOgMh
zF>%1pg>aH6FeSMe>1v)!kLzR}he#SP-iL>)ML4hr%o_kFz$yY-m9fPjg_~bpreq34
z$AZ7Pe;M$-lk2&?VdgP$=p1uNju!F8-XC0~2p-;2HiEnd3Iy~&WQQ+0Jg6HHZ!RYH
zfb_sV`d>O7?>+y4`$$Ln-yX(uw^iEuAEd(8;XEEkK$c2&0BZ^&AjYMJK2JoQ@TQe%
z6XFj@<R!`s2!_jL8ybxW3o)i3QzU9)*XO>2hd$ASIb1+#jaGb}&nN^UW~Eu)7bClz
zsuu7Lgx$u%^v(<@gzQW^)34mAA%0(3;XHHMXbnQ8DN=~?95FpK6dAZgXE4sG*QmKt
z+Ikn0wCdPsbnG=R@f-DLI5|c6svtIt_v&CQ^pplK*We;WJuqq=VNPCvGeag}Pq=A@
zw{VnNxCw#zH=EO501<Z-%^+eEnGiXWdeemm6TrL#I+}093$_Kq?L;|7FZ7g1tW?@n
zQ7>y|N4levngN6=6k0Gpm?%Y*F)mDu>y<^EP6eqdgyeRy>eXJZ8GnGH9;2St<U&)1
zpmXSV8Sz7UoMEftr_p%32Gx3$2X3cvwFA{Yj?mJ{qbIrW7o1huEcZ?a1u_!I-~&hR
ziUf86YdHs{ifA@!3m%%w1$yO|k*AT$B;3sKv2vZ&gf!60*xa0tfS6I>9Y6VjX=;i$
zFfdjQ8k#)9+(UMoacc4ODErNs$=ln`F$6h*;+`ICSVGxUyV${gfXzi83>ry6(<RDb
zI-k|wONDZ0h*Mi-V1c&BdfFA~gdiKOS2pd5GO8ij?wX^<gN)yX*V~Okg+?$7uk3&x
zjnEMaFt@pZl1gUe$Y~a$L2Mv}7)79&#s~0k$d5zUVDdBAML%}mk;UV3hDhVkk0FsW
zqQ8vttJ9|2H1ouWGClC)7SL8)KP}b>Cf-(1#J=4g24;?e@ni;ItzDuPj>em7b=ZMa
z<b4#{D#k1IqqWIX9t2U{BPHG|A>=3jg=Hgwat<eMfU%2<RhYlYjbZPUU--8qXY7SP
zeOndwAE#`DCXA1SFD%X(;TeQ)lH_{Wbkk;Yf_i{xgL67yHfw@LzfHg6bC&4Zb0$oP
zG6GANoU!)W>`Xw6X^b04Fpef&fc!mo^7PB(+K>=#TnSPK1}1q)(jnnimGJ%IWRT1x
z7EdeTS|Ug@cqqC=gS^r7PX3z?86^eKJJWzzef^kq)Avg!myR6wun1T&k%)A&-%!zl
zMhp*<J#{b**#O(_5qMMr<e0RMy>f9$_}uT63XrGzB_RR*pZ?#5lgEM40qOmoF1o$`
z4^2PabN@#=ofz%^c=Q|Q-?siwMQ5Q_-+-R9+C-%Mw3Up<vorj6)_Q5HTCQ0ONIQpP
zA;<xUvP)2g!fl?xL1KmqU@7N?0>J~n<{}U>R@n2ViGu?`n7i@8T3)Yjq{0|f-|2f5
zPXjM71XKo1^E5c~#PBP%A?j3}ci<W29@u#Z?KZh1)jVGT=MST6tm8NU6c%Q`pg}=*
zx2AMt8O?eJ-JY1~G%8wCP;b<mD`(i`G2gR-cX6UtgjS(M1p&89e+X-#TriD65B61M
zlL{LsNs1a#n<uNzmFA>}nb<&BwuE#BL1f)DC#=O+Nz~-_&2>r1g%~EpThr3;5%)4~
z*IRi8g@O`L-Wb*doz^^?XR9HOw)RX_S*%57sn|#LC23Y4>CU_^<(gTWS6k@%qwgM|
zcy~9}@-^5!kWVGK-01<VuEwPmw+_KRq0fwl4X}kK-Dtu4=Oc}yBYJlg6&bnd%AB*4
z7UZ0r=n{&+op;7~)DFkx_(yUQZP|pl0U0?O$dP=4&OCLj;Uu_3{;S$fOV1y>PDa77
z`IaD5O57LP;CXmhc}?r&%cvXZfZ_L@bl)B2;Yu=*f`p~WOZ|YWi}yk>WX%*}aqXWl
z{R}81lIrjT-0{4E)Ud88=6edEaKKT>!!AS{wj-KoGnZm{X9zT3E?1ZJ=e&#-w@5T6
zqlu25M{)uQXuV&H`6xZ$>$`GMNe3)XH4p_#@KppUVm3$S5Qr*vlu-i8&8UArrC}1i
zrbL(>wA7@tpd&0FKt-^mT>BXn9trfFaae(_lfmzlM6?K^qLbFRGRS^%UI)ytQz;sv
zH(;3+mJ?mX@o90tH$D?r%@n%E6YKCKKM<&%+@d<e_Vlw!_4cd_;GxMt+Yd0|Kmw?O
zhWs+#U9E+EBy|KIkl-Vk(ZP{ZM)T8@ZZ>qD1VKz0*jggMWqK%F9)guAm)PBac^OG{
zy3&UBF1b+l<Op<iDbmB70Rnn+2L1FmOf)wGQyys8o6ZXaKl04d`8Xr7B^(YL_K<M6
zdBpH5Q=I5FB76eo#)9@dk|Fmb`Wymg4VbCh%y1BOMyjqs*M&VXJ|4S&%DV*Qz_cZC
zpW{<VOFVxVA?U1q4W0n({Y=F!RAV@3CFmtC$}8I2jB`d1{u<7&cp$rAGDLMk0gs<o
z$P-EF-=?sW7tJ{x2}rwD#E^@e@@>*zl?Ee+L8WUNkT$NtYYcACUX7c>D&}0*1m3VO
z_+S$ZQosFxcY}154r`ClK;ohyA*15?Khq>ATjEOqB^p8Ir_XxIc{2O4p>*`*!m>oM
z%RZ4=l+|^KdzMzPSB7mrWdfC;-g@kx_4AfQqcHd~AIobMJ~V7VF#@x3sf1t@9O`g!
zFB%q9l}6m$*>9cX5kc$#23HQMAm-+^ut6Qs_vV|(G0H0@nKN95B@tJF!dpY985}H7
zn;_40YZfvcEWyA|Zq!ybpoeVLt}k~BQ1pN(RkL6V9ttyT8qJ}+=PndsNl8in7w5e=
zSpsVwisLCx6A}y7ckBinq+nJoX^1X@M^aB(c2EK>=<Qu{+L3gj*tG=!`WU<x*h5Y-
z1EC)N!{|dD<w;i%!M~<h)&$c7#!t%{j4V1t1}O5%TXE)jijQ6c%-uW;*Ez^hSuBEm
z6)6cK8{w|CgO?$5aM_~AMKelPF7RvAXK<GZg+SO8FpQ)5&#A#lr~RwjXRu}4DDvc!
zst8`QW|ik2WQZdG?OmYiBB<j9YQSAzVMir)98cASf@{th*p8PW?>e!VajvXE%G<aS
z0{U?198d0wKhI-py&X*TN$(n3?stN{dHp-iK+=KV#o?5gLPk9>%N&xzHHt8X@Ku;V
zD<l~(ZR=F%Fii-VelBvfB4)s2A6cf2R*U1cIz4b8jo1ERB{Hdr45>g*HAv7CoP1U#
zTcDC<Bp*GS4)VV42YUnPxxUFZ;4PzUi@gFbmf&q;TUCxTdt1q}wT!Oa%?wMN^*SO3
zB?lf!@|1Kz01y?ApbZC+zQ{a;jg8P0POffERUv4%_T<kE0lWkrmbOSsoxp@_;VvDj
zNox{ZP{o{4jM}=7)ZS!bBj>%@F4ygIULxqNgQf>kRi^~mheVfC&pPZfm1Ug47hO95
zGMl8j*NfoA$0Bb0Q(t=jxa`zm`WsylC&M_H6ds&#hM}gg*dy}63+uphxh<QM2j|A+
zE@J=aoYXfrkb6jAAdWk{_)FsFWfurdnj|UU{c#=*uEAs6_kS}>rACaH;^Y18`OZ>&
zX#+C<&s#@Wrn3SHu}l!iCS~{tAFpHq(ER_cyY(gC>mlcM!A`IjdJ1{~`8O{pE=U=#
zqyZQ#wi(EnP#yLA63{E-FOi{8=*SGZ!1ZfE0w6kt2*wVg{D`EcV^+0N`HDG5i781R
zfSLHJ!5Wz)b?%lrxF1|hV@#PvO>oyc>r7p5(IzTJ8na*g33lQA0TRFiS?#T)($0dk
zLkVC|X)h6AHCQ(k#Z)brSlbg4YV;taMr6N{NxV?C#K0p^gstMNCN`>YgF@(TQ?T9e
z5*O$-9BRgmM2TrKF)dBs*z@d}`<0qpTec`+ctT339kJ>F1zb>3z+q~w&LtqwLFg?k
z&L}MHUJ#jNFEUElXjFg!QyN0tX5u7dbe$&zwibmUPyHLF_wC0IJK+CS8)d+;|Lo!R
z{@-{a8}H5kl^*5)y&=re>Hj_AYmp{KLoVs0B#<pQSs;~7g7N=!gl-r2OCjoI{?^C>
z34}8#Ot^Op0OHBytmh(Z+VIj;2BP=3j2Zz5lZ3MSzJOrd2n42H5CefA(!A@o06@{U
zA-tgo`7UG;o~n%u^1MKM$}z$?c&M0E&?EmKz6LRNWGmb(T_wlis6-B`tYd_T=L5$T
zg1C%^xhd(-)zkVF-~Z)pJqB|B0+v^Ijfx*`Utm@lU_&*NzUtn*i$~5b-FtG+Nf)vE
zX+<7#u~+G(R765b_$+k?Ri7O`46_}3muP;8^4v>1hZs<BC=AXPJRkVsY?9oQaTn@?
zRu9;exhtlFu5%V025cCL4SjHM#bNK`Aq1UzX(ZtRirs(S8o#(d!GB}LNnBgp<y$?v
zJsw^#=8yj*oXCHeir#I!!w@=@|JgL+`SjEMH;xQo-RD1&$y|IC|2K@m=z`gMW%42K
zL=>i%g#1nh*kh6czz<`_jIFuM7>DhjF1VwgPYw#m{Kw5{?hw)CwBP3bN51Z!|M6TR
zJC+$DPCjU4rbgCa%m2OCFYE<AzHr+soEu!vAAdwrm4?Iwq{}YHKatI3M&o}2c%gIr
zW3mN4=w|mY{>fZAF&h6t55y+$HXHvKgIYH!yVpk?|Lyd@Y_2E&Ybr-ky4MDGQ|~D*
z|2Z~0`B<6c!Avnza1N%@#l&nrYbQ$S*+MFxE6%2}#Y`%XE8F5}Cu8hqhO^(H<}JS7
zW$d&lo*cFgrnA}E^lUtC9bnVuLQkA%)N`@ZbFfuiC$!@hQ`xkAFrO*r({?(Zun*4K
zxn$BQrISS`o6b7PbiU}s6Up4pP|M{K2zl#3Z4UcLMO?QU+Hp(qH1Kg|XA#_(EfkW;
zgN5R3!ATZ?PO*?qIf+6slSyZiJ40zUlY@_}3nlD03_$5_&wmC-?PlWayetQKm-9c7
zP9;b4f9E9Lb4iZPPCldg{}Vj_d70XtIjDa{^4Bi)|9CDw(*OHY_WDbR{O9<`oGWt2
z)b)exfxz+KPX4E|J@$VxHOl|eL&sq}(94c0ZiKErUU8%$&G=&YA;P%v`5rcb1O7NN
z#+u-m;EgW(CS^~Zx*v|(!s))xx(CruI5@0nJ&*w3WyBS>Ar^EusC|Z1cdU6nR`1f{
zaVI$&Ymi~|2h_=`YfT~ZxVFFzBZNtH=4>z-h}W<)ywBPnJzujg^2?(G(3plX3O_!W
zGO)u_{iI|4=6^idbN_1`y75T=y8&zguiqSFKwNeGi0MC?BsYNYPmm^L{?{bS)R4Tt
zed9kU9=iSiiF7<Q^8eic9tn<rY<4(1E*#)p>i>x>^uOU?(?!&$xc{$f{9~D9BArZR
z)5T<Vws0_0%EpU!KA%gcvl%;CN|#FcOd_A_qG6w(9RKa~|9EfyN4SJX`G5M5bs(>=
z+;m|2rT3kUXY;s)GoDJk{N9(&oNzvT=X)Ri(trEZ<ja5N(9*|WA1%GV^6;B~HZ=C^
zpa1DU8c3@nAWswubj*Lp9tv7}k^ecw|BU4SP==!eXxI415_ZydvIPkJWImHBI?n9D
zbgE!yG8t@JB$9SKpTqu22Z+8u`pW-g&;DO7l^f;%?Mv7J6u5HJ%RcqVlc(b=fB4zs
zi=SNl#?!{aue+r_0Kg*<PYMcj%zwn(4CAvG`JYXtNAiCdgV6=EYy4vei-l}9j?{JB
zpwE<?V!n`v?KV4`!nQb!@?5fz$fde~^!eFO{wET-Zu>ur)<*unK6D+#Yft}A75eM{
zzy3K{Bb+O@z4QCu{`Q04`P$XkyZ(6Q@6G3b`{NhC`1G+ao%%=1gFtBn;|5ZobN(lX
z((>Nq|0w=%D1*@jv}^ohI}7sa0@CMaU-_TwIscK(AtrDX|JR4G19*MqrfaYNSm<eq
zXCIya>jRA!yyLx#|M6M>{09fhxnmzY{jFF0pTCGqJ?uvRJP|+s?sr}|G<*2F51;v^
zyT1N&4}apr5C3%eU7xx9>o1%<di(cY<i6qSe^UJV=VKrI*fT!;mX&KSef+C``6~||
z{MhS0bJH(;@ckd!S9;U`de5a_cxz<&Z~s%~<=IT^&>v?W7y#}g5Z6zEj`=^NIG{bq
zf5d-`&VOA0==O)uG5(<WFg|-2f9(H^_Wy=47Tqwr#y_^RNa}7V+yCyj{wGsC`@cEd
z2R2&&w<qgB-eUcK!^@xbv|FF^i&y{Z+z(#-i@*22hwDdw{@D6ofAeeKzWdpK^TY9D
zzn_VHH6H)Wf4%?DzVyN0sekjnqx()Azx6kdzv+?WhoAX^{eM4k+iSnDar5VY_4RN2
z?&F_)@1^E*lfQQSYhQfV&pdYVk?_>7KKGV;re6ENN8k3TH$M75-|}}4Jo*>m&t3TQ
zxBRQs|FAOu!{>bBmlJ=p`pf_QnV<Mj^u8bckN@|<AARKA@B7SKe)|RgaBAW1fpl&J
zq%Q?J=0EPXy41JE?hEWe{wI0==Wx7{UHFgo|C=!r{}U^gx`;EFpL-bpL@qb-{|<)w
z+e7J?|HV@5U^bUOn6)#xgHAeQ<Dl1UG6RQivY5!u;!so4$>8NKCuYC(Kc4Kp|0#={
z@FV+w`>`9uTW|l*VcZ9H|6cUso8LSLxFZ-(4hnS4|NIlj|C@`C?Ef3VL0#h?OUybr
zEt@PAGWpzWDUr5q9O`xQ>7<=Y=My<6>7=r`;_fi(FaJ~B`+vDK&VP;M|L*9#m(rg6
zx2HZi^R=gq{p_`yU$z%8qdHGg3Uti>%oEA~H#+}$BUq|y{9^|XW)pTQ?Ii7k@q@@&
zkh7Bq({ZPmwu>p`<iTQ)O*;dY{|TJ+g1;}Dh$rLp1;&vQbhQ6>BSwF0%*21ZKfQ9j
z@gHYj{%f!LgZD4~$@k~~_U&K(zsFwjfscOq-=2N!11CQB@1H;RcQaF8xiS42wX!=3
zbj*MF+=ubmi~lE!nBZNy8TN+y$p6>&|Had>ou#eW9jW{2|H<C-zd5Af8R`GKBlDh0
zbN|PW|9JQX6Q6z8w|?sR-#ho%mtXsu*1tIYvCn<zZQuOt;~%wu^VP5V!s+*Yw(w6c
zzNd8fv1dNx=l<~2(<k2eveVCd+Na;K@wFGe`gNat?90FVrQiSIs~4R&Y}|g^Gxxv!
z_M?ZM`=|F87T)|jNB-dJfBE_7rSJda<F$YN?SJQd<cs#JKK=P;eeZ?Oz4-_8&BtH-
zSGCW+`$vy|>(Y;E7e7+{?$cktdiVSG)RR%Ay-+~pzux4sm+CvJ({KK#dgp&4iT$6E
z{l6pfURR;>xO2(57#eS<^2JRkxQPKbNV&W^e%^}nHZ@!qh6{!8OKub&&+~Tnd0bsw
zL7uj8q>n{@bR-dI)p?(r>lZ7pQ~_NsTl8w;eoy4>K-ypjS+#jdkyrRUQg$?eh$I)D
zx9k=!yl>zxLgXT>pp5<w=8+2l^|iHf6LnVVD@@|;V{}~<d1_Tg7P+B!xZnJbL+|Xg
z|Kd3QH=6%L9~d++m@I-f0@G0&!=QjBwj2iJHq8F>zvui<Je3~Bf43<(yl*D4>F^pD
zL4HD0V0jsrc-5}pVwmMMT$8;#j1yd(|GUiplFTGW`Co1X<MfPw46IOXmYW-cYrU`h
z$6XJd`XAE&W=7}#2R8y+LrNV?&8DDkXCtu3u54Xy^yVj%0=@Ge>p{d={{!lB-}#^H
uiT_CFa-;aa0g-=OFucOk^YtX7nRqlY%Ko@5!A37f6c|xpM1h|W3jBW&X7`Z*

literal 0
HcmV?d00001

diff --git a/gix-tix/tests/fixtures/rebase_conflict.sh b/gix-tix/tests/fixtures/rebase_conflict.sh
new file mode 100644
index 00000000000..61477a9b04f
--- /dev/null
+++ b/gix-tix/tests/fixtures/rebase_conflict.sh
@@ -0,0 +1,15 @@
+#!/bin/sh
+set -eu
+
+# Removing the middle commit asks the tip's same-line edit to apply to an incompatible base.
+git init -q -b main .
+git config user.name author
+git config user.email author@example.com
+git config commit.gpgSign false
+printf 'base\n' >file
+git add file
+GIT_AUTHOR_DATE='2000-01-01T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-01T00:00:00 +0000' git commit -q -m base
+printf 'middle\n' >file
+git commit -qam middle
+printf 'tip\n' >file
+git commit -qam tip
diff --git a/gix-tix/tests/fixtures/rebase_edit.sh b/gix-tix/tests/fixtures/rebase_edit.sh
new file mode 100644
index 00000000000..a815dbdf838
--- /dev/null
+++ b/gix-tix/tests/fixtures/rebase_edit.sh
@@ -0,0 +1,22 @@
+#!/bin/sh
+set -eu
+
+# A three-commit linear stack makes parent-only rewrites and tree-transplanting observable.
+git init -q -b main .
+git config user.name author
+git config user.email author@example.com
+git config commit.gpgSign false
+
+printf 'base\n' >base
+git add base
+GIT_AUTHOR_DATE='2000-01-01T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-01T00:00:00 +0000' git commit -q -m base
+
+printf 'middle\n' >middle
+git add middle
+GIT_AUTHOR_DATE='2000-01-02T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-02T00:00:00 +0000' git commit -q -m middle
+git update-ref refs/patches/middle HEAD
+
+printf 'tip\n' >tip
+git add tip
+GIT_AUTHOR_DATE='2000-01-03T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-03T00:00:00 +0000' git commit -q -m tip
+git update-ref refs/patches/tip HEAD

From 94bf93a9611c64c77c39aa2296f79bbb58a40211 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 14:30:48 +0200
Subject: [PATCH 063/282] feat: trace tix edit durations

Instrument reword, create, forget, rebase, editor, and time-travel operations at both the user-action and internal phase boundaries. Exclude repositories, graphs, terminals, and message buffers from span fields while retaining commit and mode context.

Emit span close events through the existing diagnostic logger so each completed phase records tracing-subscriber busy and idle timing.
---
 gix-tix/src/edit/create.rs      | 2 ++
 gix-tix/src/edit/forget.rs      | 1 +
 gix-tix/src/edit/mod.rs         | 1 +
 gix-tix/src/edit/rebase.rs      | 1 +
 gix-tix/src/edit/reword.rs      | 2 ++
 gix-tix/src/edit/time_travel.rs | 1 +
 gix-tix/src/lib.rs              | 3 +++
 gix-tix/src/logging.rs          | 1 +
 8 files changed, 12 insertions(+)

diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 2c45abf09a9..c6a78bef600 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -18,6 +18,7 @@ pub(crate) struct Prepared {
     objects: gix::odb::memory::Storage,
 }
 
+#[tracing::instrument(skip_all, fields(parent = ?parent))]
 pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
     repo.workdir().context("creating a commit requires a worktree")?;
     let head = repo.head().context("could not read HEAD before creating a commit")?;
@@ -177,6 +178,7 @@ fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<Obj
     Ok(editor.write().context("could not build the worktree tree")?.detach())
 }
 
+#[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
 pub(crate) fn apply(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index 6286e576790..9302a64cc7f 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -5,6 +5,7 @@ use gix::{ObjectId, bstr::ByteSlice};
 
 use super::rebase;
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn perform(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 626952ce025..e20a1e5864a 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -50,6 +50,7 @@ pub(crate) mod rebase;
 pub(crate) mod reword;
 pub(crate) mod time_travel;
 
+#[tracing::instrument(skip_all, fields(filename))]
 pub(crate) fn edit_document(
     terminal: &mut ratatui::DefaultTerminal,
     editor: &OsStr,
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 7af41c2795d..0f71c2dd9de 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -56,6 +56,7 @@ pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
 }
 
+#[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
 pub(crate) fn perform(
     mut repo: gix::Repository,
     graph: &HistoryGraph,
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 738cf96b7a7..6bf9f589987 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -20,6 +20,7 @@ pub(super) struct Edit<'a> {
     pub message: BString,
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
     let editor = repo.editor().context("no Git editor is available")?;
     let mut commit = repo
@@ -67,6 +68,7 @@ pub(super) fn missing_agent_trailers(message: &[u8]) -> [Option<&'static [u8]>;
     ]
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %old_id))]
 pub(crate) fn apply(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 4ee0e5ee4d1..4b1f8cf988a 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -12,6 +12,7 @@ use gix::{
 
 use crate::{history, open_repository};
 
+#[tracing::instrument(skip_all, fields(commit_id = %selected))]
 pub(crate) fn perform(
     repository_path: &Path,
     bare: bool,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index dd95f7502a4..0d8c2f42964 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2735,6 +2735,7 @@ fn show_commit_diff(
     Ok(false)
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn reword_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
@@ -2766,6 +2767,7 @@ fn reword_commit(
     edit::reword::apply(repository, graph, id, &edited)
 }
 
+#[tracing::instrument(skip_all, fields(parent = ?parent))]
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
@@ -2794,6 +2796,7 @@ fn create_commit(
     edit::create::apply(repository, graph, prepared, &edited).map(Some)
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn forget_commit(
     repository_path: &Path,
     bare: bool,
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index a4df04558c5..f25350b1fa9 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -372,6 +372,7 @@ pub(crate) fn init() -> Result<tracing::subscriber::DefaultGuard> {
         tracing_subscriber::fmt::layer()
             .with_ansi(false)
             .with_target(false)
+            .with_span_events(tracing_subscriber::fmt::format::FmtSpan::CLOSE)
             .with_writer(appender)
             .with_filter(
                 Targets::new()

From 3ea168fc45a7c675b8ddcd35e12bcfb3acdb6fa9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 15:05:15 +0200
Subject: [PATCH 064/282] feat: amend and spill commits with lazy rebases

Add edit actions and CLI commands for amending HEAD from the index or
worktree and spilling its tree delta back into the worktree. Preserve
worktree files, reset the affected index, and atomically retarget mutable
references through the shared rebase transaction.

Mark cheaply reparented commits as pending with their original parent so
time travel can cherry-pick the complete deferred region correctly. Show
pending commits in cyan, invalidate stale signatures, and redo configured
signatures when the deferred rebase is completed.
---
 gix-tix/spec.md                 |  20 +++-
 gix-tix/src/app.rs              |  64 +++++++++++-
 gix-tix/src/edit/create.rs      |  34 ++++---
 gix-tix/src/edit/head.rs        | 166 ++++++++++++++++++++++++++++++++
 gix-tix/src/edit/mod.rs         |   2 +-
 gix-tix/src/edit/rebase.rs      |  86 ++++++++++++++---
 gix-tix/src/edit/time_travel.rs |  91 +++++++++++++++--
 gix-tix/src/history.rs          |   7 +-
 gix-tix/src/lib.rs              |  66 +++++++++++++
 gix-tix/src/main.rs             |  33 ++++++-
 gix-tix/src/ui.rs               |  17 ++++
 11 files changed, 544 insertions(+), 42 deletions(-)
 create mode 100644 gix-tix/src/edit/head.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 937248ecbd0..d6a53eab4ab 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -333,6 +333,22 @@ space first; changes blocks adapt within the remaining history width.
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
   inaccessible or conflicting affected worktrees abort safely.
 
+### Amend and spill
+
+- `e a` amends the current worktree's `@` commit with the changed index, or
+  worktree changes when the index already matches `HEAD`. `e s` spills that
+  commit's tree delta into the worktree by replacing its tree with its first
+  parent's tree, or the empty tree for a root commit. Clean operations are
+  unavailable and report a no-op through `tix edit amend|spill`.
+- Both operations leave worktree files untouched, reset the affected worktree's
+  index to the rewritten commit, and cheaply rewrite linear descendants with
+  their trees unchanged. Rewritten commits carry `tix-rebase: pending`, invalidate
+  existing signatures, retain the original parent needed for later replay, and
+  use a bright-cyan commit marker.
+- Time travel from either endpoint of a pending region completes the entire
+  marked rebase with cherry-picking and configured signing before checkout. A
+  conflict aborts before refs or worktrees change.
+
 ### Forget commits
 
 - `e`, then `d`, is available after history completion for a selected non-merge
@@ -377,8 +393,8 @@ space first; changes blocks adapt within the remaining history width.
 ### Editing shortcuts
 
 - `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
-  `e d d` confirms forgetting a top commit, and `e t` enters or returns from time
-  travel when each action is available.
+  `e a` amends `@`, `e s` spills `@`, `e d d` confirms forgetting a top commit,
+  and `e t` enters or returns from time travel when each action is available.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 6b005d5aaf0..c9e08d50ace 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -42,6 +42,7 @@ pub(crate) enum SignatureState {
     Verifying,
     Verified,
     Failed,
+    PendingRebase,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -285,6 +286,8 @@ pub(crate) enum Action {
     OpenDiff,
     Reword,
     NewCommit,
+    Amend,
+    Spill,
     Forget,
     TimeTravel,
     VerifySignatures,
@@ -308,6 +311,8 @@ pub(crate) enum Effect {
     OpenCommitDiff(ObjectId),
     Reword(ObjectId),
     NewCommit(Option<ObjectId>),
+    Amend(ObjectId),
+    Spill(ObjectId),
     Forget(ObjectId),
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
@@ -379,6 +384,8 @@ pub(crate) struct App {
     worktree_head: Option<ObjectId>,
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
+    amend_available: bool,
+    spill_available: bool,
     known_descendants: HashSet<ObjectId>,
     known_merge_descendants: HashSet<ObjectId>,
     select_top_after_refresh: bool,
@@ -454,6 +461,8 @@ impl App {
             worktree_head: None,
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
+            amend_available: false,
+            spill_available: false,
             known_descendants: HashSet::new(),
             known_merge_descendants: HashSet::new(),
             select_top_after_refresh: false,
@@ -680,7 +689,13 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleEdit | Action::Reword | Action::NewCommit | Action::Forget | Action::TimeTravel
+            Action::ToggleEdit
+                | Action::Reword
+                | Action::NewCommit
+                | Action::Amend
+                | Action::Spill
+                | Action::Forget
+                | Action::TimeTravel
         ) {
             self.edit_expanded = false;
         }
@@ -848,6 +863,16 @@ impl App {
                     self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
                 )];
             }
+            Action::Amend if self.can_amend() => {
+                return vec![Effect::Amend(
+                    self.rows[self.selected.expect("amend requires a selection")].id,
+                )];
+            }
+            Action::Spill if self.can_spill() => {
+                return vec![Effect::Spill(
+                    self.rows[self.selected.expect("spill requires a selection")].id,
+                )];
+            }
             Action::Forget if self.can_forget() => {
                 let id = self.rows[self.selected.expect("forget requires a selection")].id;
                 if self.forget_confirmation == Some(id) {
@@ -1352,6 +1377,29 @@ impl App {
                 .is_some_and(|row| row.parent_ids.len() <= 1 && !self.known_merge_descendants.contains(&row.id))
     }
 
+    fn can_edit_head(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
+                Some(row.id) == self.worktree_head && !self.known_merge_descendants.contains(&row.id)
+            })
+    }
+
+    pub(crate) fn can_amend(&self) -> bool {
+        self.can_edit_head() && self.amend_available
+    }
+
+    pub(crate) fn can_spill(&self) -> bool {
+        self.can_edit_head() && self.spill_available
+    }
+
+    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, spill: bool) {
+        self.amend_available = amend;
+        self.spill_available = spill;
+    }
+
     pub(crate) fn forget_confirmation_visible(&self) -> bool {
         self.selected
             .and_then(|index| self.rows.get(index))
@@ -2031,6 +2079,20 @@ mod tests {
         assert_eq!(app.update(Action::Reword), vec![Effect::Reword(id(1))]);
     }
 
+    #[test]
+    fn amend_and_spill_are_limited_to_the_current_worktree_head() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        app.set_worktree_head(Some(id(2)), false);
+        app.set_head_edit_availability(true, true);
+        complete(&mut app);
+        assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
+        assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
+        app.update(Action::MoveDown);
+        assert!(!app.can_amend());
+        assert!(app.update(Action::Amend).is_empty());
+    }
+
     #[test]
     fn forgetting_a_non_merge_tip_requires_a_second_d_and_navigation_cancels_it() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index c6a78bef600..5c3753ec678 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -66,20 +66,7 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
     {
         anyhow::bail!("cannot create a commit with unresolved index conflicts");
     }
-    let mut index_editor = repo.empty_tree().edit().context("could not prepare the index tree")?;
-    for entry in index.entries() {
-        let mode = entry
-            .mode
-            .to_tree_entry_mode()
-            .context("an index entry has an invalid mode")?;
-        index_editor
-            .upsert(entry.path(&index), mode.kind(), entry.id)
-            .context("could not add an index entry to the candidate tree")?;
-    }
-    let index_tree = index_editor
-        .write()
-        .context("could not build the candidate index tree")?
-        .detach();
+    let index_tree = index_tree(&repo, &index)?;
     let based_on_parent = head_id == parent;
     let tree = if based_on_parent && index_tree != baseline.id {
         index_tree
@@ -134,7 +121,24 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
     })
 }
 
-fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<ObjectId> {
+pub(super) fn index_tree(repo: &gix::Repository, index: &gix::index::File) -> Result<ObjectId> {
+    let mut editor = repo.empty_tree().edit().context("could not prepare the index tree")?;
+    for entry in index.entries() {
+        let mode = entry
+            .mode
+            .to_tree_entry_mode()
+            .context("an index entry has an invalid mode")?;
+        editor
+            .upsert(entry.path(index), mode.kind(), entry.id)
+            .context("could not add an index entry to the candidate tree")?;
+    }
+    Ok(editor
+        .write()
+        .context("could not build the candidate index tree")?
+        .detach())
+}
+
+pub(super) fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<ObjectId> {
     let changes = load_worktree_changes_without_lines(repo)?;
     if changes.paths.is_empty() {
         return Ok(baseline.id);
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
new file mode 100644
index 00000000000..ad1cd79257a
--- /dev/null
+++ b/gix-tix/src/edit/head.rs
@@ -0,0 +1,166 @@
+use anyhow::{Context, Result};
+use gix::ObjectId;
+
+use super::{create, rebase};
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum Kind {
+    Amend,
+    Spill,
+}
+
+#[tracing::instrument(skip_all, fields(?kind))]
+pub fn perform(
+    mut repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    kind: Kind,
+) -> Result<Option<ObjectId>> {
+    let head = repo
+        .head_id()
+        .context("editing requires an existing HEAD commit")?
+        .detach();
+    let mut commit = repo
+        .find_commit(head)
+        .context("could not find HEAD commit")?
+        .decode()
+        .context("could not decode HEAD commit")?
+        .into_owned()
+        .context("could not own HEAD commit")?;
+    repo.workdir().context("editing HEAD requires a worktree")?;
+    repo.commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+    repo = repo.with_object_memory();
+    let old_tree = commit.tree;
+    let parent_tree = match commit.parents.first().copied() {
+        Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
+        None => repo.empty_tree().id,
+    };
+    let tree = match kind {
+        Kind::Spill => parent_tree,
+        Kind::Amend => {
+            let index = repo.index_or_empty().context("could not load the index")?;
+            if index
+                .entries()
+                .iter()
+                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+            {
+                anyhow::bail!("cannot amend with unresolved index conflicts");
+            }
+            let index_tree = create::index_tree(&repo, &index)?;
+            drop(index);
+            if index_tree != old_tree {
+                index_tree
+            } else {
+                let baseline = repo.find_tree(old_tree)?;
+                create::worktree_tree(&repo, &baseline)?
+            }
+        }
+    };
+    if tree == old_tree {
+        return Ok(None);
+    }
+    commit.tree = tree;
+    Ok(rebase::perform(
+        repo,
+        graph,
+        rebase::Edit::Replace { target: head, commit },
+        rebase::Signature::InvalidateExisting,
+        rebase::Tree::LeaveAsIsAndMark,
+    )?
+    .selected)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use gix::bstr::ByteSlice;
+
+    use super::*;
+
+    fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated().config_overrides([
+                "user.name=editor".to_owned(),
+                "user.email=editor@example.com".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?)
+    }
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!("git {} failed: {}", args.join(" "), output.stderr.to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn amend_prefers_the_index_and_leaves_worktree_files_alone() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let graph = super::super::loaded_graph(&repo)?;
+        let new = perform(repo, &graph, Kind::Amend)?.expect("staged changes amend HEAD");
+        assert_ne!(new, old);
+        assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
+        assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"staged\n");
+        assert!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty(),
+            "the index follows the amended commit"
+        );
+        let commit = open(fixture.path())?.find_commit(new)?.decode()?.into_owned()?;
+        assert!(super::super::rebase::has_marker(&commit), "lazy descendants are marked");
+        Ok(())
+    }
+
+    #[test]
+    fn spill_moves_the_tip_tree_change_to_the_worktree() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let parent_tree = repo
+            .find_commit(old)?
+            .parent_ids()
+            .next()
+            .expect("tip has parent")
+            .object()?
+            .peel_to_tree()?
+            .id;
+        let graph = super::super::loaded_graph(&repo)?;
+        let new = perform(repo, &graph, Kind::Spill)?.expect("the tip introduces changes");
+        let repo = open(fixture.path())?;
+        assert_eq!(repo.find_commit(new)?.tree_id()?.detach(), parent_tree);
+        assert_eq!(
+            std::fs::read(fixture.path().join("tip"))?,
+            b"tip\n",
+            "worktree content survives"
+        );
+        assert!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty(),
+            "the index follows the spilled commit"
+        );
+        assert_eq!(git(fixture.path(), &["status", "--short"])?, b"?? tip\n");
+        let graph = super::super::loaded_graph(&repo)?;
+        assert_eq!(perform(repo, &graph, Kind::Spill)?, None, "an empty spill is a no-op");
+        Ok(())
+    }
+
+    #[test]
+    fn spilling_a_root_uses_the_empty_tree() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let new = perform(repo, &graph, Kind::Spill)?.expect("the root has a non-empty tree");
+        let repo = open(fixture.path())?;
+        assert_eq!(repo.find_commit(new)?.tree_id()?.detach(), repo.empty_tree().id);
+        assert!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty(),
+            "the root spill resets the index to empty"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index e20a1e5864a..d6d23f01c36 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -2,7 +2,6 @@ use std::{ffi::OsStr, io::Write, process::Command};
 
 use anyhow::{Context, Result};
 
-#[cfg(test)]
 pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::HistoryGraph> {
     use std::sync::atomic::AtomicBool;
 
@@ -46,6 +45,7 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
 
 pub(crate) mod create;
 pub(crate) mod forget;
+pub(crate) mod head;
 pub(crate) mod rebase;
 pub(crate) mod reword;
 pub(crate) mod time_travel;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 0f71c2dd9de..3cc1ed485fc 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -18,11 +18,11 @@ use gix::{
 use crate::history::HistoryGraph;
 
 const MARKER: &[u8] = b"tix-rebase";
+const ORIGINAL_PARENT: &[u8] = b"tix-rebase-parent";
 const PENDING: &[u8] = b"pending";
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum Signature {
-    #[allow(dead_code, reason = "available to edits which defer a rebase")]
     InvalidateExisting,
     RedoIfNeeded,
 }
@@ -46,7 +46,6 @@ pub(crate) enum Edit {
     Remove {
         target: ObjectId,
     },
-    #[allow(dead_code, reason = "available to resume a marked deferred rebase")]
     Repeat {
         base: ObjectId,
     },
@@ -54,6 +53,13 @@ pub(crate) enum Edit {
 
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
+    rewritten: HashMap<ObjectId, Option<ObjectId>>,
+}
+
+impl Outcome {
+    pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
+        self.rewritten.get(&id).copied().unwrap_or(Some(id))
+    }
 }
 
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
@@ -98,7 +104,7 @@ pub(crate) fn perform(
     if inserted {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark);
+        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark, root);
         let id = write_commit(&repo, commit, signature, signing.clone())?;
         selected = Some(id);
         if let Some(root) = root {
@@ -149,9 +155,25 @@ pub(crate) fn perform(
         if Some(old_id) != root || repeat {
             commit.committer = committer.clone();
         }
-        commit.tree = rewritten_tree(&repo, &commit, &old_parents, &new_parents, tree_mode)?;
+        let original_parent = repeat.then(|| marked_parent(&commit)).transpose()?.flatten();
+        let original_parents = original_parent.into_iter().collect::<Vec<_>>();
+        commit.tree = rewritten_tree(
+            &repo,
+            &commit,
+            if original_parents.is_empty() {
+                &old_parents
+            } else {
+                &original_parents
+            },
+            &new_parents,
+            tree_mode,
+        )?;
         commit.parents = new_parents.into_iter().collect();
-        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark);
+        marker(
+            &mut commit,
+            tree_mode == Tree::LeaveAsIsAndMark,
+            old_parents.first().copied(),
+        );
         let new_id = write_commit(&repo, commit, signature, signing.clone())?;
         rewritten.insert(old_id, Some(new_id));
         if Some(old_id) == root {
@@ -168,8 +190,15 @@ pub(crate) fn perform(
             .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
     }
 
-    let transitions = worktree_transitions(&repo, &rewritten, inserted)?;
-    let index_resets = inserted.then(|| inserted_index_resets(&repo, &rewritten)).transpose()?;
+    let transitions = worktree_transitions(&repo, &rewritten, inserted || tree_mode == Tree::LeaveAsIsAndMark)?;
+    let index_reset_from = if inserted || tree_mode == Tree::LeaveAsIsAndMark {
+        root
+    } else {
+        None
+    };
+    let index_resets = index_reset_from
+        .map(|old| index_resets(&repo, &rewritten, old))
+        .transpose()?;
     for transition in &transitions {
         super::forget::preflight_tree_transition(
             &transition.repo,
@@ -195,7 +224,7 @@ pub(crate) fn perform(
             return rollback(&repo, &committer, &transitions, &rollback_refs, err);
         }
     }
-    Ok(Outcome { selected })
+    Ok(Outcome { selected, rewritten })
 }
 
 fn rollback<T>(
@@ -222,9 +251,10 @@ fn rollback<T>(
     }
 }
 
-fn inserted_index_resets(
+fn index_resets(
     repo: &gix::Repository,
     rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+    reset_from: ObjectId,
 ) -> Result<Vec<IndexReset>> {
     let mut repos = vec![
         repo.main_repo()
@@ -248,6 +278,9 @@ fn inserted_index_resets(
         else {
             continue;
         };
+        if old != reset_from {
+            continue;
+        }
         let Some(Some(new)) = rewritten.get(&old).copied() else {
             continue;
         };
@@ -359,14 +392,30 @@ fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<Objec
     }
 }
 
-fn marker(commit: &mut gix::objs::Commit, add: bool) {
-    commit.extra_headers.retain(|(name, _)| name.as_slice() != MARKER);
+fn marker(commit: &mut gix::objs::Commit, add: bool, original_parent: Option<ObjectId>) {
+    commit
+        .extra_headers
+        .retain(|(name, _)| name.as_slice() != MARKER && name.as_slice() != ORIGINAL_PARENT);
     if add {
         commit.extra_headers.push((MARKER.into(), PENDING.into()));
+        if let Some(parent) = original_parent {
+            commit
+                .extra_headers
+                .push((ORIGINAL_PARENT.into(), parent.to_hex().to_string().into()));
+        }
     }
 }
 
-fn has_marker(commit: &gix::objs::Commit) -> bool {
+fn marked_parent(commit: &gix::objs::Commit) -> Result<Option<ObjectId>> {
+    commit
+        .extra_headers
+        .iter()
+        .find(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
+        .map(|(_, value)| ObjectId::from_hex(value).context("pending rebase has an invalid original parent"))
+        .transpose()
+}
+
+pub(super) fn has_marker(commit: &gix::objs::Commit) -> bool {
     commit
         .extra_headers
         .iter()
@@ -692,7 +741,8 @@ mod tests {
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
-        let commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~2")?)?.tree_id()?.detach();
         let marked = perform(
             repo.clone(),
             &graph,
@@ -717,6 +767,16 @@ mod tests {
             assert!(!has_marker(&commit), "repeating clears every pending marker");
             id = commit.parents.first().copied();
         }
+        let files = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["ls-tree", "-r", "--name-only", "HEAD"])
+            .output()?;
+        assert!(files.status.success());
+        assert_eq!(
+            files.stdout, b"base\ntip\n",
+            "repeat cherry-picks the descendant against its recorded original parent"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 4b1f8cf988a..cf01542466f 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -16,21 +16,43 @@ use crate::{history, open_repository};
 pub(crate) fn perform(
     repository_path: &Path,
     bare: bool,
-    selected: ObjectId,
+    mut selected: ObjectId,
     graph: &history::HistoryGraph,
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
-    let repository =
+    let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
     let workdir = repository
         .workdir()
         .context("time-travel requires a worktree")?
         .to_owned();
     let head = repository.head().context("could not read HEAD before time-travel")?;
-    let Some(head_id) = head.id().map(gix::Id::detach) else {
+    let Some(mut head_id) = head.id().map(gix::Id::detach) else {
         anyhow::bail!("cannot time-travel from an unborn HEAD");
     };
+    let head_referent = head.referent_name().map(ToOwned::to_owned);
+    drop(head);
+    let mut completed_graph = None;
+    while let Some(base) = pending_base(&repository, head_id, selected)? {
+        let outcome = super::rebase::perform(
+            repository,
+            completed_graph.as_ref().unwrap_or(graph),
+            super::rebase::Edit::Repeat { base },
+            super::rebase::Signature::RedoIfNeeded,
+            super::rebase::Tree::CherryPick,
+        )?;
+        selected = outcome
+            .map(selected)
+            .context("the time-travel destination disappeared while completing its rebase")?;
+        head_id = outcome
+            .map(head_id)
+            .context("HEAD disappeared while completing its rebase")?;
+        repository = open_repository(repository_path, bare, false)
+            .context("could not reopen repository after completing a pending rebase")?;
+        completed_graph = Some(super::loaded_graph(&repository)?);
+    }
+    let graph = completed_graph.as_ref().unwrap_or(graph);
     if selected == head_id {
         return Ok(None);
     }
@@ -44,10 +66,7 @@ pub(crate) fn perform(
             Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
         }));
     }
-    let saved_target = head
-        .referent_name()
-        .map(|name| Target::Symbolic(name.to_owned()))
-        .unwrap_or(Target::Object(head_id));
+    let saved_target = head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id));
     let provisional = graph
         .is_ancestor(selected, head_id)
         .then(|| create_or_reuse_pin(&repository, saved_target, head_id))
@@ -91,6 +110,32 @@ pub(crate) fn perform(
     Ok(Some(notice))
 }
 
+fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId) -> Result<Option<ObjectId>> {
+    for endpoint in [head, selected] {
+        let mut current = endpoint;
+        let mut base = None;
+        loop {
+            let commit = repository
+                .find_commit(current)
+                .context("could not inspect a time-travel endpoint for a pending rebase")?
+                .decode()?
+                .into_owned()?;
+            if !super::rebase::has_marker(&commit) {
+                break;
+            }
+            base = Some(current);
+            let Some(parent) = commit.parents.first().copied() else {
+                break;
+            };
+            current = parent;
+        }
+        if base.is_some() {
+            return Ok(base);
+        }
+    }
+    Ok(None)
+}
+
 fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
     let mut pins: Vec<_> = history::applicable_pins(repository)?
         .into_iter()
@@ -376,4 +421,36 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn travelling_completes_the_whole_pending_rebase() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        let commit = repository.find_commit(middle)?.decode()?.into_owned()?;
+        super::super::rebase::perform(
+            repository.clone(),
+            &graph,
+            super::super::rebase::Edit::Replace { target: middle, commit },
+            super::super::rebase::Signature::InvalidateExisting,
+            super::super::rebase::Tree::LeaveAsIsAndMark,
+        )?;
+        let graph = loaded_graph(&repository, &[])?;
+        perform(&repository_path, false, root, &graph, &[], false)?;
+
+        let repository = crate::open_test_repository(fixture.path())?;
+        let mut current = Some(repository.find_reference("refs/heads/main")?.id().detach());
+        while let Some(id) = current {
+            let commit = repository.find_commit(id)?.decode()?.into_owned()?;
+            assert!(
+                !super::super::rebase::has_marker(&commit),
+                "time travel clears the complete pending region"
+            );
+            current = commit.parents.first().copied();
+        }
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 6ae03b4394e..5eb238f51b5 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1361,7 +1361,12 @@ fn decode_metadata<'a>(
                     }
                 }
             }
-            Token::ExtraHeader((name, _)) if name == "gpgsig" || name == "gpgsig-sha256" => {
+            Token::ExtraHeader((name, value)) if name == "tix-rebase" && value.as_ref() == b"pending" => {
+                signature = SignatureState::PendingRebase;
+            }
+            Token::ExtraHeader((name, _))
+                if (name == "gpgsig" || name == "gpgsig-sha256") && signature != SignatureState::PendingRebase =>
+            {
                 signature = SignatureState::Unverified;
             }
             _ => {}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 0d8c2f42964..79f055d604d 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -745,6 +745,30 @@ pub struct Options {
     pub worktrees: bool,
 }
 
+/// An edit applied to the commit checked out by the current worktree.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum HeadEdit {
+    /// Add staged changes, or worktree changes when nothing is staged, to `HEAD`.
+    Amend,
+    /// Move the changes introduced by `HEAD` into the worktree.
+    Spill,
+}
+
+/// Apply `edit` to the current worktree's `HEAD` without starting the terminal UI.
+pub fn edit_head(repository: gix::ThreadSafeRepository, edit: HeadEdit) -> Result<Option<gix::ObjectId>> {
+    let _log_guard = logging::init().context("could not initialize tix diagnostics")?;
+    let repository = repository.to_thread_local();
+    let graph = edit::loaded_graph(&repository)?;
+    edit::head::perform(
+        repository,
+        &graph,
+        match edit {
+            HeadEdit::Amend => edit::head::Kind::Amend,
+            HeadEdit::Spill => edit::head::Kind::Spill,
+        },
+    )
+}
+
 fn detect_commit_pane_background() -> Option<(u8, u8, u8)> {
     let mut options = terminal_colorsaurus::QueryOptions::default();
     options.timeout = THEME_QUERY_TIMEOUT;
@@ -1742,6 +1766,44 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("new commit: {err:#}")),
                     }
                 }
+                edit @ (Effect::Amend(id) | Effect::Spill(id)) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let kind = if matches!(edit, Effect::Amend(_)) {
+                        edit::head::Kind::Amend
+                    } else {
+                        edit::head::Kind::Spill
+                    };
+                    let verb = if kind == edit::head::Kind::Amend {
+                        "amend"
+                    } else {
+                        "spill"
+                    };
+                    let result = history_graph
+                        .as_ref()
+                        .context("editing HEAD requires a completed history graph")
+                        .and_then(|graph| {
+                            edit::head::perform(
+                                open_repository(&repository_path, repository_is_bare, false)
+                                    .context("could not open repository for HEAD edit")?,
+                                graph,
+                                kind,
+                            )
+                        });
+                    match result {
+                        Ok(Some(new_id)) => {
+                            app.leave_message(format!(
+                                "{verb}ed {} as {}",
+                                id.to_hex_with_len(7),
+                                new_id.to_hex_with_len(7)
+                            ));
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Ok(None) => app.leave_message(format!("nothing to {verb}")),
+                        Err(err) => app.leave_message(format!("{verb}: {err:#}")),
+                    }
+                }
                 Effect::Forget(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -3520,6 +3582,8 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
         KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
         KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
+        KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
+        KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
@@ -4405,6 +4469,8 @@ mod tests {
         for (key, expected) in [
             ('r', Action::Reword),
             ('n', Action::NewCommit),
+            ('a', Action::Amend),
+            ('s', Action::Spill),
             ('d', Action::Forget),
             ('t', Action::TimeTravel),
         ] {
diff --git a/gix-tix/src/main.rs b/gix-tix/src/main.rs
index 40132e32788..942d159e7d7 100644
--- a/gix-tix/src/main.rs
+++ b/gix-tix/src/main.rs
@@ -5,10 +5,25 @@ use std::ffi::OsString;
 use anyhow::{Context, Result};
 
 fn main() -> Result<()> {
-    let (revisions, options, help) = arguments(gix::env::args_os().skip(1))?;
+    let mut args = gix::env::args_os().skip(1).peekable();
+    let edit = if args.peek().is_some_and(|arg| arg == "edit") {
+        args.next();
+        let edit = match args.next().as_deref() {
+            Some(value) if value == "amend" => gix_tix::HeadEdit::Amend,
+            Some(value) if value == "spill" => gix_tix::HeadEdit::Spill,
+            _ => anyhow::bail!("usage: tix edit amend|spill"),
+        };
+        if args.next().is_some() {
+            anyhow::bail!("usage: tix edit amend|spill");
+        }
+        Some(edit)
+    } else {
+        None
+    };
+    let (revisions, options, help) = arguments(args)?;
     if help {
         println!(
-            "Usage: tix [--quit-on-finish] [-w|--worktrees] [-h|--hide REVSPEC] [REVISION]...\n\nBrowse commits reachable from HEAD or the given revisions.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n  -w, --worktrees     Add all worktree HEADs as visible tips\n      --help          Print help"
+            "Usage: tix [--quit-on-finish] [-w|--worktrees] [-h|--hide REVSPEC] [REVISION]...\n       tix edit amend|spill\n\nBrowse commits reachable from HEAD or edit its checked-out commit.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n  -w, --worktrees     Add all worktree HEADs as visible tips\n      --help          Print help"
         );
         return Ok(());
     }
@@ -16,6 +31,20 @@ fn main() -> Result<()> {
     let current_dir = std::env::current_dir().context("could not determine current directory")?;
     let repository = gix::ThreadSafeRepository::discover_with_environment_overrides(current_dir)
         .context("could not discover repository")?;
+    if let Some(edit) = edit {
+        match gix_tix::edit_head(repository, edit)? {
+            Some(id) => println!("{}", id.to_hex_with_len(7)),
+            None => println!(
+                "nothing to {}",
+                if edit == gix_tix::HeadEdit::Amend {
+                    "amend"
+                } else {
+                    "spill"
+                }
+            ),
+        }
+        return Ok(());
+    }
     gix_tix::run(repository, revisions, options)
 }
 
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index d6f831e8e85..144b2676ec0 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -243,6 +243,15 @@ pub(crate) fn draw_with_worktree(
         && changes_panes
             .iter()
             .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0);
+    let selected_is_head = app.selected.and_then(|index| app.rows.get(index)).is_some_and(|row| {
+        decorations
+            .get(&row.id)
+            .is_some_and(|refs| refs.iter().any(|r| r.kind == DecorationKind::Head))
+    });
+    app.set_head_edit_availability(
+        selected_is_head && worktree_changes.is_some_and(|changes| !changes.paths.is_empty()),
+        selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
+    );
     if app.changes_visible() {
         app.set_changes_layout(
             changes_layout,
@@ -685,6 +694,12 @@ pub(crate) fn draw_with_worktree(
             if app.can_create_commit() {
                 options.push(("new", 'n'));
             }
+            if app.can_amend() {
+                options.push(("amend", 'a'));
+            }
+            if app.can_spill() {
+                options.push(("spill", 's'));
+            }
             if app.can_forget() {
                 options.push(if app.forget_confirmation_visible() {
                     ("d again forget", 'd')
@@ -1730,6 +1745,7 @@ fn signature_color(signature: SignatureState) -> Color {
         SignatureState::Unverified | SignatureState::Verifying => Color::Rgb(255, 165, 0),
         SignatureState::Verified => Color::Green,
         SignatureState::Failed => Color::LightRed,
+        SignatureState::PendingRebase => Color::LightCyan,
     }
 }
 
@@ -2796,6 +2812,7 @@ mod tests {
             (SignatureState::Unverified, Color::Rgb(255, 165, 0)),
             (SignatureState::Verified, Color::Green),
             (SignatureState::Failed, Color::LightRed),
+            (SignatureState::PendingRebase, Color::LightCyan),
         ];
         let mut terminal = Terminal::new(TestBackend::new(4, states.len() as u16))?;
         terminal.draw(|frame| {

From 5556f0d6693b56452097a6401feeb6937bf6e277 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 15:20:28 +0200
Subject: [PATCH 065/282] feat: spill selected tree paths

Keep the history edit prefix available while the tree-changes block has
focus and scope spill to its selected path. Restore that path from the
currently displayed parent while retaining every other tree change, then
reuse the existing lazy rebase transaction to preserve worktree files,
reset the index, invalidate signatures, and update mutable refs.

Leave the command-line edit interface unchanged so tix edit spill continues
to spill the complete commit.
---
 gix-tix/spec.md          |   3 ++
 gix-tix/src/app.rs       |  15 ++++--
 gix-tix/src/edit/head.rs | 112 ++++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs       |  31 ++++++++---
 gix-tix/src/ui.rs        |  68 ++++++++++++++++++++++--
 5 files changed, 209 insertions(+), 20 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index d6a53eab4ab..4c360bb2528 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -340,6 +340,9 @@ space first; changes blocks adapt within the remaining history width.
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
   unavailable and report a no-op through `tix edit amend|spill`.
+- With a path selected in the focused tree-changes block, the main `e` prefix
+  offers `spill` and `e s` spills only that path against the displayed parent.
+  The CLI intentionally supports only whole-commit spilling.
 - Both operations leave worktree files untouched, reset the affected worktree's
   index to the rewritten commit, and cheaply rewrite linear descendants with
   their trees unchanged. Rewritten commits carry `tix-rebase: pending`, invalidate
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index c9e08d50ace..39cb8297deb 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1380,7 +1380,6 @@ impl App {
     fn can_edit_head(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
-            && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
                 Some(row.id) == self.worktree_head && !self.known_merge_descendants.contains(&row.id)
@@ -1388,11 +1387,11 @@ impl App {
     }
 
     pub(crate) fn can_amend(&self) -> bool {
-        self.can_edit_head() && self.amend_available
+        self.can_edit_head() && self.changes_focus.is_none() && self.amend_available
     }
 
     pub(crate) fn can_spill(&self) -> bool {
-        self.can_edit_head() && self.spill_available
+        self.can_edit_head() && matches!(self.changes_focus, None | Some(ChangePane::Tree)) && self.spill_available
     }
 
     pub(crate) fn set_head_edit_availability(&mut self, amend: bool, spill: bool) {
@@ -2088,6 +2087,16 @@ mod tests {
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
         assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
+        app.changes_focus = Some(ChangePane::Tree);
+        assert!(!app.can_amend(), "a tree path cannot be amended");
+        assert_eq!(
+            app.update(Action::Spill),
+            vec![Effect::Spill(id(2))],
+            "tree focus scopes spill to its selected path"
+        );
+        app.changes_focus = Some(ChangePane::Worktree);
+        assert!(!app.can_spill(), "worktree paths cannot be spilled from a commit");
+        app.changes_focus = None;
         app.update(Action::MoveDown);
         assert!(!app.can_amend());
         assert!(app.update(Action::Amend).is_empty());
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index ad1cd79257a..b40cfadcfe1 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -1,7 +1,8 @@
 use anyhow::{Context, Result};
-use gix::ObjectId;
+use gix::{ObjectId, bstr::BStr};
 
 use super::{create, rebase};
+use crate::{ChangeKind, PathChange};
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub enum Kind {
@@ -14,6 +15,7 @@ pub fn perform(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     kind: Kind,
+    selected_path: Option<(&PathChange, Option<ObjectId>)>,
 ) -> Result<Option<ObjectId>> {
     let head = repo
         .head_id()
@@ -36,7 +38,12 @@ pub fn perform(
         None => repo.empty_tree().id,
     };
     let tree = match kind {
-        Kind::Spill => parent_tree,
+        Kind::Spill => match selected_path {
+            Some((path, selected_parent)) => {
+                spill_path_tree(&repo, old_tree, selected_parent.unwrap_or(parent_tree), path)?
+            }
+            None => parent_tree,
+        },
         Kind::Amend => {
             let index = repo.index_or_empty().context("could not load the index")?;
             if index
@@ -70,6 +77,63 @@ pub fn perform(
     .selected)
 }
 
+fn spill_path_tree(
+    repo: &gix::Repository,
+    commit_tree: ObjectId,
+    parent_tree: ObjectId,
+    change: &PathChange,
+) -> Result<ObjectId> {
+    let parent = repo.find_tree(parent_tree).context("could not load the parent tree")?;
+    let mut editor = repo
+        .find_tree(commit_tree)
+        .context("could not load the commit tree")?
+        .edit()
+        .context("could not edit the commit tree")?;
+    match change.kind {
+        ChangeKind::Added => {
+            editor.remove(&change.path).context("could not spill the added path")?;
+        }
+        ChangeKind::Deleted | ChangeKind::Modified | ChangeKind::TypeChanged => {
+            restore_path(&parent, &mut editor, &change.path)?;
+        }
+        ChangeKind::Renamed | ChangeKind::Copied => {
+            editor
+                .remove(&change.path)
+                .context("could not spill the rewritten destination")?;
+            if change.kind == ChangeKind::Renamed {
+                restore_path(
+                    &parent,
+                    &mut editor,
+                    change.source.as_ref().context("a rename has no source path")?,
+                )?;
+            }
+        }
+        ChangeKind::Unmerged => anyhow::bail!("cannot spill an unmerged path"),
+    }
+    Ok(editor
+        .write()
+        .context("could not build the partially spilled tree")?
+        .detach())
+}
+
+fn restore_path(
+    parent: &gix::Tree<'_>,
+    editor: &mut gix::object::tree::Editor<'_>,
+    path: &gix::bstr::BString,
+) -> Result<()> {
+    let entry = parent
+        .lookup_entry(
+            path.split(|byte| *byte == b'/')
+                .map(|component| BStr::new(component).to_owned()),
+        )
+        .context("could not look up the path in the parent tree")?
+        .context("the path is absent from the parent tree")?;
+    editor
+        .upsert(path, entry.mode().kind(), entry.object_id())
+        .context("could not restore the path from the parent tree")?;
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command};
@@ -103,7 +167,7 @@ mod tests {
         let repo = open(fixture.path())?;
         let old = repo.head_id()?.detach();
         let graph = super::super::loaded_graph(&repo)?;
-        let new = perform(repo, &graph, Kind::Amend)?.expect("staged changes amend HEAD");
+        let new = perform(repo, &graph, Kind::Amend, None)?.expect("staged changes amend HEAD");
         assert_ne!(new, old);
         assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
         assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"staged\n");
@@ -130,7 +194,7 @@ mod tests {
             .peel_to_tree()?
             .id;
         let graph = super::super::loaded_graph(&repo)?;
-        let new = perform(repo, &graph, Kind::Spill)?.expect("the tip introduces changes");
+        let new = perform(repo, &graph, Kind::Spill, None)?.expect("the tip introduces changes");
         let repo = open(fixture.path())?;
         assert_eq!(repo.find_commit(new)?.tree_id()?.detach(), parent_tree);
         assert_eq!(
@@ -144,7 +208,11 @@ mod tests {
         );
         assert_eq!(git(fixture.path(), &["status", "--short"])?, b"?? tip\n");
         let graph = super::super::loaded_graph(&repo)?;
-        assert_eq!(perform(repo, &graph, Kind::Spill)?, None, "an empty spill is a no-op");
+        assert_eq!(
+            perform(repo, &graph, Kind::Spill, None)?,
+            None,
+            "an empty spill is a no-op"
+        );
         Ok(())
     }
 
@@ -153,7 +221,7 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
-        let new = perform(repo, &graph, Kind::Spill)?.expect("the root has a non-empty tree");
+        let new = perform(repo, &graph, Kind::Spill, None)?.expect("the root has a non-empty tree");
         let repo = open(fixture.path())?;
         assert_eq!(repo.find_commit(new)?.tree_id()?.detach(), repo.empty_tree().id);
         assert!(
@@ -163,4 +231,36 @@ mod tests {
         assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
         Ok(())
     }
+
+    #[test]
+    fn spilling_one_path_keeps_the_other_commit_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        std::fs::write(fixture.path().join("other"), "other\n")?;
+        git(fixture.path(), &["add", "other"])?;
+        git(fixture.path(), &["commit", "--amend", "--no-edit"])?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let selected = PathChange {
+            kind: ChangeKind::Added,
+            group: crate::ChangeGroup::Tree,
+            source: None,
+            path: "tip".into(),
+            lines: None,
+        };
+        let new =
+            perform(repo, &graph, Kind::Spill, Some((&selected, None)))?.expect("the selected path can be spilled");
+        let repo = open(fixture.path())?;
+        let tree = repo.find_commit(new)?.tree()?;
+        assert!(
+            tree.lookup_entry(["other"])?.is_some(),
+            "the unselected addition remains committed"
+        );
+        assert!(
+            tree.lookup_entry(["tip"])?.is_none(),
+            "the selected addition is spilled"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("tip"))?, b"tip\n");
+        assert_eq!(git(fixture.path(), &["status", "--short"])?, b"?? tip\n");
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 79f055d604d..03c83f7da9f 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -766,6 +766,7 @@ pub fn edit_head(repository: gix::ThreadSafeRepository, edit: HeadEdit) -> Resul
             HeadEdit::Amend => edit::head::Kind::Amend,
             HeadEdit::Spill => edit::head::Kind::Spill,
         },
+        None,
     )
 }
 
@@ -1779,16 +1780,34 @@ fn event_loop(
                     } else {
                         "spill"
                     };
+                    let path = (kind == edit::head::Kind::Spill && app.changes_focus == Some(ChangePane::Tree))
+                        .then(|| {
+                            tree_changes
+                                .as_ref()
+                                .filter(|(cached_id, _, _)| *cached_id == id)
+                                .and_then(|(_, _, changes)| {
+                                    changes
+                                        .paths
+                                        .get(app.tree_changes.selected)
+                                        .cloned()
+                                        .map(|path| (path, changes.parent.map(|parent| parent.id)))
+                                })
+                                .context("selected tree path is no longer available")
+                        })
+                        .transpose();
                     let result = history_graph
                         .as_ref()
                         .context("editing HEAD requires a completed history graph")
                         .and_then(|graph| {
-                            edit::head::perform(
-                                open_repository(&repository_path, repository_is_bare, false)
-                                    .context("could not open repository for HEAD edit")?,
-                                graph,
-                                kind,
-                            )
+                            path.and_then(|path| {
+                                edit::head::perform(
+                                    open_repository(&repository_path, repository_is_bare, false)
+                                        .context("could not open repository for HEAD edit")?,
+                                    graph,
+                                    kind,
+                                    path.as_ref().map(|(path, parent)| (path, *parent)),
+                                )
+                            })
                         });
                     match result {
                         Ok(Some(new_id)) => {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 144b2676ec0..a1ae02852a3 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -657,7 +657,7 @@ pub(crate) fn draw_with_worktree(
     };
     let mut footer_spans = vec![Span::raw(status)];
     let mut edit_prefix_spans = Vec::new();
-    if app.changes_focus.is_none() {
+    if app.changes_focus != Some(ChangePane::Worktree) {
         let time_travel = if app.time_travel_shortcut_visible()
             && decorations
                 .values()
@@ -688,10 +688,10 @@ pub(crate) fn draw_with_worktree(
         };
         if app.edit_expanded {
             let mut options = Vec::new();
-            if app.reword_shortcut_visible() {
+            if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'r'));
             }
-            if app.can_create_commit() {
+            if app.changes_focus.is_none() && app.can_create_commit() {
                 options.push(("new", 'n'));
             }
             if app.can_amend() {
@@ -700,14 +700,16 @@ pub(crate) fn draw_with_worktree(
             if app.can_spill() {
                 options.push(("spill", 's'));
             }
-            if app.can_forget() {
+            if app.changes_focus.is_none() && app.can_forget() {
                 options.push(if app.forget_confirmation_visible() {
                     ("d again forget", 'd')
                 } else {
                     ("d forget", 'd')
                 });
             }
-            if let Some(label) = time_travel {
+            if app.changes_focus.is_none()
+                && let Some(label) = time_travel
+            {
                 options.push(label);
             }
             edit_prefix_spans.push(Span::raw(" · "));
@@ -2669,6 +2671,62 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn focused_tree_path_offers_only_spill_in_the_main_edit_prefix() -> Result<(), Box<dyn std::error::Error>> {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(4);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        app.set_worktree_head(Some(id), false);
+        complete(&mut app);
+        app.changes_focus = Some(ChangePane::Tree);
+        app.edit_expanded = true;
+        let changes = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Added,
+                group: ChangeGroup::Tree,
+                source: None,
+                path: "file".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        let decorations = Decorations::from([(
+            id,
+            vec![Decoration {
+                name: "HEAD".into(),
+                kind: DecorationKind::Head,
+            }],
+        )]);
+        let mut terminal = Terminal::new(TestBackend::new(120, 8))?;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        let footer = rendered_line(&terminal, 7);
+        assert!(
+            footer.contains("edit (spill)"),
+            "tree focus keeps the scoped edit visible: {footer}"
+        );
+        assert!(!footer.contains("amend"), "tree paths cannot be amended");
+        Ok(())
+    }
+
     #[test]
     fn renders_worktree_labels_and_keeps_them_selected_when_refs_are_hidden() -> Result<(), Box<dyn std::error::Error>>
     {

From 5ac278a71e882472ad4f12de038905e2af8444d6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 15:29:00 +0200
Subject: [PATCH 066/282] feat: expose hidden branch divergence in tix

Use named hidden local refs and the persistent history graph to find their best common bases with the visible view. Render the view-relative missing count as a right-aligned behind marker with stable margins, retain normal reference display, and tolerate unavailable hidden revisions when another requested hidden revision resolves.
---
 gix-tix/spec.md        |  14 +++--
 gix-tix/src/app.rs     |  18 +++++--
 gix-tix/src/history.rs | 115 ++++++++++++++++++++++++++++++++++++++++-
 gix-tix/src/lib.rs     |  28 +++++++++-
 gix-tix/src/ui.rs      |  71 +++++++++++++++++++++----
 5 files changed, 225 insertions(+), 21 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 4c360bb2528..3f14ebea243 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -20,8 +20,9 @@ without trading responsiveness for metadata that is not visible.
   revisions. Hidden revisions still exclude matching ancestry.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
-- Revisions must resolve and peel to commits. Invalid or non-commit revisions are
-  errors.
+- Revisions must resolve and peel to commits. Invalid or non-commit visible
+  revisions are errors. An unavailable hidden revision emits a warning and is
+  ignored when another hidden revision resolves; if none resolve, startup fails.
 - The UI always owns the alternate screen. Raw mode, focus reporting, mouse
   capture, and enhanced keyboard reporting are restored on every exit path.
 - `Ctrl-C` exits immediately from any normal tix focus. `q` quits from history;
@@ -57,11 +58,16 @@ without trading responsiveness for metadata that is not visible.
 - Boundary rows retain graph styling but use terminal-default colors, are dimmed,
   and cannot be selected, paged to, copied, signature-verified, restored as a
   selection, or entered by Shift navigation.
-- When hidden revisions are configured, references are hidden by default so
-  metadata remains aligned.
+- Hidden revisions do not change the default reference display mode.
 - `v`, then `h`, toggles the full hidden projection. Toggling preserves the
   selected commit when it still exists and otherwise selects the newest
   selectable row.
+- When a hidden revspec names a local branch, its best common base with the
+  visible tips permanently shows `⇣N` after the commit title when that branch has
+  `N` commits not reachable from the view. The terminal edge pushes the marker
+  left over a clipped title when necessary. A blank margin remains on each side.
+  The cached history graph supplies the base and count; unrelated refs and
+  zero-count relations add no marker.
 
 ### Row content and visual states
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 39cb8297deb..bd74b4368e1 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -393,6 +393,7 @@ pub(crate) struct App {
     signature_verification_running: bool,
     pub(crate) manual_refresh: bool,
     pub(crate) selection_relation: Option<SelectionRelation>,
+    hidden_branch_behind: HashMap<ObjectId, usize>,
 }
 
 impl App {
@@ -470,6 +471,7 @@ impl App {
             signature_verification_running: false,
             manual_refresh: false,
             selection_relation: None,
+            hidden_branch_behind: HashMap::new(),
         }
     }
 
@@ -483,9 +485,6 @@ impl App {
 
     pub(crate) fn configure_hidden_filter(&mut self, present: bool) {
         self.has_hidden_filter = present;
-        if present {
-            self.ref_mode = RefMode::None;
-        }
     }
 
     pub(crate) fn set_worktree_head(&mut self, head: Option<ObjectId>, select_on_load: bool) {
@@ -974,6 +973,14 @@ impl App {
         self.hidden_rows.clone()
     }
 
+    pub(crate) fn set_hidden_branch_behind(&mut self, markers: HashMap<ObjectId, usize>) {
+        self.hidden_branch_behind = markers;
+    }
+
+    pub(crate) fn hidden_branch_behind(&self, id: ObjectId) -> Option<usize> {
+        self.hidden_branch_behind.get(&id).copied()
+    }
+
     pub(crate) fn start_refresh(
         &mut self,
         commits: LoadedCommits,
@@ -1089,6 +1096,7 @@ impl App {
         self.all_rows.clear();
         self.all_order.clear();
         self.hidden_rows.clear();
+        self.hidden_branch_behind.clear();
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
@@ -2791,8 +2799,8 @@ mod tests {
         app.configure_hidden_filter(true);
         assert_eq!(
             app.ref_mode,
-            RefMode::None,
-            "hidden ancestry hides references by default"
+            RefMode::Default,
+            "hidden ancestry keeps the normal reference display"
         );
         app.extend_commits(vec![row(1)]);
         assert!(
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 5eb238f51b5..8e015885305 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -407,13 +407,51 @@ impl HistoryGraph {
             .map(|(visible, _)| crate::app::SelectionRelation::Visible(visible))
     }
 
+    pub(crate) fn hidden_branch_behind(
+        &self,
+        view_tips: &[ObjectId],
+        hidden_tips: impl IntoIterator<Item = ObjectId>,
+    ) -> HashMap<ObjectId, usize> {
+        let hidden_tips: HashSet<_> = hidden_tips.into_iter().collect();
+        let mut out: HashMap<ObjectId, usize> = HashMap::new();
+        for tip in hidden_tips {
+            let Some((ahead, _, bases)) = self.paint_with_bases(tip, view_tips) else {
+                continue;
+            };
+            if ahead == 0 {
+                continue;
+            }
+            for base in bases {
+                out.entry(base)
+                    .and_modify(|previous| *previous = (*previous).max(ahead))
+                    .or_insert(ahead);
+            }
+        }
+        out
+    }
+
     fn paint(&self, first: ObjectId, others: &[ObjectId]) -> Option<(usize, usize)> {
+        self.paint_inner(first, others, false)
+            .map(|(ahead, behind, _)| (ahead, behind))
+    }
+
+    fn paint_with_bases(&self, first: ObjectId, others: &[ObjectId]) -> Option<(usize, usize, Vec<ObjectId>)> {
+        self.paint_inner(first, others, true)
+    }
+
+    fn paint_inner(
+        &self,
+        first: ObjectId,
+        others: &[ObjectId],
+        collect_bases: bool,
+    ) -> Option<(usize, usize, Vec<ObjectId>)> {
         let first = self.index(first)?;
         let others: Vec<_> = others.iter().map(|id| self.index(*id)).collect::<Option<_>>()?;
         let mut flags = vec![0u8; self.commits.len()];
         let mut queue = gix::revwalk::PriorityQueue::<GenThenTime, CommitIndex>::new();
         let mut queued = vec![false; self.commits.len()];
         let mut pending = 0usize;
+        let mut bases = Vec::new();
         for (index, flag) in std::iter::once((first, VISIBLE)).chain(others.into_iter().map(|index| (index, HIDDEN))) {
             flags[index.as_usize()] |= flag;
             if !queued[index.as_usize()] {
@@ -430,6 +468,9 @@ impl HistoryGraph {
                 pending -= 1;
             }
             if propagated & (VISIBLE | HIDDEN) == VISIBLE | HIDDEN {
+                if collect_bases && propagated & STALE == 0 {
+                    bases.push(self.id(index));
+                }
                 propagated |= STALE;
                 flags[index.as_usize()] = propagated;
             }
@@ -461,7 +502,15 @@ impl HistoryGraph {
                 _ => {}
             }
         }
-        Some((ahead, behind))
+        if collect_bases && bases.len() > 1 {
+            let candidates = bases.clone();
+            bases.retain(|candidate| {
+                !candidates
+                    .iter()
+                    .any(|other| candidate != other && self.is_ancestor(*candidate, *other))
+            });
+        }
+        Some((ahead, behind, bases))
     }
 
     pub(crate) fn refresh(
@@ -1400,6 +1449,34 @@ fn resolve_tips(repo: &gix::Repository, revisions: &[OsString]) -> Result<Option
     }
 }
 
+#[expect(
+    clippy::type_complexity,
+    reason = "both successful revisions and warning text are returned"
+)]
+pub(crate) fn available_hidden_revisions(
+    repo: &gix::Repository,
+    revisions: &[OsString],
+) -> Result<(Vec<OsString>, Vec<(OsString, String)>)> {
+    let mut available = Vec::new();
+    let mut unavailable = Vec::new();
+    let mut first_error = None;
+    for revision in revisions {
+        match resolve_revisions(repo, std::slice::from_ref(revision), "hidden ") {
+            Ok(_) => available.push(revision.clone()),
+            Err(err) => {
+                unavailable.push((revision.clone(), format!("{err:#}")));
+                first_error.get_or_insert(err);
+            }
+        }
+    }
+    if available.is_empty()
+        && let Some(err) = first_error
+    {
+        return Err(err);
+    }
+    Ok((available, unavailable))
+}
+
 fn attribution_kind(trailer: &gix::objs::commit::message::body::TrailerRef<'_>) -> Option<AttributionKind> {
     if trailer.is_co_authored_by() {
         Some(AttributionKind::CoAuthor)
@@ -1655,6 +1732,42 @@ mod tests {
         );
     }
 
+    #[test]
+    fn marks_visible_views_behind_hidden_branches_at_their_base() {
+        let mut graph = HistoryGraph::default();
+        for (n, parents, generation) in [
+            (1, vec![], 1),
+            (2, vec![1], 2),
+            (3, vec![1], 2),
+            (4, vec![3], 3),
+            (5, vec![], 1),
+        ] {
+            insert_commit(&mut graph, n, &parents, generation);
+        }
+
+        assert_eq!(
+            graph.hidden_branch_behind(&[id(2), id(5)], [id(4)]),
+            HashMap::from([(id(1), 2)]),
+            "only the fork point in the hidden branch's past reports its missing commits"
+        );
+    }
+
+    #[test]
+    fn ignores_missing_hidden_revisions_only_if_another_one_resolves() -> gix_testtools::Result {
+        let fixture = fixture()?;
+        let repo = crate::open_test_repository(&fixture)?;
+        let revisions = ["unknown".into(), "main".into()];
+
+        let (available, unavailable) = available_hidden_revisions(&repo, &revisions)?;
+        assert_eq!(available, [OsString::from("main")]);
+        assert_eq!(unavailable.len(), 1);
+        assert!(
+            available_hidden_revisions(&repo, &[OsString::from("unknown")]).is_err(),
+            "all missing hidden revisions retain the previous fatal behavior"
+        );
+        Ok(())
+    }
+
     #[test]
     fn walks_the_same_reachable_set_as_git_for_multiple_tips() -> gix_testtools::Result {
         let fixture = fixture()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 03c83f7da9f..4dbbb5cc407 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -799,7 +799,7 @@ fn shade_terminal_background((red, green, blue): (u8, u8, u8), dark: bool) -> (u
 }
 
 /// Run the interactive commit graph for `repository`.
-pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, options: Options) -> Result<()> {
+pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut options: Options) -> Result<()> {
     let _log_guard = match logging::init() {
         Ok(guard) => Some(guard),
         Err(err) => {
@@ -807,6 +807,17 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, opti
             None
         }
     };
+    let mut repository_path = repository.git_dir().to_owned();
+    let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
+    let (validation_repository, _) = open_history_repository(&mut repository_path, &common_dir)?;
+    let (hide, unavailable) = history::available_hidden_revisions(&validation_repository, &options.hide)?;
+    options.hide = hide;
+    for (revision, err) in unavailable {
+        eprintln!(
+            "warning: ignoring unavailable hidden revision {}: {err}",
+            revision.to_string_lossy()
+        );
+    }
     tracing::info!(
         revision_count = revisions.len(),
         hidden_revision_count = options.hide.len(),
@@ -1237,6 +1248,7 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    update_hidden_branch_behind(&mut app, history_graph.as_ref(), &ref_snapshot);
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "lane-computation-completed");
                     filesystem_responses.queue_frame(&response_ids, "lane-computation-completed");
@@ -1427,6 +1439,7 @@ fn event_loop(
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     history_graph = Some(graph);
+                    update_hidden_branch_behind(&mut app, history_graph.as_ref(), &ref_snapshot);
                     selection_relation = None;
                     app.selection_relation = None;
                 }
@@ -2135,6 +2148,19 @@ fn decoration_head(decorations: &Decorations) -> Option<gix::ObjectId> {
     })
 }
 
+fn update_hidden_branch_behind(app: &mut App, graph: Option<&HistoryGraph>, refs: &history::RefSnapshot) {
+    let markers = graph.map_or_else(HashMap::new, |graph| {
+        graph.hidden_branch_behind(
+            &refs.view_tips,
+            refs.hidden
+                .iter()
+                .filter(|(name, _)| name.starts_with(b"refs/heads/"))
+                .filter_map(|(_, target)| target.try_id().map(ToOwned::to_owned)),
+        )
+    });
+    app.set_hidden_branch_behind(markers);
+}
+
 fn restore_change_selection(view: &mut app::ChangesView, changes: &Changes, remembered: Option<(BString, usize)>) {
     let Some((path, viewport_row)) = remembered else {
         return;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index a1ae02852a3..2bc964c87a7 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -384,6 +384,27 @@ pub(crate) fn draw_with_worktree(
         let underline = head_has_descendants && !selected;
         let head_state = head.then_some(head_has_descendants);
         let metadata_width = metadata.width();
+        let hidden_branch_behind = app.hidden_branch_behind(visible_rows[index].id);
+        let line_width = if align_metadata {
+            align_width.saturating_add(metadata_width)
+        } else {
+            lane.chars()
+                .count()
+                .saturating_add(metadata_width)
+                .saturating_sub(horizontal_offset)
+        };
+        let hidden_branch_marker = hidden_branch_behind.and_then(|behind| {
+            let marker = format!("⇣{behind}");
+            let width = marker.chars().count() as u16;
+            (body.width > width.saturating_add(2)).then(|| {
+                let natural_x = content
+                    .x
+                    .saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
+                    .saturating_add(1);
+                let x = natural_x.min(body.right().saturating_sub(width).saturating_sub(1));
+                (marker, x, width)
+            })
+        });
         let signature_color = signature_color(visible_rows[index].signature);
         let highlight = if selected && app.show_selection_tail {
             Some(signature_color)
@@ -475,21 +496,16 @@ pub(crate) fn draw_with_worktree(
             }
         }
         if selected && app.show_selection_tail && body.width > 0 {
-            let line_width = if align_metadata {
-                align_width.saturating_add(metadata_width)
-            } else {
-                lane.chars()
-                    .count()
-                    .saturating_add(metadata_width)
-                    .saturating_sub(horizontal_offset)
-            };
+            let marker_limit = hidden_branch_marker
+                .as_ref()
+                .map_or_else(|| body.right().saturating_sub(1), |(_, x, _)| x.saturating_sub(2));
             let marker_x = content
                 .x
                 .saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
                 .saturating_add(1)
                 .saturating_add(u16::try_from(selection_info_width).unwrap_or(u16::MAX))
                 .saturating_add(1)
-                .min(body.right().saturating_sub(1));
+                .min(marker_limit);
             if selection_info_width > 0 {
                 let width = u16::try_from(selection_info_width)
                     .unwrap_or(u16::MAX)
@@ -528,6 +544,19 @@ pub(crate) fn draw_with_worktree(
                     .set_style(Style::default().add_modifier(Modifier::DIM));
             }
         }
+        if let Some((marker, x, width)) = hidden_branch_marker {
+            frame.buffer_mut()[(x - 1, y)].set_symbol(" ");
+            frame.render_widget(
+                Paragraph::new(marker).style(color(Color::LightRed)),
+                Rect::new(x, y, width, 1),
+            );
+            frame.buffer_mut()[(x + width, y)].set_symbol(" ");
+            for marker_x in x..x + width {
+                let cell = &mut frame.buffer_mut()[(marker_x, y)];
+                cell.set_fg(Color::LightRed);
+                cell.modifier.remove(Modifier::DIM | Modifier::REVERSED);
+            }
+        }
     }
     app.set_horizontal_bounds(content.width as usize, max_offset);
     if app.changes_focus.is_some() {
@@ -2646,7 +2675,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let footer = rendered_line(&terminal, 1);
-        let view = "view (date · emails · names · mailmap · trailers · no refs · show hidden)";
+        let view = "view (date · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
             footer.starts_with(&format!("0 commits · {view} · [ align")),
             "the active view prefix follows the history position"
@@ -4315,6 +4344,7 @@ mod tests {
         app.extend_commits(vec![commit(1)]);
         app.extend_hidden_commits(vec![commit(2)]);
         complete(&mut app);
+        app.set_hidden_branch_behind(std::collections::HashMap::from([(gix::ObjectId::Sha1([2; 20]), 2)]));
         app.set_lane(0, "● ");
         app.set_lane(1, "● ");
         let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
@@ -4331,8 +4361,22 @@ mod tests {
             terminal.backend().buffer()[(hash, 1)].modifier.contains(Modifier::BOLD),
             "non-color styling is retained"
         );
+        let marker_byte = line.find("⇣2").expect("the behind count is visible");
+        let marker = line[..marker_byte].chars().count() as u16;
+        assert_eq!(&line[marker_byte - 1..marker_byte], " ", "the marker has a left margin");
+        assert_eq!(
+            terminal.backend().buffer()[(marker + 2, 1)].symbol(),
+            " ",
+            "the marker has a right margin"
+        );
+        assert!(line.contains("subject 2 ⇣2 "), "the marker naturally follows the title");
         for x in 0..terminal.backend().buffer().area.width {
             let cell = &terminal.backend().buffer()[(x, 1)];
+            if (marker..marker + 2).contains(&x) {
+                assert_eq!(cell.fg, Color::LightRed, "behind information uses its usual color");
+                assert!(!cell.modifier.contains(Modifier::DIM));
+                continue;
+            }
             assert_eq!(cell.fg, Color::Reset, "the hidden row has no foreground colors");
             assert_eq!(cell.bg, Color::Reset, "the hidden row has no background colors");
             assert!(cell.modifier.contains(Modifier::DIM), "the hidden row is dimmed");
@@ -4342,6 +4386,13 @@ mod tests {
             ">",
             "the hidden row is not selected"
         );
+
+        let mut narrow = Terminal::new(TestBackend::new(28, 3))?;
+        narrow.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&narrow, 1).ends_with(" ⇣2 "),
+            "the terminal edge pushes the marker over clipped title text"
+        );
         Ok(())
     }
 

From 05a0c7af5381a55a40db52f8dd5671f049cdc813 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:25:07 +0200
Subject: [PATCH 067/282] feat: split staged and unstaged HEAD changes

Offer e p only at the current worktree HEAD when staged and unstaged changes coexist. Amend the unstaged delta into the source commit, then cherry-pick the staged delta into a newly edited upper commit.

Prepare both tree applications in memory before opening the editor, and reuse the rebase transaction for signature handling, mutable-ref updates, and index reset without touching worktree files.
---
 gix-tix/spec.md                               |  18 +-
 gix-tix/src/app.rs                            |  28 ++-
 gix-tix/src/edit/create.rs                    |  44 ++--
 gix-tix/src/edit/mod.rs                       |   1 +
 gix-tix/src/edit/rebase.rs                    |  43 +++-
 gix-tix/src/edit/split.rs                     | 238 ++++++++++++++++++
 gix-tix/src/lib.rs                            |  54 ++++
 gix-tix/src/ui.rs                             |   9 +
 .../generated-archives/split_commit.tar       | Bin 0 -> 69120 bytes
 gix-tix/tests/fixtures/split_commit.sh        |  20 ++
 10 files changed, 425 insertions(+), 30 deletions(-)
 create mode 100644 gix-tix/src/edit/split.rs
 create mode 100644 gix-tix/tests/fixtures/generated-archives/split_commit.tar
 create mode 100644 gix-tix/tests/fixtures/split_commit.sh

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3f14ebea243..61d9995949b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -339,7 +339,7 @@ space first; changes blocks adapt within the remaining history width.
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
   inaccessible or conflicting affected worktrees abort safely.
 
-### Amend and spill
+### Amend, spill, and split
 
 - `e a` amends the current worktree's `@` commit with the changed index, or
   worktree changes when the index already matches `HEAD`. `e s` spills that
@@ -349,7 +349,16 @@ space first; changes blocks adapt within the remaining history width.
 - With a path selected in the focused tree-changes block, the main `e` prefix
   offers `spill` and `e s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
-- Both operations leave worktree files untouched, reset the affected worktree's
+- `e p` is offered at `@` only when both staged and unstaged changes exist. It
+  amends the unstaged changes into the source commit, then creates a new upper
+  commit from the staged delta using the standard Markdown editor buffer. Both
+  deltas are three-way applied in memory before the editor opens, so overlapping
+  changes abort without writing objects or changing refs, the index, or files.
+- A successful split leaves the worktree bytes untouched and resets the index to
+  the new upper commit. The rewritten source retains its message and ancestry;
+  the upper commit receives the edited message. Both commits are marked for the
+  same lazy signature-aware rebase used by amend and spill.
+- All three operations leave worktree files untouched, reset the affected worktree's
   index to the rewritten commit, and cheaply rewrite linear descendants with
   their trees unchanged. Rewritten commits carry `tix-rebase: pending`, invalidate
   existing signatures, retain the original parent needed for later replay, and
@@ -402,8 +411,9 @@ space first; changes blocks adapt within the remaining history width.
 ### Editing shortcuts
 
 - `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
-  `e a` amends `@`, `e s` spills `@`, `e d d` confirms forgetting a top commit,
-  and `e t` enters or returns from time travel when each action is available.
+  `e a` amends `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
+  `e d d` confirms forgetting a top commit, and `e t` enters or returns from
+  time travel when each action is available.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
   mutate the repository.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index bd74b4368e1..3138ee6f0bb 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -288,6 +288,7 @@ pub(crate) enum Action {
     NewCommit,
     Amend,
     Spill,
+    Split,
     Forget,
     TimeTravel,
     VerifySignatures,
@@ -313,6 +314,7 @@ pub(crate) enum Effect {
     NewCommit(Option<ObjectId>),
     Amend(ObjectId),
     Spill(ObjectId),
+    Split(ObjectId),
     Forget(ObjectId),
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
@@ -386,6 +388,7 @@ pub(crate) struct App {
     worktree_head_unborn: bool,
     amend_available: bool,
     spill_available: bool,
+    split_available: bool,
     known_descendants: HashSet<ObjectId>,
     known_merge_descendants: HashSet<ObjectId>,
     select_top_after_refresh: bool,
@@ -464,6 +467,7 @@ impl App {
             worktree_head_unborn: false,
             amend_available: false,
             spill_available: false,
+            split_available: false,
             known_descendants: HashSet::new(),
             known_merge_descendants: HashSet::new(),
             select_top_after_refresh: false,
@@ -693,6 +697,7 @@ impl App {
                 | Action::NewCommit
                 | Action::Amend
                 | Action::Spill
+                | Action::Split
                 | Action::Forget
                 | Action::TimeTravel
         ) {
@@ -872,6 +877,11 @@ impl App {
                     self.rows[self.selected.expect("spill requires a selection")].id,
                 )];
             }
+            Action::Split if self.can_split() => {
+                return vec![Effect::Split(
+                    self.rows[self.selected.expect("split requires a selection")].id,
+                )];
+            }
             Action::Forget if self.can_forget() => {
                 let id = self.rows[self.selected.expect("forget requires a selection")].id;
                 if self.forget_confirmation == Some(id) {
@@ -1402,9 +1412,14 @@ impl App {
         self.can_edit_head() && matches!(self.changes_focus, None | Some(ChangePane::Tree)) && self.spill_available
     }
 
-    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, spill: bool) {
+    pub(crate) fn can_split(&self) -> bool {
+        self.can_edit_head() && self.changes_focus.is_none() && self.split_available
+    }
+
+    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, spill: bool, split: bool) {
         self.amend_available = amend;
         self.spill_available = spill;
+        self.split_available = split;
     }
 
     pub(crate) fn forget_confirmation_visible(&self) -> bool {
@@ -2087,16 +2102,23 @@ mod tests {
     }
 
     #[test]
-    fn amend_and_spill_are_limited_to_the_current_worktree_head() {
+    fn head_edits_are_limited_to_the_current_worktree_head_and_available_changes() {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_head_edit_availability(true, true);
+        app.set_head_edit_availability(true, true, false);
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
         assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
+        assert!(
+            app.update(Action::Split).is_empty(),
+            "split needs both kinds of changes"
+        );
+        app.set_head_edit_availability(true, true, true);
+        assert_eq!(app.update(Action::Split), vec![Effect::Split(id(2))]);
         app.changes_focus = Some(ChangePane::Tree);
         assert!(!app.can_amend(), "a tree path cannot be amended");
+        assert!(!app.can_split(), "a tree path cannot be split");
         assert_eq!(
             app.update(Action::Spill),
             vec![Effect::Spill(id(2))],
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 5c3753ec678..dacde6d9f38 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -13,9 +13,9 @@ use super::{rebase, reword};
 pub(crate) struct Prepared {
     pub editor: OsString,
     pub document: Vec<u8>,
-    parent: Option<ObjectId>,
-    tree: ObjectId,
-    objects: gix::odb::memory::Storage,
+    pub(super) parent: Option<ObjectId>,
+    pub(super) tree: ObjectId,
+    pub(super) objects: gix::odb::memory::Storage,
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
@@ -140,6 +140,14 @@ pub(super) fn index_tree(repo: &gix::Repository, index: &gix::index::File) -> Re
 
 pub(super) fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<ObjectId> {
     let changes = load_worktree_changes_without_lines(repo)?;
+    worktree_tree_with_changes(repo, baseline, &changes)
+}
+
+pub(super) fn worktree_tree_with_changes(
+    repo: &gix::Repository,
+    baseline: &gix::Tree<'_>,
+    changes: &crate::Changes,
+) -> Result<ObjectId> {
     if changes.paths.is_empty() {
         return Ok(baseline.id);
     }
@@ -189,20 +197,8 @@ pub(crate) fn apply(
     mut prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
-    let edit = reword::parse(edited)?;
-    if edit.message.is_empty() {
-        anyhow::bail!("the edited commit message is empty");
-    }
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let commit = gix::objs::Commit {
-        message: edit.message,
-        tree: prepared.tree,
-        author: reword::actor(edit.author, edit.author_time, "author")?,
-        committer: reword::actor(edit.committer, edit.committer_time, "committer")?,
-        encoding: None,
-        parents: prepared.parent.into_iter().collect(),
-        extra_headers: Vec::new(),
-    };
+    let commit = commit_from_edit(&prepared, edited)?;
     let base_tree = match prepared.parent {
         Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
         None => repo.empty_tree().id,
@@ -226,6 +222,22 @@ pub(crate) fn apply(
     .context("inserting a commit did not produce a selection")
 }
 
+pub(super) fn commit_from_edit(prepared: &Prepared, edited: &[u8]) -> Result<gix::objs::Commit> {
+    let edit = reword::parse(edited)?;
+    if edit.message.is_empty() {
+        anyhow::bail!("the edited commit message is empty");
+    }
+    Ok(gix::objs::Commit {
+        message: edit.message,
+        tree: prepared.tree,
+        author: reword::actor(edit.author, edit.author_time, "author")?,
+        committer: reword::actor(edit.committer, edit.committer_time, "committer")?,
+        encoding: None,
+        parents: prepared.parent.into_iter().collect(),
+        extra_headers: Vec::new(),
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command};
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index d6d23f01c36..4127d2d603b 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -48,6 +48,7 @@ pub(crate) mod forget;
 pub(crate) mod head;
 pub(crate) mod rebase;
 pub(crate) mod reword;
+pub(crate) mod split;
 pub(crate) mod time_travel;
 
 #[tracing::instrument(skip_all, fields(filename))]
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 3cc1ed485fc..bb65651f350 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -46,6 +46,11 @@ pub(crate) enum Edit {
     Remove {
         target: ObjectId,
     },
+    Split {
+        target: ObjectId,
+        source: gix::objs::Commit,
+        upper: gix::objs::Commit,
+    },
     Repeat {
         base: ObjectId,
     },
@@ -70,11 +75,12 @@ pub(crate) fn perform(
     signature: Signature,
     mut tree_mode: Tree,
 ) -> Result<Outcome> {
-    let (root, replacement, inserted, removed, repeat) = match edit {
-        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false),
-        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false),
-        Edit::Remove { target } => (Some(target), None, false, true, false),
-        Edit::Repeat { base } => (Some(base), None, false, false, true),
+    let (root, replacement, inserted, removed, repeat, mut split_upper) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, None),
+        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false, None),
+        Edit::Remove { target } => (Some(target), None, false, true, false, None),
+        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, Some(upper)),
+        Edit::Repeat { base } => (Some(base), None, false, false, true, None),
     };
     if repeat {
         tree_mode = Tree::CherryPick;
@@ -177,7 +183,15 @@ pub(crate) fn perform(
         let new_id = write_commit(&repo, commit, signature, signing.clone())?;
         rewritten.insert(old_id, Some(new_id));
         if Some(old_id) == root {
-            selected = Some(new_id);
+            if let Some(mut upper) = split_upper.take() {
+                upper.parents = [new_id].into_iter().collect();
+                marker(&mut upper, true, Some(new_id));
+                let upper_id = write_commit(&repo, upper, Signature::RedoIfNeeded, signing.clone())?;
+                rewritten.insert(old_id, Some(upper_id));
+                selected = Some(upper_id);
+            } else {
+                selected = Some(new_id);
+            }
         }
     }
 
@@ -367,13 +381,28 @@ fn rewritten_tree(
     if old_base == new_base {
         return Ok(commit.tree);
     }
+    cherry_pick_tree(repo, old_base, new_base, commit.tree)
+}
+
+pub(super) fn cherry_pick_tree(
+    repo: &gix::Repository,
+    old_base: ObjectId,
+    new_base: ObjectId,
+    tree: ObjectId,
+) -> Result<ObjectId> {
+    if tree == old_base {
+        return Ok(new_base);
+    }
+    if old_base == new_base {
+        return Ok(tree);
+    }
     let labels = gix::merge::blob::builtin_driver::text::Labels {
         ancestor: Some(BStr::new(b"parent")),
         current: Some(BStr::new(b"rebased parent")),
         other: Some(BStr::new(b"commit")),
     };
     let mut outcome = repo
-        .merge_trees(old_base, new_base, commit.tree, labels, repo.tree_merge_options()?)
+        .merge_trees(old_base, new_base, tree, labels, repo.tree_merge_options()?)
         .context("could not cherry-pick a descendant tree")?;
     if outcome.has_unresolved_conflicts(gix::merge::tree::TreatAsUnresolved::git()) {
         anyhow::bail!("rebasing would cause a merge conflict");
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
new file mode 100644
index 00000000000..d0d5340e670
--- /dev/null
+++ b/gix-tix/src/edit/split.rs
@@ -0,0 +1,238 @@
+use anyhow::{Context, Result};
+use gix::ObjectId;
+
+use super::{create, rebase};
+use crate::{ChangeGroup, ChangeKind, load_worktree_changes_without_lines};
+
+pub(crate) struct Prepared {
+    pub editor: std::ffi::OsString,
+    pub document: Vec<u8>,
+    create: create::Prepared,
+    target: ObjectId,
+    source: gix::objs::Commit,
+    tree: ObjectId,
+}
+
+#[tracing::instrument(skip_all)]
+pub(crate) fn prepare(mut repo: gix::Repository) -> Result<Prepared> {
+    let target = repo
+        .head_id()
+        .context("splitting requires an existing HEAD commit")?
+        .detach();
+    let changes = load_worktree_changes_without_lines(&repo)?;
+    if changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged) {
+        anyhow::bail!("cannot split with unresolved conflicts");
+    }
+    if !changes.paths.iter().any(|change| change.group == ChangeGroup::Staged)
+        || !changes.paths.iter().any(|change| change.group == ChangeGroup::Unstaged)
+    {
+        anyhow::bail!("splitting requires both staged and worktree changes");
+    }
+
+    let mut source = repo
+        .find_commit(target)
+        .context("could not find HEAD commit")?
+        .decode()
+        .context("could not decode HEAD commit")?
+        .into_owned()
+        .context("could not own HEAD commit")?;
+    let mut create = create::prepare(repo.clone(), Some(target))?;
+    repo.objects.set_object_memory(std::mem::take(&mut create.objects));
+
+    let head_tree = source.tree;
+    let index_tree = create.tree;
+    let index = repo
+        .find_tree(index_tree)
+        .context("could not load the prepared index tree")?;
+    let worktree_tree = create::worktree_tree_with_changes(&repo, &index, &changes)?;
+    drop(index);
+    let source_tree = rebase::cherry_pick_tree(&repo, index_tree, head_tree, worktree_tree)
+        .context("worktree changes conflict with the source commit")?;
+    let tree = rebase::cherry_pick_tree(&repo, head_tree, source_tree, index_tree)
+        .context("staged changes conflict with the rewritten source commit")?;
+    source.tree = source_tree;
+    create.objects = repo
+        .objects
+        .take_object_memory()
+        .context("candidate object memory was unavailable")?;
+
+    Ok(Prepared {
+        editor: create.editor.clone(),
+        document: create.document.clone(),
+        create,
+        target,
+        source,
+        tree,
+    })
+}
+
+#[tracing::instrument(skip_all, fields(target = %prepared.target))]
+pub(crate) fn apply(
+    mut repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    mut prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    repo.objects
+        .set_object_memory(std::mem::take(&mut prepared.create.objects));
+    let mut upper = create::commit_from_edit(&prepared.create, edited)?;
+    upper.tree = prepared.tree;
+    rebase::perform(
+        repo,
+        graph,
+        rebase::Edit::Split {
+            target: prepared.target,
+            source: prepared.source,
+            upper,
+        },
+        rebase::Signature::InvalidateExisting,
+        rebase::Tree::LeaveAsIsAndMark,
+    )?
+    .selected
+    .context("splitting HEAD did not produce a selection")
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use gix::bstr::ByteSlice;
+
+    use super::*;
+
+    fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "user.name=editor".to_owned(),
+                "user.email=editor@example.com".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?)
+    }
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!("git {} failed: {}", args.join(" "), output.stderr.to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn splits_staged_and_worktree_changes_without_touching_files_during_preparation() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("split_commit.sh")?;
+        let repository = open(fixture.path())?;
+        let old = repository.head_id()?.detach();
+        let old_parent = repository.find_commit(old)?.parent_ids().next().map(gix::Id::detach);
+        for name in ["refs/patches/split", "refs/tags/keep", "refs/remotes/origin/keep"] {
+            git(fixture.path(), &["update-ref", name, &old.to_string()])?;
+        }
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?)?;
+        assert!(
+            prepared
+                .document
+                .windows(b"staged".len())
+                .any(|window| window == b"staged"),
+            "the upper commit editor describes staged paths"
+        );
+        assert!(
+            !prepared
+                .document
+                .windows(b"unstaged |".len())
+                .any(|window| window == b"unstaged |"),
+            "the upper commit editor excludes worktree-only paths"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "preparing both cherry-picks leaves the repository unchanged"
+        );
+
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"upper\n\nreason", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let upper = apply(open(fixture.path())?, &graph, prepared, &edited)?;
+        let repository = open(fixture.path())?;
+        let source = repository
+            .find_commit(upper)?
+            .parent_ids()
+            .next()
+            .expect("the upper commit has the rewritten source")
+            .detach();
+        assert_eq!(
+            repository.find_commit(source)?.parent_ids().next().map(gix::Id::detach),
+            old_parent,
+            "the source commit retains its original ancestry"
+        );
+        assert_eq!(
+            git(fixture.path(), &["show", &format!("{source}:both")])?,
+            b"one\nbase staged\nmiddle\nworktree\nend\n"
+        );
+        assert_eq!(
+            git(fixture.path(), &["show", &format!("{upper}:both")])?,
+            b"one\nstaged\nmiddle\nworktree\nend\n"
+        );
+        assert_eq!(
+            git(fixture.path(), &["show", &format!("{source}:unstaged")])?,
+            b"worktree\n"
+        );
+        assert_eq!(
+            git(fixture.path(), &["show", &format!("{source}:untracked")])?,
+            b"untracked\n"
+        );
+        assert_eq!(git(fixture.path(), &["show", &format!("{upper}:staged")])?, b"staged\n");
+        assert_eq!(repository.find_commit(source)?.message_raw()?, b"base\n".as_bstr());
+        assert_eq!(
+            repository.find_commit(upper)?.message_raw()?,
+            b"upper\n\nreason\n".as_bstr()
+        );
+        assert!(super::super::rebase::has_marker(
+            &repository.find_commit(source)?.decode()?.into_owned()?
+        ));
+        assert!(super::super::rebase::has_marker(
+            &repository.find_commit(upper)?.decode()?.into_owned()?
+        ));
+        assert_eq!(git(fixture.path(), &["status", "--short"])?, b"");
+        for name in ["refs/heads/main", "refs/patches/split"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                upper,
+                "{name} follows the split"
+            );
+        }
+        for name in ["refs/tags/keep", "refs/remotes/origin/keep"] {
+            assert_eq!(
+                repository.find_reference(name)?.id().detach(),
+                old,
+                "{name} is not edited"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn conflicting_staged_and_worktree_hunks_abort_before_the_editor() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("split_commit.sh")?;
+        std::fs::write(
+            fixture.path().join("both"),
+            b"one\nworktree conflict\nmiddle\nbase worktree\nend\n",
+        )?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let err = match prepare(open(fixture.path())?) {
+            Ok(_) => return Err("overlapping staged and worktree hunks should conflict".into()),
+            Err(err) => err,
+        };
+        assert!(
+            format!("{err:#}").contains("worktree changes conflict with the source commit"),
+            "the error identifies the conflicting half of the split: {err:#}"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "a conflicting split writes no observable state"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 4dbbb5cc407..38ee6f8fba5 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1780,6 +1780,30 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("new commit: {err:#}")),
                     }
                 }
+                Effect::Split(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = history_graph
+                        .as_ref()
+                        .context("splitting HEAD requires a completed history graph")
+                        .and_then(|graph| {
+                            split_commit(terminal, &repository_path, repository_is_bare, graph, enhanced_keyboard)
+                        });
+                    match result {
+                        Ok(Some(new_id)) => {
+                            app.leave_message(format!(
+                                "split {} as {}",
+                                id.to_hex_with_len(7),
+                                new_id.to_hex_with_len(7)
+                            ));
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_select_top_requested = true;
+                            refresh_pending = true;
+                        }
+                        Ok(None) => app.leave_message("no split performed: no input was provided"),
+                        Err(err) => app.leave_message(format!("split: {err:#}")),
+                    }
+                }
                 edit @ (Effect::Amend(id) | Effect::Spill(id)) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2903,6 +2927,34 @@ fn create_commit(
     edit::create::apply(repository, graph, prepared, &edited).map(Some)
 }
 
+#[tracing::instrument(skip_all)]
+fn split_commit(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    graph: &HistoryGraph,
+    enhanced_keyboard: bool,
+) -> Result<Option<gix::ObjectId>> {
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not open repository before splitting HEAD")?;
+    repository.object_cache_size(None);
+    let prepared = edit::split::prepare(repository)?;
+    let Some(edited) = edit::edit_document(
+        terminal,
+        &prepared.editor,
+        &prepared.document,
+        &format!("tix-split-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?
+    else {
+        return Ok(None);
+    };
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing split")?;
+    repository.object_cache_size(None);
+    edit::split::apply(repository, graph, prepared, &edited).map(Some)
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn forget_commit(
     repository_path: &Path,
@@ -3600,6 +3652,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Enter => Some(Action::OpenDiff),
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
         KeyCode::Char('c') => Some(Action::ToggleChanges),
+        KeyCode::Char('p') if edit_expanded => Some(Action::Split),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -4516,6 +4569,7 @@ mod tests {
             ('n', Action::NewCommit),
             ('a', Action::Amend),
             ('s', Action::Spill),
+            ('p', Action::Split),
             ('d', Action::Forget),
             ('t', Action::TimeTravel),
         ] {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 2bc964c87a7..8cea6f0ba02 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -251,6 +251,12 @@ pub(crate) fn draw_with_worktree(
     app.set_head_edit_availability(
         selected_is_head && worktree_changes.is_some_and(|changes| !changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
+        selected_is_head
+            && worktree_changes.is_some_and(|changes| {
+                changes.paths.iter().any(|change| change.group == ChangeGroup::Staged)
+                    && changes.paths.iter().any(|change| change.group == ChangeGroup::Unstaged)
+                    && !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
+            }),
     );
     if app.changes_visible() {
         app.set_changes_layout(
@@ -729,6 +735,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_spill() {
                 options.push(("spill", 's'));
             }
+            if app.can_split() {
+                options.push(("split", 'p'));
+            }
             if app.changes_focus.is_none() && app.can_forget() {
                 options.push(if app.forget_confirmation_visible() {
                     ("d again forget", 'd')
diff --git a/gix-tix/tests/fixtures/generated-archives/split_commit.tar b/gix-tix/tests/fixtures/generated-archives/split_commit.tar
new file mode 100644
index 0000000000000000000000000000000000000000..783420d2a906fae9d0cf4f38a879747932af0641
GIT binary patch
literal 69120
zcmeHw4QyQ5bspDt({K_rDVoBufwpf)v`I>wUk+zPYN@rB(pp?=MOC7#O(iY&&CDBe
zR>OItc{8GDtqd4V+tmF*5F|EW!$ninZCY%Twg`#>1&SK|LF_g#YPW@(rfuA0<0cK-
z!bVf0ZP0$-IrqMK^M>S*6i43e4zXHt=G}Mhx#ym9?m6e4du}>2G4h`*eo6}q6a0;z
z_;2|xmn{@?*?cxXFV9Q!`Gtvvkz<Aqx<SWnJI)h#B}0o0?uh|D9RTUgdS}!<ku*o0
z|I$K!JpZGf7{KTJXI9o;etC6$<I=^|^_Opa^u&AR{1*#_xZK;%c)BprFaNoGE;m1s
zJ#kF-0QfGK|FRo+i9N_N{_5R90g?ZDv+6w@-FSz|e<53p%YQCg9LxXcW~2xC;_CGk
ze0mT5z4!IUzkd4%zWq<XWq&_2G4aDc`oYA{PfUF3uTD%n^FPq$NAPdz5C8P9{++*f
z`&a(q`lYo$^ZqaYqd&O(Q(yYUiT9QL&K92HN8bO=-}tEgZQ%Su49@TWz`y+$f9l8I
zoO}G$TVLCHZ}&g{(Bv2X$)_g15BAumSG8~wKmLtBO*s5*;QZ|voZt5!KlA7_U)=qT
zKk=h~|3mN3|I4lS{oS`-zd7;!-KK@Ke*MxV!27<5RL;pJzHs@i5B}OWfATkf=u0!{
zKlX)ZzWrCue&FA+w|D1{$bZ|b1tT0j<^O2*UoKn9<;M2k2<OCt4(C4uu^SN+9Ao}-
z#X@O3|8|l__`5g%Tb^4T4Feo!{!68?|3AWM4?)M~KeO%Do8iL~`h)X-p#Qg!i`#$s
zQm!=i|4xYh2Z71X7fPPz)z0R<#cHwOp3RosV!oIwSKWN6P;>K@N-5_p=EgqaK~#L_
zJ`?%h^8I_GQT;-g<LG}FjN|qHDX>*<{xhv^u$AigsmhjDx#xE~>A>A?HM}QBV#xe2
z%+HtN`hQ`egm~eTcRd`!yFC7P>e)=W-pmABiNq=ALeudc%A`9~2~JRH*ION@<2&6}
z)$MqW>j-mr)fD){>9jr1@tgP-L1c&QlTMrhnDwoCpaAf@-hANS^QumHm#tE5uj17o
zc&V0Kxi^!Wb#}JArh~WJo?Gbz><X;_gU}qeSv5TeXi)RoUbEuO1hW8&clce)59%Gi
zy*npu1z2axleYn+)2@30)1c2s<+j_bY&o4Rx8nf4O1BNDoyM*mnZuE>V>AW`gKxU(
zHFsCE?F$N_;x}vc&2HQ6)Ioy>ZoBT58y;Z>9%+V`wcAw$B4Ar9ZC==Qs$R|QHac@o
z&;=r{4i&Fqgxvs?s@K@Jv*Wk#)tj42WrGj~jz}FK``V`MZTpy(9vz%5HvsnNq+T=h
za%ydVTOfvG1pqUTGTMs2y<P8|)45<6XGs6fw%e&}0SM7FKph1#$M1F>x9yq1gO0wo
zm)1>h2c+iYVxXORt2Y##mvle#;N3DHkt+Dpf8e#-^{OY33>5*O>}|OZ>VCI<4otV>
zp^+lyqh;A^_&cCaotkVL6Ag9%(&pvfs{lj7Iou5Fkm@bJ-t0Ivzm0)4A9&3=-gUNp
zkhNZs8MmzNDW@AgQSeF&XQvKQ?rhbC-GFtyW#`QhjmRrAVfr`GBW7DiEaFyON+_h|
zsT{>~wc}J=iYVkoV7pG!Z>B!swS6Mq=?bqa8_6(5h-R#aRedi2l)#^(z->eE;dL{p
zU1=}e<zUQl{+mrFs&&tqnROl|CcVm*@0|Z|-bqfKPU0ic$t4~W!?iX+6UlA&9@GUG
zu?c|>0=G>8bDNtgk8$`aa6bD56h(uSXbVZUJn*kP#KZ;lHn@Sqg@{mj5Y`aVsvHUr
zu{D@5WLFASl%Nq}>I}aKau}s3%&pVSAqHfsU8mh`ivEKJtENOHrn*jQ+qrz{!bOlM
zmy{8Ks#P+k?|9qY29c-Eta%V5j6ih}Awjbd#WvYE0Hb2G6)G42ktw&D779;!t+V56
zui({f@)ujgajA3SF%4kiy4wKK>;ua?rU;CO7XknWCKxL}Sqnfh(`Ujv%B`3~a5Z$@
zJ<n^I8FCta#chOhY=+UN!(^CM>P500#LH__Md`SRP(){yz0QtjCf9bFCWoz~oeDKX
z#)U+-y_DZhH840%Q-!ON+YCTqYGsfcnx@gPa<_tcuad<m*wUry;+`UqC!oP}AX+MF
z59!Q9b<~^G(wq{4ppb2J{Ee#DYWTYlky^JYQ^vV0ck2!4lT38kOIMV$u2OXiQ3ysB
z+?_gbg~sz9dX;Vmy@a|uqT-b&xab*DhK-`+#`5BGDcSYA&W;P^1zNN~ap4mDAp{Dr
ze4AnPzbkJM8K_nu={s)Kg(ZNmsSu%9-AV-<jmd9d?e)@|7!sFwx61FFWTon)(@FAE
zH{cg-k23;LEw{53U?zdtv%+gCn<<s~)O{zFs&6(qt3kI6ecQ#%;yWm{wg)2xlxij>
zsf&^~Tbvv*ON3vYnhTz+CKI)K1Uz{vRl@^9x!<j0Y2LesDCk>e=?y6@%c|W_uuQH!
z8FNRtvF&#^A<hv7^lM9E5;+dTYa3XdH((smVgaK(?<A=tlFpKI>E&zdKeoY*ij5nW
zFXT2ZUwVZk5@B>ZG5{y#sZPnC&s4n!nP#`qFh~>jGC?K02DWo2<@3}G-$svHDZl(W
zw1|^3CR-{MbTCcMb0M7BJ&0yzBqUnJ1(~aRQg4bK;>mCt>XuAD1w&SdYpvvzE`P}=
z+!epusEP(LMqQL~$*I)tLROAxxc&bwZxQkTl%6N%_4Nol#Q!TH?<?;A%}czn2V!)8
zjr~94|Iu^X-vKOReZS{)n{E?}H_R6pQ`j%k^$AvmM@x-szzWO@Jj7Cvr22`jdr4!o
zwl}+Ci7(-4tw|#!*m83zA7U+kK!DYagss#RpQ>XW$~n9uZ^$=P>y-GUa&A(W)fMr}
zfJ#b!@P~xA(m>4Li3|V_9Q8KJzTfa@(0OnVU{hj|!MYV6s$H7}4u%K=#u}^+(6XLr
z+Hrb59u0(Dcyi6@4wiM&CxT1WYj_<GWE_HtwBsTw6dy!`od}5IAR#Wz?r<br_71Cl
zm*$E3L7;(K!^}GsC~lft>Bz_hAuzy!V^_=Wu*0`@AlOK)q~1&%mjv|c1$*yMsHnTm
zSb>ZfQ!;=PAlALAj^3K``>_UW2AU1zOHaZBcnv)3tiT_qU($e~nJ_Z4ES>~p1fBu@
z&L<NP6a9NWNyC^g-f-bim`DcAhuco-6L3L3irhZrc_f{?=SV0RP~yTRFA87M>kx4=
z(Vozn<l<}5fGr1)&%Wr)0Jt?Q=j5-7EXzT+MVH8QD4o$i>VMgp$~w<sSm&MRbUgS&
z2XlVbwp5?eSaN0<h7w69<?Fcg?cQevGBC_;fP|8z19~0o)XoDVJc+pCSXRqQ<3FH#
zXSd}oQ-?%_JEA^j6@rSpGR&bsL|>Rq#94J1h<N)xEFjCn-j`8_D$2YaYKud?9k!k&
zgBl|pE<w|$A1|>*dbX{$PxF*t0W4!Zuym($_osWT3qv(*pPWrpkhF-0kr$Kn$C5Xj
zTpX$qZJa#qyx}DAiedTFr%yZAw7)10jw~gxl~qy0@x)rt&lZ#C&LzCStyo!GVU*nA
z+|##)JWMJ3QKV_`q|<5sVyp$eBm$=rWaDzBM8#KN=yZYs2Sd$1TYbPr$3Qx5XZm(F
zwdkg5cc-1{?DVWkdD8Tqbe2IDLW~H3qO~Dhs$Cl|A^O0ubm(ey>~PdGFa);}IA=Q)
zs6zWmJPRa;By)OB#|olPA_m$__1O&gGT8FloecwQdFqk*>(r?pjK^pu3M@Gl7r&(Q
zEJoRBcfH6UCnNK_4sSZ%>zp&y*DIza5GTTDU;65z1bb_!nf@r`n_#<Xnl)Stp_N?B
zNh)wK7ZOjPL1eWeCmQ_OayMZtS?vi}s@Ntcq1q<NQhjvO=~22FF5$}DPYQj2?}rlN
zA`J{04!U?BVZ;YwiLMpJ_`F6ZER_8|ES(R3SbSP6T-X6%fNRQ3zH{CQy-_EB{=+$p
zTGy)R1gwMZ)Ap5VES+>2cNxG7IzfcWj8G;i>n}56yL$v0M1br~1iHFGjK_`f5YCfb
zn0nF(R!L69RkDcd0gSw2tqeC3CT8sHFid+e_Iq$zd=QZZKp*wZq_rfXvlHPred8!X
zwl}_NamDG42unrwMnarJN$S0@#}EhKi?Xb~aP+appgz%{Ppf2IXzoHAL2?<-fwd)}
zUW7^!Q15;JJlm=zM^?Y7TXb|VmZ1OcHT@mvG^|eyewtVbloI5vCv@CKVhgi=7<Dd|
zUQboU7QPqj%{sSl5~9np;}FZ}ViQjRawPuKLeQ1L>=Taw(GEHw|2MxdKal@l$jy)Q
z|DVG2PaJapAG=XlM-d#+ohr91`~R|6shhb7d-R8XU=;I7(!>Zf6s=AGEOadG&_uF%
ztvi=<*eYR+1cp>Z&A}qZckoyh7`$Z1S>@I@G@@}=sf7@=;a2P5b|@B0QKL3uU~nDG
zQo!C7!&U-@xYc}m<<!71Q{Yn|%n@iLe<}x;&$-I5RsSYDbZc*~mmP5-D0_ra_2I~$
za;EZp_2%^}G!74Li`Ez?q40g8MS|;I3WjOC9HAc`VU2KYR4t5-c=x+*LqlS#O>X<>
zmYA73j8Uz0*~?=d0_d*TDv^l2xbp~SaF>w52<|TfGZF~1)~vd1hQV6E%<T8E8@u80
zobCu>y@7wPfBW?+{x<Wj56lNX>CK8J9w8d&?=X>MM~!K0iDDZ|C=1H>u;(5kQEK=I
zP;sw$Q_yR7=$OfjCU31?OFA>$DIlh>%Qvx`6kt~y;S~~5qbuEZLqjW1>XapPdz8kh
z?u*jdF@IsChV$i1?SBK`Ca^V1pQqztV?H@06yx_1r!HYl;#1CLkRQ=cwOL>XEWyK-
zy`Kn(9_&6C76_cPtJo`1g9n><$o#<^)3~(61>8w&W^Ix_J$z_&Xjgz>tPU`=7~$mB
zI6(NBdjafWmrnOXXV{0Xqq^91tuTKE1Rm(j8=sk;L<82plWIDYOiXOcnSK>7Fnl1$
z)B6vpf@ZyKrI?E$ISnuRU4-6x9g<-TdYHsHaT<+WBKZNNh#IcITx9*7V;jZRf0yw)
z?9o<E(h3-|{%4B|+4%m?!hCL=|Mzs)|AY5`4ln>z9<e0^b;}fhkcD)22pcP23daf>
zRypgMv<{6eIS<hC+|d;|5^WvNY0^!GdJuG}U0fOi=mW78WZWTx!m50zPVP4#)j`sr
zu*u$%WkJz1ogR8iiN<hmB-mO?q#3zLVK*J2!EOstOV22xqz2D=F%4)Tv}C4(Muam2
zrj2K@mrebidI&WXf=Dth!kmx(FQ*>m&LpQkl6;(48kv_BlmBh6y=iehF+X6a{1*o0
zA4$RE{NJab0DAWSlgmG3Ean72IKfY5;}>E7&`O0JA5#E$_wXuUPX!>hDKcA-B+7XF
zp2|S*F{Z?ER6<lf_D~8v**05X8QJfRC;*Cj0vpfrV?=)6wj-2#%UV(S_k&JK14Sn$
z`qIrX`OlXI>VFi9WBIpJG}7OPm4B>N@Py$Vz#*<MpTD<JBAXw`(U$ydh;g;MUDhPH
z7WR3N>?dae4!`pD*pLz?GQvF<<xH%;ZP+5n7p(asTNFo1@wXT7sQl{`8%rg%9c-SE
z8W<w~`BJ_RxBrXT()j%6)8Le&%0B}wYRX3AEqko|+Q=;Zd`t4SOvp?#w-`)hgbz=l
zHVjl_&d-?;95fAl3cepn0kDxbeFg8Dm$1<uAVaz0Ma&C)*Xp*Bf+I(B7^kR0ne>Ly
zds~tKY=F@?C(J3{FS^L|>mD4&%Me>@!w)*L#v2ekD!#sRRLx4G3j&}&p1CsT5dxl;
zL9DXghDU)Aqr{aSNGlRFdCIwlyfzG667-_D8hRl|A&JD~M#~b=U=E-Gyc@(p>b;Jk
z-@6^g`Y?x*+sD*uL|izpNLG;JC#klcb^w`4nQ$&&=V22Q+~os#U*AEJxPT?$c_Isl
zb6SZqrrxW#Tv;$<JiWr~jEax_D)AFjDfA2+5g(Gz0Ro<~F=ctlE<NZFVPM264c(Zf
z&XkNB$Ta6sHe`r{#~9#bps^2eNzcb&4`3B^Y;ryrNFvee3`66;HWo%?J>eLf?}KDj
z&&Bkanrf)0w(;WXl}kLrW4^kvcJulQzQ`w->b*QQpGai7L0it@Au+$<r0VIidk+yU
zWE;TAMbNX`<N=47?aZs`VRM>Er_t=xRA!a|uoxDSDQ1#6`mmXsA}*52fwaiEH##29
zw!pido5jfSvp0g6iD`X~CW>kDPBZDGo!7Wx8wLpz$NM?uHM}`VLmk*==m1X%BcD0r
zEH69Ry^wdX6A5fi&*~pG8|TK_3nmzdLwJ&VrbAo5bbVv>;-#zW$kLFkqNXz)WL~{9
zlRka^&TRVhRHlysmYh4eObaPBrzAx|&ZofY>ELt?4;Hj}fS}$?fh-jdf0}PWWAvZg
zi`0@8q#gmY@cQUYF#)5IuMQ$^gr*?Wvr3^2a_X5gdr=7B5Q03)y3xP>+vAxhwD225
zhOGZ6{WswM7Z%3#zm77E$8LMr^<U2OiIK0{QjXtZ$}d%{EJ9YbnnQ6+OTa?Jy#(E`
z(bnL3tocy<ZF7QgnhneFD3+;6m~Gnjm<-r^6;Q%seo1|pjKZV>242TmbS<}YwS{=8
zsB(XR4*9j4H!g3iU0YvWySlNmcJu1GJ%v(V&L$>xgGb&-PSufu+TfneKJQI(XJ^uT
zfb(%l{IBaR-x+8MAZTM$vozAQI!W*l0!eC!$@h?~k1$b};YFKhujwCCj|9Z2)60*;
zG&ZKlAlr=8<%URa<3jW(c1WN^XX?%wCpU}dvW;;>U2<$D9KZNIqd-Le*Me=o$<y?y
z9c}<2_xpsFfrIsbE|)6~<bM?N*|GokG?)VVKWcj>64dbl3MW)L=j87lx820POQ4@t
zudOUCt+l*n{v17&{m%>0eA>hzQ_s0&m<i2iwmO|wu$0NvU_&8e{vNq+t6NUj{fy<g
z3~EB)OR>RVjR!3cen7Vc_pbxZ1xx^kJIY)uB*~Qd339-*=e)?i64r&5izCm-UT}Dr
zn&*LM!V(BhepWy<TzDp7cHBL&$TV4k{s){>)&!7a=<HBk6|=uoWl9E;F@Q`I0KsxC
z!_p^c>6$0!Xqn2=LmCHTVM)^6h`tU39~(!3oX-asoVE$i&Kl>W?IQ)$IMRKGABkbW
zFdfJ)ZZmKP!H_0!_2v~rokNG=?svWRZm0>6#v{O4nnN<6&FKdm0`}6O;&39`r2l=a
z?uqSPXJ*RG1oE*-`3)U8j!%Q~v&dfm$c5`4{kX8!&8Be!CA?Vm%H7RPoqaWmZ>(Ru
zbp1LO-K=AQ?g10th(I&h`k=M)h8#YpA#d>E`X3^PDJ6TL)PWu}ZZZ!>JbOn+)f=!t
zv)nap5t&Yl7nGQ!>y&&EtN_d%uHtks1Nf5^DR|$49x5k*G*b|T4Nm8V)DT#9Ha-1}
zmK!*TJTr@dupL|y6jNAsa^~~vf#2L{-P^?R1X>utx{cJII%2gi-B`Q2wDigiEc{cp
z6;BA*??IYLKzU3Ly6O+UdF|TXZ(h5GHy@+>hKr-_TN_q%1w|a&c4FTXGBNkjxox{4
zl;j&s%|M20Z|n-stIkaMvoZ^lDt5@12~al$U#HGLsvsZb-s3svBah^xNZRAa1oxPw
zD2PShTLy=jDS5G8#hdbuFx>{m!d#ZUSuVucKx9({A)rk-sM^+?lRTfq|AhJN_*ftZ
z!ICt7C5aUzx!#1nLawd6vDEF<&Vr11p!|%l!ORA`J59w-_ybMwHPkYi5K#*V60ml2
z9UX_T3?u^tz^(t7Wlx%eH8n>TxFg@_W9<qvs${bx*bp#w?m+t%%zY0p-+ve?Ya#}w
zPWCfzGK1bkbY7Gr`DA)<vuTX{Curj7{#QbYnH(Z6a?<8`9s$Xc77&JR8wom=y;J9*
zj#KAJ+|>ChVpvsg1`?yVV;<sT6fU%5Yyq`pncDo!ozp9quUy;^0-L{Aug*EsmO4)A
zb;iE@6hj1^U4#uLDMc(yK;Fo+4ulLI2hW~0+F;1glnGb$)Sx2fJp}kbmM$%NvExm1
z6DE-CcV<R0rh+OCwa8jSp3+(?SPo>38Pv6sZONkqp%X#wWy}@Zr)fYSkacX>qRay#
zK}h(<LRAmu97RAA5hao*JtQ%|P1ckEMwo2c5O_!!^h=tRT?7(QxJa}g4yB+L0d!!s
zF2x&~m?JE+SYDE~y4R=%Nj7WLQIg04QCZ^Glvz9GW@A?Zpv^&~dUOLY4|P$nHw<KI
z-8RsYl0I0}QRz}vUsWscWJO6umn8`aLRu(2)KbtYcyDHqoO2EidZC(?cORuMlB%=@
zTZ!NylP<pS-H{F^`yQCC@87=-=204hlLlU$y9?BCSc;lRS!UUJ?z!aTrK=Z-^yKZN
zd`tDzFL3zgQ6D&VNVm{V!jf}4N#;u4os+L4B$Y>g2Ow@Iu`)?3qyLh3@1pf%{0|r$
zs8q>3p)d)OoT1@*Rhp(L??$io)TdGa!;UFTZ6Wf!dezVgtyHO+ukl$I*HF!IMKmfi
zbIy6rs)O@f_|U_Ci$yptu)f0Tjceb<!ZzJ!T=wzc&_v<fG8XodM9wKmsup1cBIm*^
zM2FKsqF!xx!p>x)VZETno7<pXmo*Q3Y9So5Qw?wTUUQZ|iKy_MM_5OWt>X8xD2$?q
z1tEyqwO?i)StC$h%dk@98B7fM2D2@qZ_KXqPF7Ualr|@=&7VMdJA+fdtN{l_1q%2L
z)VmR5J$)K012iG)zBmX!qkx^BJ`@4)s_=OpL2R^-R0>_jnK8QN%1Z<C%r!T@=t|Ho
z6f%8p--Y)Owrbzv3w)JSB-&xuU%Yexq2r9EZLKkVDAPcolWh(V(U2mFzqB2$c(ie7
z(8ZMuKHoBO2nQC<pWE1RcUjd>ER>!*$g)(>eY$I>Iy+!|kZYwhm8Wz|lPm&e4t#-O
zz(Sqfq*H6)5F|K^>oxfgdJ1m{fDi!%E4yxN3EK;eSw2sFYa9(@b*LR^U?~C6a(Cr@
z_FO^w1#_MW9`80-2NLc#$}{3X1J>*Z^(xL4$U=-2Q~0#ct{00??D~VI8gIsw$`j4C
z&dr_<!b~!goTUZczrKpcDdHYF6T&s>L&ZH9SaVba*4%{YiA8rnFZK^%h_xrO6mqMX
zdU|7Og~z-<qq(MxzfXq{IEd5w>KfJM^mectOgnG9;Y^t?D!ZFFz%p%AOXNk2`c}O;
zpI=(~sMlH9shY{^Yw<}W@MP}X$=u0MuRPXsh>wH<>RaMHJeZ6k1i1KiX{lmBl0s%&
z(PkXt(}--1`#1~*A`zQjy7LL<{t$<Q<G(l?IC%bVVLqQ5=l>pN0-vzWVfX*EdWS9$
ztQH&1{y{kegzu22!?5SuGy6Z1ZY(J#SdLkAhbvqxAIK)Hm=*45xr@EgQ-t<N5Y~((
zJj019sn2)7sR3<EKz*kMLJ-kY1CcL}c4{CZ|J+7YI4894V_9>E{Lkl#1NT1^3aAM_
zuK#T*IJ)15m4Dcd`yBvQo?%K9<iGzAusEc3RMIgAdq#Tzpk4z4P)#R!21o~IG6ZN7
zM+Mdph1DjVUQtdhUjkK$LR%>RQb+mkXmL)Q?8PoC%J3TEEWxlxBAsaolO7d<Td3lt
z)zzhPXAh1ljlM!bFw>b67*<cwiam0EI9iNGG#=ss&D4b(E32!b-ZXe9<;t1L7S=F_
zR%BU{v=*+yJ8n>^Ge3X?IJoYWZ7e09u0yxd?KOb`YFj;@k=C^C94k$bY1%%@_cGy(
zTW>s{t2rPYruX3`_W@7M?t%L`w3TDQ00M$<YdBMnF(b)O6+9QMUbcGLxy1xZ)au1p
z_y~KE`~!I@_yjl-EfP0gPLFD~3IdecIzak6oTM#mvQ=37jvg4WG&!P35v+o2u*+}5
zK^Kx+g7j5Sac~F(4&T+j3cx122FGWSV9yK~l#>N?6z^#x#So`(88v`6h6tuNhb<G-
zl_C(1ALA3V9NQWU3Ujl{E!P`$vXSrH@EfR3A2_)zl3~N`-cEZKHG&x*CKOVF36zK~
z8w9YPBfkX+x-IT?08EWOtcjT-WQ*iU*=H2g;0j7IjIszB+E(;U^{4;&h}t4>E-etu
z1qqigu$tSH<^MOhYj$O2<HD6I%PSmus*0jlPU@3)?;t7g4QHp~q$;zr0bt6)q8>Y9
zo_8*-y_mSfAkLC=p~L(|Oc?7HlY;%MBLQUO{7C*LD|u^@DcBCdn{A|Y_KMpP1RWz)
zU@gx_8F_ABpsoNW-*PNs$BA_<h9Hzj8!#6r?p7bvgI-98@}@k8FgD&<)s9%IMN2DC
zU^xX<sRhqZM6YULP)OAflK}iu0w;+gBFW9jK<ivut`j*<kTf>mhli_0IdBB58-O6d
z77|*OvBe=pm|sJtWC~=*g1@<c8Hv4<>$$yQ<d``0&$$#wOWC;(Cl@7xN4J!XAs>SR
z5&I9-;j11G>ZT-`3*kN?J8+2oS14o$&wu2`=f96Jn@4}8Xa7Mf?4QnKIRd&=sslJP
zPyrb(HH>*8>x4J0%$gK`Kq4<uXFxGLsJpOeL|KS41)U;U6GuMx9X<4kF3jNqYHRco
z+I+?!5H%~^^1c|^<y5nPcOV=!7iLg0U=VUJy-L4wr-sCRWrefuvauS3N;9Mo^*M5S
z=qNIAiNRo;Q}=1PQrp^#NxCg;G<xo~E&N9N89`1lz8c8Q;=MYU3q7U5%Qd)2(GE;I
z7g&=Q;LMas+7oV?;Vm4sE^b0#{mss-O(5cqqM1Z&A`>EKQg6DjFagXK(9wD$HrW;k
z_X_10yU-euSgCZVVqW@YN4js2S^<P66nZcpSSUq|F)mEZ>y<^EK?QkL2+8eYwX1Ed
znQ(&AmQk;3aiJMQ&?St!j{G4#&ahwe>*&1q2F-f32X5DKwFAvQ&d~bW#WgPc6>m#6
z%kAl)NJRpfeBfxWNZ=5#mUB{?$Y!IpVA0&DFe<-+I*l|Y5oSh=mFuh)q=8+=?v_FX
z#Ek;)gvAd`S2MhUfw^+9(Bvz~9;(|+(u!w9Iqc2|?_fWdkmLl4TRYgWgtDm)v5)-#
zn~OdeG&K)PmnbJ0eAaj`4a&nIPHUBk1==6q)1k;91le?}vFAvXQ4PtC)*US#RQxu)
z-s==5G?H0(We4nNq>fO51)W{AR5GJRPN$NNVgoJ2ECQ`Geggkbgn8(iOnw8q=$Br;
zuzE$#5NRIzB@}W-_Lnh!Rczv}nN=go^uUi>K>Kn1tau|3y#1hve|s<tNREQBIs>q_
z@6ifJ=bh~q{6HG=AqqVc;}!kUx5-l$f|%~98t;`5@{|9PvXMYNhZ8rzIKag!tlt!5
zuy@Ko_`4=&?1eu=UlslzMK(njCPX4s7PpM@jKViXaxFG-+U!kG3y3~A#R1Z+1scOX
z!+|e3Vrws%G$HB;EM0QO+V<IBfEZ$o8%QvZrd)vhzO{D!V{&as0ynNisRIX-yd>q2
zaH~r4RS7akWfF&{m2fQ)v>754G1VYXw7gUJq)$gl1B}jeAYR`vX5I7o`r7)1D;A50
z7n4fKFo#VQJ!s_cpx9F%(~u3Y?VdtJB|?sA=h7>y>%!;Zs8oTx+b;=;*#C_Gw!JbA
zjGmC)Z>`aT?SEMMg@OA&3I*K%K92ud3Xbk~&;F;Ov*NdQVJB^MkSRaw<Z*5D9RGjT
zd8ym1`_2l=&f!=HY5=0`I*g%Yk7sa@n5hC-%6Xwc^uVvV2!xE4w9zyPZ~zEvH@@zd
z_4-B{j8XHQu~&&S@B%|XWzsZHgR@Qy|D-iUo2vf~JY(DgJB!d!i#yWH3k`67Ft)}H
zjsw78Vf70-6byH3Nk_KPs&}yMiJ6K~)tP~LqtRSB!zN$zIbX0BC+dr^DwL=o;6ddN
z;VslFrZd>Vp{Z<2VFM*8Q6pyabklp-nYNgT4}@h)NM{g4)lGB4T4I$%O>W=Zk&;}<
zVM4w&J&h1?TXDP9Ei)+;lz{QZv?kcJ=DTI~n&52f$kdd@T4a`rQ#4=lX7!QbEbCIP
zm9=@bg|0vP>@}+QV0XLh!|#E9s>$U}uVHmHA+4-)4*m&aW^`<TEiCDF7ty~EX&fEV
zyQ^r($W2$~oSpO_=j_CmPz0WTKEtDSI4;LuQj=)kE+h=d%+W}V<f{zkX<!W}!6oxw
z&31Zv;oS8z3Z^ae1YuI*zR)($!^6w#IBOrHZJ-l|&(AY_caeuH$wUego+2;x1Fiv{
z3&Bt|Q;5a2f69zAVvtCw!>b6#^9oYKx~5qeDTKj+Kp_vi5N-I5=%UA5iskbO(0rrb
z+|ZB9GF#jt(VC1VJ9-(#2_&KQRc#ic^jc`|%0(r8u&iky29)5d2vWuDjm$X^Rs1Mp
z1k^j}@P10eBzjGWFgs|eMQ1@rcs_uNWJ$U9Gc7z489Vc^B10#GKQD!7kwnEHtqEn2
z{p7q3m|sOHonSOzgD-64V#En)@v5DlsYgbH9`nRHBFV2sUeE9II@9*_XOGu=QWwEP
zi-GpOfWUzSFa-_yWxiv*B|{{2249opBa!In%qgRVWlHy&I;%mDQwFw{3~&(-h08;*
zB67K-O_;4ns^Ur?+Fo*@?8zC34JkFioDl+AnZY>24HK=+z>)`=_NH=y<VT)ax}9Yv
zwxq*h!yXzAH;)*8Wr-8rMnp`&+*r_)Bbjom(U*`gYrxEW$V>-OXQt{lY+d*hlarZO
zXY3^)XJ#GA`<$FXS>omMNI~b@j}ZyL-p@?tPBVjpR)Svct~{c@%{*r$;cw&oiUk>i
z$rRNo1w46MAy4IHe0##q-!<oSBq8ltQ9}W0%J)eBNIFcN2bCUcLfWJzuQ9nnM>S~<
ztC(|LQ+UF$;0K#v(E7bEcsEF_by7!!4sv%537Hkoe=L)rY>7W2DA5TrA4Aqt&J*d!
zhSJ5gl?};amwh6$C~N2v_bhE<uMFFM$^@!G?Rp%Z^|MQ&F&ILfkL9(A7#cR9n1R{8
zS3@!i4s`^$7Yz%lY9ns$oOafDL=ZcG(UpTHh`D(!X;4S@z4=S@81)s4%o#4jl8CE7
z5v^g+3;`CHP0(k$H4B{%mSAEhH)<QZutWCiH`Kco7<xdIrdhNHi^3ecMt5j$!-b+O
zsVN!%qTEZ6C9>wBIljedLSn)9J-3YjDVP;Y8nTNJk<^oxeUv~CdV80gb|hV>c3lC0
zF-ETiw#Z3kAiRhFF#9k^dD0a`2(KxYHNlL4`O~rnqlylZ0gAlxR)Trf@X>34xtoXS
zx&=Kdi$!#-q9s9OqullF=w-;9T=r<WXimw>1%8|M4DK?a5=fc`hH<q1IW0IDba-|9
z9JXxRRi1oO6Tx<CR(bA0CO8AI-UX^If;wNI2Ez3X4pef-@vVkXaLqXr+wm}AuM^9d
z;L0|%yo)O#U=Js5@#L<=^DJBI?O<w8+G}XJ-wF2S_3t<X$pC(g!>KWajCx>}H6(>=
z6k$x^k3oPoNityCv#Bs(x)36M0cx}&XTY+LEYrrS#qnAd4;)D2wSQQNOlcxRD$r9M
z5{v{VpVi0~sAL(bN6)UKys!Jgb^>kan`{H#GRC&}D~MtV-Y&LP<v6q5N|vo<4DAJ0
zSfbSHj2M(WL?p>mG6VrYR4hT;9x{DVc?cUDi5Z++-JhyL(75#!%7y@52M<eMq@@Zl
zAv?HBhi1~YBo{OxGm25q_K~;u5Ny=EH{0d9ea=e+?K)^iAg`)OkbOvWIrXg5E}|^+
z48Dl%0Ejfn>vj~;i;qR!gr~mr{&Cr<f%qF+5hueqnN%JWIKxmgSnQGcVADGAz1)^f
z;la6axr;bFIw$X&8^|pZn20MLFaDDJdD#U*m!?Pxcz=>dgMCDdhyF8CDsN<nDSqtl
zfxp>`4_!d!zp`_IZTeq8BesbG*`p1=!jElP0krU+^MXF)b3NqTYuFF=&Ok#8kiW}<
z;)=AfEe*hEv%NrOgz9*IC;@GoaEVML5*Ow$1g>8zk^s@KL@;+y<rkzh9jmI<>JQC1
zN{A$507mfDf;Box-g!aZ!TsRk8bf4OwZPq=)R}kfqD@qcHs-ka5$wYI10;b5y4tR!
z($9+YLk(b1=`9gpHF!5v#WXEgSlcQIb$XCeBf8({BwnamW8x7g!d`J!6B|{yK_T&i
zY1r#{oeT6f4mIOOqTDQ*n4V_n>{);2Ri!4^mVH_no{$#mM{IdO0T)zMaF|+O=MoSZ
zAnX=4XBL(YFN#cl5E&(GIxWC}DIFnhGf@bcU1ycR{;Dux&A-vb-rf$7Bk^DLQBFAb
zpJO~Y{+rDevxD`&3gh~}PlY}D<G&X|E7Ig>$R(ZB1hNGu3#771H2<H0(1Y@RsYGq%
zZ_O-_L^xBzgnP#TAdyT;Jr`lqhb>bX$==^LYXl%n5z6>|0nxk>C``Q|1`0v6dF-|T
zK+(RTykQ81A!JdWYK@%ad4ZnDF~c}|sF+mHBmW@2CNcI^E8MGGCFkLyWDcsXV}^*0
zf#V86Tt>s%l#J)<Y5hhR|FT<;k=nn2W#8SV;fLE7SXBnt(9C44da&-|g`4Y_*N$Cu
z5xbvG>VAN|N?TG91t}4;)E!j)?)-VU?by3S_v_T>w(J~oK*6DKIJ<~^;DfhEaZl!5
zXbf5-U^C{fm_E8LISd%EV;DA!!66ify^s4yI<;ja5dq4)dfS=2dpgJeXR6b<wm24B
zy?8JlHW~AKe-cjgKU_t78}BHT4)uSrfcsqZC;mH&3Sja2&-r{QJKp~r#bm@_4qlmj
z&Yp;ZcuC6dbc8*osQ|(>W=O0buwopxe`0XQAKw`i5c$W=X~785rPv>E|05sA<v&}>
z6(<%(h*Jm}m8nrR*a<%$_YaN&KcR9vE}W<QUO4~Aq^gaG2}qYC&VR1BurQwgr@#yS
z^PiC|@RRQL81tVm6>{VGKk13s1KwWqpJ7t#9&L~N73cpT`!5e)A4R~6xoke0pQj4V
z%@>OcWBc#81V6%ioSVb^INA9^$@9G0*}S({Ef(Cf*|J;A7jxyR3t_Ff`AVgf^A>Z)
ze`Y%SbL!sW&yN^CEsbx^JBx*4@oeF2HtU>W*XBY`oM_Z@v9n9?RReEqQ66C$kKME<
z|4fcLHkbon<Rl+a{&R)g`27EYL_ML0oSVb^jOG7?2>vz$Bl6G7)JBLG`Rj=Gf3}nz
z+y5h+k`Qz_{~7P0+%XkCIk`VL{|D*+`Qm{850h}L|4(iP_J^dG9W{a!Lw&sBNK=~e
zhvA15^TwA4*aQLiE2tQ2l4GJbx}2JpJ$2fCIBJWa`zhx|WIy5Hu$J{e0sMd&SJ;MF
z(cPfl8B*P`=J{B?ON+;y<ZP@#hS?u5C!2vYgUaLD12>G2Ce>fF!BimL#?J65=XCnE
z@80DfpBx*NF;<X?9i8bXy$zH9Y<}SW*KA=SKlcA(b2W;Oi25xt2PDwYkGTG0AsGdw
z-<~i<{(Y%3HKOS6(EJaohj{!aSIEwf<9|<qWuo(+$&F^mg%f;4`#)Di9B?$)#E3fH
z|LJ6m{A2zzi-l^XoGTX>5Z5bv3x&c$p?0>ED^(UN*r%VbF6Jw_av?^;As;#a2igC4
z7?=MN`WmnQL+E-Ej~_nsv9El2?RvIY`K7OZ?5)%3)hlZ+fAcH9d}Z~^t8cyZ(%jXX
zGhfYoB|ZDn%Wu8(%OCsZdnR7`!9Va@C(-X1#@mAeefqyT8jX7#{a=Foj|Q6<-N*XB
zr~j)9nfb*Wu1zY}=8N-{lDAl9AikQ-y0!Vre15UASg4d1%5IE?Lp~1E|GE6Y{g0(Q
zVnXBk4?_rh0*@a)a|X)&Caz#E<6m|@_s1`PCG+LizW?9+pKpKTxBudszxbd2)(8G~
z^$-2-uYUe_f9IcF{kb>pua-aYdg34dUj1Kx{WBjw|7U;d8$Wxx*~$G$@9STG^V-jS
z`fJZU_xi-y-<W&(1P~j8cq$a=)Bg+eBkA)v`oB1zAM5{-%tk-Z*!*Ymi?xC`Kkrs6
zxoWPQ&sE*Uvt=(=EoRG=s<&A5iq*5_#eNvWJ`L0Vd)fa5#01Cse;8$-{JFLNb5+{^
zYVk*$fKMfU=3DRgKKmnI{A=wm{^l23&rE#wAN=rNe)3+&5Z*2n=#&2u?E@b}|6~7e
zod5eYc%*Osb4OI{heYrg^N;vnVZ8nylD<#UEH?j{>SCpGcHwNnt>i1EYNfVNs^*Jl
zv-70|?`*b~U0keI3TJai>v8D%zlZ;qE#bV-(YiTa>vy^TZ`c3L8C~_?Gm-oc@7p~d
zDaUWU^C-|K|G3-a-Ux<p4E>+y{cq#=-v}ln2C{GdtF_qEllgdz`OlT0|Ht!xGW0(P
zN^Jf!i^WoTvFI+87QMoPn>$-Rn_tM4=JVAYtbjr}?=9fr5hrH&`aiJ$S1h6?@Ob?{
zXy#7lnO*<A%h>FD>pc@6_@nRr+{r*5LwP4qpilmhb2Eyc<LLh);(td}Gsi>yU2gx!
z=09_|LtaNC^)UUPD-G0t81Mfbjl{=p{qUK`f8k4s_vC)?;`0AI(|-Td!oPp;-aq%<
zGuxlL^rh>+_3{7yoz%=Hg7kmOW&ixYy8iQj<juc+*Z-S8IbHtz&9A-mm!@W>|4ZYS
ze&YUze)iN4oSVGy=?|a(UtcVK_qE;cy!q8v{%dLZa%%duZ~fly)GmJG*MH&zZ+-W-
zf92OU|M{)|>%aWz&wuXyzwp`O2ak>M_{Ec?fXKgA@;phfeXxeff4($u{x_G;kMqC!
zh&ZATw^4J~yPKHom2yEPOjP1S1>t~Khb=o<R?|kgXcUyiC%I8-vdr7LmU$y6&go8~
zd<g1ev5;Vk^}K_y8LkKgbSbuP-^Be6IJbeaF&?Tau}H0Ld>cnL+CW5#%Pc!?7Z;wj
zQH!28$DxgWj-DePXQ`hAOW@=VitC;Pr2SzGlYe9f$MZk4^9$qiU;9(^<eupKk7eoP
zDEiKV)NSGtE!;OfN)<3v{&NHOKjoMcGLHX@o|nS;AFF`T6Z>u01Mb=zxdkv>{s;Vj
z)PEc2e?1L$v3E_5#s6tg`|a1q#s-SG`wvkVcw-yaq-|`B07c6G5zqhS7xJZX{C5O%
z5eGRi{~54Cvs3S!U=GM|{XcO2qcHaW;xjdx&!u^gx{y6v!mYdYhok9Z4E60xfkFAl
zdXO^FzY{`xsQe?=8>|0VD3!+h|0hKL1HteL7aQx%rx&v6+}IL4kYN9xJuIW%)2N3u
zRQ^%xD<=QhY+)S#9re5rKJI2om>BSOy;{XpETKo}HLGJ?@HFON+{c&#V+xEZ@V%hG
F{{v`u%&!0d

literal 0
HcmV?d00001

diff --git a/gix-tix/tests/fixtures/split_commit.sh b/gix-tix/tests/fixtures/split_commit.sh
new file mode 100644
index 00000000000..385bd2de950
--- /dev/null
+++ b/gix-tix/tests/fixtures/split_commit.sh
@@ -0,0 +1,20 @@
+#!/bin/sh
+set -eu
+
+# A split must preserve disjoint staged and unstaged hunks, including changes to the same file.
+git init -q -b main .
+git config user.name author
+git config user.email author@example.com
+printf 'one\nbase staged\nmiddle\nbase worktree\nend\n' >both
+printf 'base\n' >staged
+printf 'base\n' >unstaged
+git add both staged unstaged
+GIT_AUTHOR_DATE='2000-01-01T00:00:00 +0000' GIT_COMMITTER_DATE='2000-01-01T00:00:00 +0000' git commit -q -m base
+
+printf 'one\nstaged\nmiddle\nbase worktree\nend\n' >both
+printf 'staged\n' >staged
+git add both staged
+
+printf 'one\nstaged\nmiddle\nworktree\nend\n' >both
+printf 'worktree\n' >unstaged
+printf 'untracked\n' >untracked

From cec58710edf1bf3c5c207d5aa65552df845bf95a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:36:38 +0200
Subject: [PATCH 068/282] fix: retain history selection across filesystem
 refreshes

Preserve the selected commit by object ID when reference notifications refresh the visible history. Fall back to the first selectable row only when that commit is no longer visible, while keeping explicit edit operations free to request their new top commit.
---
 gix-tix/spec.md    |  4 ++--
 gix-tix/src/app.rs | 23 ++++++++++++++++++++---
 gix-tix/src/lib.rs |  2 +-
 3 files changed, 23 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 61d9995949b..3dbb3c5669f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -432,8 +432,8 @@ space first; changes blocks adapt within the remaining history width.
   malformed or inaccessible ordinary refs remain errors.
 - Ref changes that affect view or hidden tips trigger an incremental history
   refresh. Decoration-only changes avoid traversal. Filesystem-driven traversal
-  changes select the newest selectable row; manual refresh and display toggles
-  preserve selection when possible.
+  changes, manual refresh, and display toggles preserve selection by commit ID
+  when possible and otherwise select the first selectable row.
 - The worktree watcher exists only while the combined worktree block is enabled.
   It observes the index and ignore-aware directories that Git status would walk,
   using non-recursive registrations so ignored build trees do not generate work.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 3138ee6f0bb..b0baceae5a9 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2070,7 +2070,7 @@ mod tests {
     }
 
     #[test]
-    fn filesystem_refresh_selects_the_first_selectable_row() {
+    fn filesystem_refresh_retains_selection_or_uses_the_first_selectable_row() {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
         complete(&mut app);
@@ -2079,13 +2079,30 @@ mod tests {
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
 
         let rows = app
-            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[], true)
+            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4)], &[], false)
             .expect("a filesystem refresh computes lanes");
         let (rows, graph, time) = compute_lanes(rows);
         app.finish_lane_computation(rows, graph, time);
 
-        assert_eq!(app.selected, app.first_selectable());
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(1)),
+            "a still-visible selection survives new commits"
+        );
+
+        app.update(Action::First);
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+        let rows = app
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(3)], &[], false)
+            .expect("a filesystem rewind computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(app.selected, app.first_selectable());
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(3)),
+            "a removed selection falls back to the first selectable row"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 38ee6f8fba5..ba8e81bed91 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1343,7 +1343,7 @@ fn event_loop(
                 hidden_changed,
                 "compared reference snapshot"
             );
-            let select_top = std::mem::take(&mut refresh_select_top_requested) || from_filesystem && tips_changed;
+            let select_top = std::mem::take(&mut refresh_select_top_requested);
             ref_snapshot = next;
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };

From 60c41aa912ae5a7ae191d4cda92e6146e33e59ca Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:38:50 +0200
Subject: [PATCH 069/282] fix: ignore non-commit refs when editing HEAD

Build the edit rebase graph only from refs whose direct targets are commits. This keeps tree refs such as Codex checkpoints from being passed to the commit traversal while preserving normal branches, patch refs, pins, and detached HEAD.
---
 gix-tix/spec.md         |  2 ++
 gix-tix/src/edit/mod.rs | 49 +++++++++++++++++++++++++++++++++++------
 2 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3dbb3c5669f..dea39be7c04 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -363,6 +363,8 @@ space first; changes blocks adapt within the remaining history width.
   their trees unchanged. Rewritten commits carry `tix-rebase: pending`, invalidate
   existing signatures, retain the original parent needed for later replay, and
   use a bright-cyan commit marker.
+- Edit graph discovery follows refs that point to commits and ignores refs whose
+  targets are trees, blobs, or other non-commit objects.
 - Time travel from either endpoint of a pending region completes the entire
   marked rebase with cherry-picking and configured signing before checkout. A
   conflict aborts before refs or worktrees change.
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 4127d2d603b..f03f14ce97b 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -13,14 +13,22 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
     ));
     let mut revisions = Vec::new();
     for reference in repo.references()?.all()? {
-        let reference = reference.map_err(|err| anyhow::anyhow!("could not read test reference: {err}"))?;
-        if reference.name().as_bstr() != b"HEAD" && reference.try_id().is_some() {
-            revisions.push(
-                gix::path::from_bstr(reference.name().as_bstr())
-                    .into_owned()
-                    .into_os_string(),
-            );
+        let reference = reference.map_err(|err| anyhow::anyhow!("could not read reference: {err}"))?;
+        let Some(id) = reference.try_id() else { continue };
+        if reference.name().as_bstr() == b"HEAD"
+            || repo
+                .find_header(id)
+                .context("could not inspect reference target")?
+                .kind()
+                != gix::object::Kind::Commit
+        {
+            continue;
         }
+        revisions.push(
+            gix::path::from_bstr(reference.name().as_bstr())
+                .into_owned()
+                .into_os_string(),
+        );
     }
     if repo.head().is_ok_and(|head| head.referent_name().is_none()) {
         revisions.push("HEAD".into());
@@ -90,3 +98,30 @@ pub(crate) fn edit_document(
     let edited = std::fs::read(tempfile.path()).context("could not read edited commit message")?;
     Ok((edited != document).then_some(edited))
 }
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use super::*;
+
+    #[test]
+    fn edit_graph_ignores_refs_that_do_not_point_to_commits() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let output = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["update-ref", "refs/cache/tree", "HEAD^{tree}"])
+            .output()?;
+        assert!(
+            output.status.success(),
+            "the non-commit ref is created: {}",
+            String::from_utf8_lossy(&output.stderr)
+        );
+        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let head = repo.head_id()?.detach();
+        let graph = loaded_graph(&repo)?;
+        assert!(graph.parents_of(head).is_some(), "HEAD remains part of the edit graph");
+        Ok(())
+    }
+}

From ca1e29fab485a68cdf6fc1a0c412b218d58a259f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:41:35 +0200
Subject: [PATCH 070/282] feat: mark reword rebases for lazy replay

Use Tree::LeaveAsIsAndMark when rewording so the changed commit and its linear descendants retain their trees while carrying the pending rebase marker. Time travel can then replay the marked region with normal cherry-picking and signing.
---
 gix-tix/spec.md            |  6 ++++--
 gix-tix/src/edit/reword.rs | 28 +++++++++++++++++++++++++++-
 2 files changed, 31 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index dea39be7c04..7cbd41b3c94 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -309,8 +309,10 @@ space first; changes blocks adapt within the remaining history width.
   regardless of value.
 - An unchanged editor document is a no-op. Otherwise tix recreates the commit,
   signs it when commit-signing configuration is enabled, and rewrites every
-  linear descendant with unchanged trees and corrected parentage. Mutable refs
-  follow every rewritten commit; tags and remote-tracking refs remain unchanged.
+  linear descendant with unchanged trees and corrected parentage. The rewritten
+  region is marked `tix-rebase: pending` for cherry-pick replay during time travel.
+  Mutable refs follow every rewritten commit; tags and remote-tracking refs remain
+  unchanged.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
   the main status line and do not leave a repository retained by the UI.
 
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 6bf9f589987..ff1c050c4b7 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -95,7 +95,7 @@ pub(crate) fn apply(
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
-        rebase::Tree::LeaveAsIs,
+        rebase::Tree::LeaveAsIsAndMark,
     )?;
     Ok(outcome.selected.filter(|new_id| *new_id != old_id))
 }
@@ -310,6 +310,28 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn marks_the_reworded_commit_and_its_linear_descendants_for_lazy_replay() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides(["core.editor=:".to_owned()]),
+        )?;
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let (_, document) = document(&repository, middle)?;
+        let edited = document.replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
+        let graph = super::super::loaded_graph(&repository)?;
+        let new_middle = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
+        let new_tip = repository.head_id()?.detach();
+        for id in [new_middle, new_tip] {
+            assert!(
+                rebase::has_marker(&repository.find_commit(id)?.decode()?.into_owned()?),
+                "every rewritten commit is marked for lazy replay"
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn rewrites_direct_refs_except_tags_and_remotes_and_signs_when_enabled() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
@@ -356,6 +378,10 @@ mod tests {
             b"rewritten title\n\nrewritten body\n\nAssisted-by: GPT 5.6\n".as_bstr()
         );
         assert_eq!(decoded.author()?.name, b"New Author".as_bstr());
+        assert!(
+            rebase::has_marker(&decoded.into_owned()?),
+            "the reword is marked for lazy replay"
+        );
         assert!(
             commit
                 .verify_signature()?

From 3d993e17aa84b8ed2ae20ddecc839bc211c8dcc1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:44:04 +0200
Subject: [PATCH 071/282] feat: streamline tix history actions

Make the history footer read in action order: view and edit prefixes, copy, focus and display actions, reference and signature controls, navigation, then quit.

Use m for the commit-message view, shorten the changes label, and render the Tab key consistently. Add a plain r reference-visibility toggle that restores the exact display mode it hid while leaving v r as the independent mode cycle.

Update the behavioral specification and focused UI and input tests.
---
 gix-tix/spec.md    | 13 ++++---
 gix-tix/src/app.rs | 37 +++++++++++++++++---
 gix-tix/src/lib.rs | 23 ++++++++-----
 gix-tix/src/ui.rs  | 86 ++++++++++++++++++++--------------------------
 4 files changed, 93 insertions(+), 66 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7cbd41b3c94..737902854cd 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -153,6 +153,9 @@ without trading responsiveness for metadata that is not visible.
 | `v m` | Toggle mailmap resolution. |
 | `v r` | Cycle all, normal, and no reference labels. |
 | `v h` | Show or hide configured hidden ancestry. |
+| `r` | Hide reference labels or restore the mode visible when they were hidden. |
+| `m`/`]` | Toggle the commit-message view. |
+| `c` | Cycle the tree/worktree changes display. |
 | `Shift-R` | Explicitly refresh the revision view and visible worktree status. |
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
@@ -165,7 +168,9 @@ shortcuts. The footer underlines the `v` in `view`; while active, `view (` conta
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
-actions follow before movement, panning, and diff navigation shortcuts.
+actions follow before movement, panning, and diff navigation shortcuts. Copy
+immediately follows the edit group; the reference toggle immediately precedes
+signature verification when verification is available; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
 possible; keys that cannot be expressed naturally in the label remain explicit.
 The Enter key is written as `<enter>` throughout.
@@ -217,10 +222,10 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Commit message
 
-- `o` or `]` toggles the commit view on the right. It uses at most half the
+- `m` or `]` toggles the commit view on the right. It uses at most half the
   terminal and reserves 80 content columns when space permits.
-- Its history-status action says `open message` or `close message`, avoiding
-  confusion with the edit group's commit-creation action.
+- Its history-status action says `message`, avoiding confusion with the edit
+  group's commit-creation action.
 - The panel has a minimally shaded background derived from the detected terminal
   background, with the default background as fallback.
 - The title begins on the first content row and is bold. Body text follows, then
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index b0baceae5a9..e70eed1ff4d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -273,6 +273,7 @@ pub(crate) enum Action {
     ToggleEmail,
     ToggleTrailers,
     ToggleMailmap,
+    CycleRefs,
     ToggleRefs,
     Refresh,
     ToggleHidden,
@@ -346,6 +347,7 @@ pub(crate) struct App {
     pub show_trailers: bool,
     pub use_mailmap: bool,
     pub ref_mode: RefMode,
+    visible_ref_mode: RefMode,
     pub has_hidden_filter: bool,
     pub show_hidden: bool,
     pub align_metadata: bool,
@@ -425,6 +427,7 @@ impl App {
             show_trailers: true,
             use_mailmap: true,
             ref_mode: RefMode::Default,
+            visible_ref_mode: RefMode::Default,
             has_hidden_filter: false,
             show_hidden: false,
             align_metadata: true,
@@ -685,7 +688,7 @@ impl App {
                 | Action::ToggleName
                 | Action::ToggleTrailers
                 | Action::ToggleMailmap
-                | Action::ToggleRefs
+                | Action::CycleRefs
                 | Action::ToggleHidden
         ) {
             self.history_display_expanded = false;
@@ -794,13 +797,20 @@ impl App {
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
             Action::ToggleEdit => self.edit_expanded = !self.edit_expanded,
-            Action::ToggleRefs => {
+            Action::CycleRefs => {
                 self.ref_mode = match self.ref_mode {
                     RefMode::All => RefMode::Default,
                     RefMode::Default => RefMode::None,
                     RefMode::None => RefMode::All,
                 };
             }
+            Action::ToggleRefs => match self.ref_mode {
+                RefMode::None => self.ref_mode = self.visible_ref_mode,
+                visible => {
+                    self.visible_ref_mode = visible;
+                    self.ref_mode = RefMode::None;
+                }
+            },
             Action::Refresh if matches!(self.state, State::Complete | State::Cancelled) => {
                 return vec![Effect::Reload(self.show_hidden)];
             }
@@ -2649,7 +2659,7 @@ mod tests {
         app.update(Action::ToggleName);
         app.update(Action::ToggleTrailers);
         app.update(Action::ToggleMailmap);
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         app.update(Action::ToggleAlign);
         app.update(Action::ToggleCommit);
         app.update(Action::CycleChangesParent);
@@ -2661,9 +2671,9 @@ mod tests {
         assert!(!app.show_trailers);
         assert!(!app.use_mailmap);
         assert_eq!(app.ref_mode, RefMode::None);
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         assert_eq!(app.ref_mode, RefMode::All);
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         assert_eq!(app.ref_mode, RefMode::Default);
         assert!(!app.align_metadata);
         assert!(app.show_commit);
@@ -2673,6 +2683,23 @@ mod tests {
         assert!(app.align_metadata);
     }
 
+    #[test]
+    fn reference_visibility_toggle_restores_the_mode_it_hid() {
+        let mut app = App::new(1);
+        app.update(Action::CycleRefs);
+        app.update(Action::CycleRefs);
+        assert_eq!(app.ref_mode, RefMode::All);
+        app.update(Action::ToggleRefs);
+        assert_eq!(app.ref_mode, RefMode::None);
+        app.update(Action::ToggleRefs);
+        assert_eq!(app.ref_mode, RefMode::All);
+        app.update(Action::CycleRefs);
+        assert_eq!(app.ref_mode, RefMode::Default);
+        app.update(Action::ToggleRefs);
+        app.update(Action::ToggleRefs);
+        assert_eq!(app.ref_mode, RefMode::Default);
+    }
+
     #[test]
     fn history_display_group_stays_open_only_for_grouped_actions() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index ba8e81bed91..c4e276790f4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3677,18 +3677,20 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('m') if history_display_expanded => Some(Action::ToggleMailmap),
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
-        KeyCode::Char('r') if history_display_expanded => Some(Action::ToggleRefs),
+        KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
         KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
         KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
         KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
+        KeyCode::Char('m') => Some(Action::ToggleCommit),
+        KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
-        KeyCode::Char(']' | 'o') => Some(Action::ToggleCommit),
+        KeyCode::Char(']') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
         KeyCode::Char('y') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::CopyAuthor),
         KeyCode::Char('y') => Some(Action::Copy),
@@ -4527,8 +4529,14 @@ mod tests {
             Some(Action::ToggleEdit)
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)), None);
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)),
+            Some(Action::ToggleCommit)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
+            Some(Action::ToggleRefs)
+        );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
@@ -4550,7 +4558,7 @@ mod tests {
             ('n', Action::ToggleName),
             ('t', Action::ToggleTrailers),
             ('m', Action::ToggleMailmap),
-            ('r', Action::ToggleRefs),
+            ('r', Action::CycleRefs),
             ('h', Action::ToggleHidden),
         ] {
             assert_eq!(
@@ -4596,10 +4604,7 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char(']'), KeyModifiers::NONE)),
             Some(Action::ToggleCommit)
         );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)),
-            Some(Action::ToggleCommit)
-        );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
             Some(Action::CycleChangesParent)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8cea6f0ba02..125696c0e27 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -667,9 +667,8 @@ pub(crate) fn draw_with_worktree(
             frame.render_widget(
                 Paragraph::new(Line::from(vec![
                     Span::raw("PgUp/C-b up page · PgDn/C-f down page · "),
-                    Span::raw("cl"),
-                    Span::styled("o", Style::default().add_modifier(Modifier::UNDERLINED)),
-                    Span::raw("se"),
+                    Span::styled("m", Style::default().add_modifier(Modifier::UNDERLINED)),
+                    Span::raw(" close"),
                 ]))
                 .style(Style::default().bg(PANE_STATUS_BACKGROUND)),
                 Rect::new(
@@ -772,8 +771,8 @@ pub(crate) fn draw_with_worktree(
     }
     if app.tree_changes_visible || app.worktree_changes_visible {
         footer_spans.push(match app.focus_feedback.take() {
-            Some(destination) => Span::raw(format!(" · Tab → {destination}")),
-            None => Span::raw(" · Tab switch"),
+            Some(destination) => Span::raw(format!(" · <tab> → {destination}")),
+            None => Span::raw(" · <tab> switch"),
         });
     }
     if app.changes_focus.is_some() {
@@ -781,17 +780,9 @@ pub(crate) fn draw_with_worktree(
     }
     footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
     footer_spans.push(Span::raw(" · "));
-    footer_spans.extend(shortcut(
-        if app.show_commit {
-            "close message"
-        } else {
-            "open message"
-        },
-        'o',
-        app.show_commit,
-    ));
+    footer_spans.extend(shortcut("message", 'm', app.show_commit));
     footer_spans.push(Span::raw(" · "));
-    footer_spans.extend(shortcut("cycle changes", 'c', app.changes_mode.is_some()));
+    footer_spans.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
     let mut view_prefix_spans = Vec::new();
     if app.history_display_expanded {
         view_prefix_spans.push(Span::raw(" · "));
@@ -835,22 +826,24 @@ pub(crate) fn draw_with_worktree(
     let mut ordered = vec![Span::raw(history_position(app))];
     ordered.append(&mut view_prefix_spans);
     ordered.append(&mut edit_prefix_spans);
+    ordered.push(Span::raw(" · "));
+    ordered.extend(if app.preview_author_copy {
+        shortcut("copY author", 'Y', true)
+    } else {
+        shortcut("copy", 'y', true)
+    });
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
+    footer_spans.push(Span::raw(" · "));
     if app.preview_author_copy && app.manual_refresh {
-        footer_spans.push(Span::raw(" · "));
         footer_spans.extend(shortcut(
             "Refresh",
             'R',
             matches!(history_state, State::Complete | State::Cancelled),
         ));
-    }
-    footer_spans.push(Span::raw(" · "));
-    footer_spans.extend(if app.preview_author_copy {
-        shortcut("copY author", 'Y', true)
     } else {
-        shortcut("copy", 'y', true)
-    });
+        footer_spans.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
+    }
     if app.signature_failures > 0 {
         footer_spans.extend([
             Span::raw(format!(" · s {} ", app.signature_failures)),
@@ -864,16 +857,14 @@ pub(crate) fn draw_with_worktree(
             Span::styled("●", color(Color::Green)),
         ]);
     }
-    if app.changes_focus.is_none() {
-        if history_state == State::Loading {
-            footer_spans.push(Span::raw(" · Esc cancel"));
-        }
-        footer_spans.push(Span::raw(" · "));
-        footer_spans.extend(shortcut("quit", 'q', true));
+    if app.changes_focus.is_none() && history_state == State::Loading {
+        footer_spans.push(Span::raw(" · Esc cancel"));
     }
     footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · <enter> diff"));
+        footer_spans.push(Span::raw(" · "));
+        footer_spans.extend(shortcut("quit", 'q', true));
     }
     if let Some(message) = app.message() {
         footer_spans = vec![Span::raw(message)];
@@ -1911,7 +1902,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · view · edit · computing"),
+            computing.contains("1 commits · view · edit · copy") && computing.contains("computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -2397,7 +2388,8 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text = "#1 · view · edit · [ align · open message · cycle changes · copy · quit · ↑↓/jk move · h/l pan · <enter> diff";
+        let footer_text =
+            "#1 · view · edit · copy · [ align · message · changes · refs · ↑↓/jk move · h/l pan · <enter> diff · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2421,18 +2413,19 @@ mod tests {
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
-        let message = footer_text[..footer_text.find("open message").expect("the message toggle is present")]
+        let message = footer_text[..footer_text.find("message").expect("the message toggle is present")]
             .chars()
             .count();
-        for x in message..message + "open message".len() {
+        for x in message..message + "message".len() {
             expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
         }
         for (label, key) in [
             ("view", 'v'),
             ("edit", 'e'),
-            ("open message", 'o'),
-            ("cycle changes", 'c'),
             ("copy", 'y'),
+            ("message", 'm'),
+            ("changes", 'c'),
+            ("refs", 'r'),
             ("quit", 'q'),
         ] {
             let label_start = footer_text[..footer_text.find(label).expect("shortcut label is present")]
@@ -2542,7 +2535,7 @@ mod tests {
             "the restored name mode is not dimmed"
         );
 
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(!rendered_row(&terminal).contains("HEAD"), "no refs hides regular refs");
         assert!(
@@ -2555,7 +2548,7 @@ mod tests {
         );
         assert!(footer_is_dim(&terminal, "no refs"), "no refs is dimmed");
 
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             !rendered_row(&terminal).contains("HEAD"),
@@ -2567,7 +2560,7 @@ mod tests {
         );
         assert!(!footer_is_dim(&terminal, "all refs"), "all refs is not dimmed");
 
-        app.update(Action::ToggleRefs);
+        app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             !rendered_row(&terminal).contains("HEAD"),
@@ -2686,7 +2679,7 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "view (date · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · [ align")),
+            footer.starts_with(&format!("0 commits · {view} · copy · [ align")),
             "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
@@ -2703,7 +2696,7 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · [ align"),
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · [ align"),
             "the edit prefix follows the view prefix even when no action is available"
         );
         Ok(())
@@ -3185,10 +3178,7 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(
-            footer_is_dim(&terminal, "open message"),
-            "the closed commit pane is dimmed"
-        );
+        assert!(footer_is_dim(&terminal, "message"), "the closed commit pane is dimmed");
 
         app.update(Action::ToggleCommit);
         terminal.draw(|frame| {
@@ -3232,7 +3222,7 @@ mod tests {
             "the commit body remains separated from its title"
         );
         assert!(
-            !footer_is_dim(&terminal, "close message"),
+            !footer_is_dim(&terminal, "message"),
             "the open commit pane is not dimmed"
         );
 
@@ -3612,7 +3602,7 @@ mod tests {
             Color::Reset,
             "the main status keeps its original background"
         );
-        assert!(rendered_line(&terminal, 15).contains("Tab switch"));
+        assert!(rendered_line(&terminal, 15).contains("<tab> switch"));
 
         app.changes_suppressed = true;
         terminal.draw(|frame| {
@@ -3630,7 +3620,7 @@ mod tests {
             "repeated history navigation temporarily hides the changes pane"
         );
         assert!(
-            app.changes_mode.is_some() && !footer_is_dim(&terminal, "cycle changes"),
+            app.changes_mode.is_some() && !footer_is_dim(&terminal, "changes"),
             "temporary suppression leaves the persistent changes setting enabled"
         );
         app.changes_suppressed = false;
@@ -3665,7 +3655,7 @@ mod tests {
                 && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
             "the inactive history is dimmed without dimming the main status"
         );
-        assert!(rendered_line(&terminal, 15).contains("Tab → tree changes"));
+        assert!(rendered_line(&terminal, 15).contains("<tab> → tree changes"));
         assert!(rendered_line(&terminal, 15).contains("q/Esc history"));
         terminal.draw(|frame| {
             super::draw(
@@ -3678,7 +3668,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 15).contains("Tab switch"),
+            rendered_line(&terminal, 15).contains("<tab> switch"),
             "focus feedback lasts for one redraw"
         );
         assert!(

From 94cb7213a466975818842945ffe1a43fcb6984a2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 17:51:59 +0200
Subject: [PATCH 072/282] fix: retain tix selection across commit rewrites

Carry the successor ID returned by reword, create, split, amend, spill, and time-travel operations through the asynchronous history refresh instead of selecting the newest row.

Follow external rewrites when the selected commit is HEAD or a stable reference such as a StGit patch ref moves to its successor. Preserve the prior commit ID for ordinary refreshes and fall back only when no successor remains visible.

Document the selection identity rules and cover edit, HEAD, and reference-based successor tracking.
---
 gix-tix/spec.md    |  7 +++--
 gix-tix/src/app.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs | 58 ++++++++++++++++++++++++++---------
 3 files changed, 122 insertions(+), 19 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 737902854cd..1fd076d6a90 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -441,8 +441,11 @@ space first; changes blocks adapt within the remaining history width.
   malformed or inaccessible ordinary refs remain errors.
 - Ref changes that affect view or hidden tips trigger an incremental history
   refresh. Decoration-only changes avoid traversal. Filesystem-driven traversal
-  changes, manual refresh, and display toggles preserve selection by commit ID
-  when possible and otherwise select the first selectable row.
+  changes, manual refresh, and display toggles preserve selection by commit ID.
+  Edits retain the selection on the successor ID returned by the rewrite. A
+  selected worktree HEAD or other moving reference follows its changed target,
+  covering external branch and StGit patch rewrites. If none remains visible,
+  selection falls back to the first selectable row.
 - The worktree watcher exists only while the combined worktree block is enabled.
   It observes the index and ignore-aware directories that Git status would walk,
   using non-recursive registrations so ignored build trees do not generate work.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index e70eed1ff4d..fed7b070597 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -385,6 +385,7 @@ pub(crate) struct App {
     follow_tail: bool,
     reload_selection: Option<ObjectId>,
     pending_initial_selection: Option<ObjectId>,
+    selection_after_refresh: Option<ObjectId>,
     worktree_head: Option<ObjectId>,
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
@@ -465,6 +466,7 @@ impl App {
             follow_tail: false,
             reload_selection: None,
             pending_initial_selection: None,
+            selection_after_refresh: None,
             worktree_head: None,
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
@@ -495,6 +497,12 @@ impl App {
     }
 
     pub(crate) fn set_worktree_head(&mut self, head: Option<ObjectId>, select_on_load: bool) {
+        if !select_on_load
+            && self.worktree_head != head
+            && self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) == self.worktree_head
+        {
+            self.selection_after_refresh = head;
+        }
         self.worktree_head = head;
         self.pending_initial_selection = select_on_load.then_some(head).flatten();
         self.update_worktree_head_descendants();
@@ -1055,9 +1063,14 @@ impl App {
         if self.state != State::Computing {
             return;
         }
-        let selected = (!std::mem::take(&mut self.select_top_after_refresh))
-            .then(|| self.selected.map(|index| self.rows[index].id))
-            .flatten();
+        let selected = if std::mem::take(&mut self.select_top_after_refresh) {
+            self.selection_after_refresh = None;
+            None
+        } else {
+            self.selection_after_refresh
+                .take()
+                .or_else(|| self.selected.map(|index| self.rows[index].id))
+        };
         let metadata: HashMap<_, _> = if rows.iter().any(|row| !row.metadata_loaded) {
             self.rows
                 .iter()
@@ -1137,6 +1150,7 @@ impl App {
         self.reset_changes_view();
         self.follow_tail = false;
         self.pending_initial_selection = None;
+        self.selection_after_refresh = None;
         self.update_worktree_head_descendants();
         self.clear_preview_author_copy();
         self.signature_failures = 0;
@@ -1444,6 +1458,10 @@ impl App {
         }
     }
 
+    pub(crate) fn select_commit_after_refresh(&mut self, id: ObjectId) {
+        self.selection_after_refresh = Some(id);
+    }
+
     pub(crate) fn time_travel_shortcut_visible(&self) -> bool {
         self.worktree_changes_available
             && self.changes_focus.is_none()
@@ -2115,6 +2133,58 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_selects_the_rewritten_successor() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        app.update(Action::MoveDown);
+        app.select_commit_after_refresh(id(4));
+
+        let rows = app
+            .start_refresh(
+                vec![row_with_parents(5, &[4]), row_with_parents(4, &[1])].into(),
+                &[id(5)],
+                &[],
+                false,
+            )
+            .expect("a rewritten stack computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(4)),
+            "selection follows the successor supplied by the edit"
+        );
+    }
+
+    #[test]
+    fn selected_head_follows_an_external_rewrite() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        app.set_worktree_head(Some(id(3)), false);
+        complete(&mut app);
+        app.set_worktree_head(Some(id(5)), false);
+
+        let rows = app
+            .start_refresh(
+                vec![row_with_parents(5, &[4]), row_with_parents(4, &[1])].into(),
+                &[id(5)],
+                &[],
+                false,
+            )
+            .expect("an externally rewritten stack computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(5)),
+            "the selected HEAD follows its new target"
+        );
+    }
+
     #[test]
     fn completed_non_merge_stacks_can_be_reworded_from_any_row() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c4e276790f4..d004e84375d 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -934,8 +934,6 @@ fn event_loop(
     let mut refresh_pending = false;
     let mut refresh_from_filesystem = false;
     let mut ref_refresh_deadline: Option<Instant> = None;
-    let mut refresh_select_top = false;
-    let mut refresh_select_top_requested = false;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
     let mut commit_message = None;
@@ -1280,12 +1278,19 @@ fn event_loop(
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "history-refresh-completed");
                     filesystem_responses.queue_frame(&response_ids, "history-refresh-completed");
+                    let decorated_successor = app
+                        .selected
+                        .and_then(|index| app.rows.get(index))
+                        .and_then(|row| decoration_successor(row.id, &decorations, &result.decorations));
                     app.set_worktree_head(
                         (!repository_is_bare)
                             .then(|| decoration_head(&result.decorations))
                             .flatten(),
                         false,
                     );
+                    if let Some(successor) = decorated_successor {
+                        app.select_commit_after_refresh(successor);
+                    }
                     worktree_head_unborn = !repository_is_bare
                         && open_repository(&repository_path, false, false)
                             .and_then(|repo| Ok(repo.head()?.is_unborn()))
@@ -1299,12 +1304,7 @@ fn event_loop(
                     } else {
                         result.refs.hidden_tips.as_slice()
                     };
-                    if let Some(rows) = app.start_refresh(
-                        result.commits,
-                        &result.refs.view_tips,
-                        hidden_tips,
-                        std::mem::take(&mut refresh_select_top),
-                    ) {
+                    if let Some(rows) = app.start_refresh(result.commits, &result.refs.view_tips, hidden_tips, false) {
                         lane_receiver = Some(start_lane_worker(rows));
                     }
                     refresh_receiver = None;
@@ -1343,7 +1343,6 @@ fn event_loop(
                 hidden_changed,
                 "compared reference snapshot"
             );
-            let select_top = std::mem::take(&mut refresh_select_top_requested);
             ref_snapshot = next;
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
@@ -1364,13 +1363,12 @@ fn event_loop(
                     .take()
                     .expect("refresh starts only with a cached history graph"),
             ));
-            refresh_select_top = select_top;
             refresh_expand_hidden = false;
             app.deferred_history_state = Some(app.state);
             history_status_deadline = Some(refresh_started + HISTORY_STATUS_DELAY);
             app.state = State::Loading;
             filesystem_responses.phase(&response_ids, "history-refresh-started");
-            tracing::info!(?response_ids, select_top, "started history refresh");
+            tracing::info!(?response_ids, "started history refresh");
         }
         let now = Instant::now();
         if motion.timeout(now) == Some(Duration::ZERO)
@@ -1749,7 +1747,7 @@ fn event_loop(
                                 id.to_hex_with_len(7),
                                 new_id.to_hex_with_len(7)
                             ));
-                            refresh_select_top_requested = true;
+                            app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(None) => {}
@@ -1773,7 +1771,7 @@ fn event_loop(
                     match result {
                         Ok(Some(new_id)) => {
                             app.leave_message(format!("created {}", new_id.to_hex_with_len(7)));
-                            refresh_select_top_requested = true;
+                            app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(None) => app.leave_message("no commit created: no input was provided"),
@@ -1797,7 +1795,7 @@ fn event_loop(
                                 new_id.to_hex_with_len(7)
                             ));
                             invalidate_worktree_changes(&mut worktree_changes);
-                            refresh_select_top_requested = true;
+                            app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(None) => app.leave_message("no split performed: no input was provided"),
@@ -1854,6 +1852,7 @@ fn event_loop(
                                 new_id.to_hex_with_len(7)
                             ));
                             invalidate_worktree_changes(&mut worktree_changes);
+                            app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(None) => app.leave_message(format!("nothing to {verb}")),
@@ -1899,6 +1898,11 @@ fn event_loop(
                         Ok(Some(notice)) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
                             app.leave_message(notice);
+                            if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
+                                .and_then(|repo| Ok(repo.head_id()?.detach()))
+                            {
+                                app.select_commit_after_refresh(head);
+                            }
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
@@ -2172,6 +2176,18 @@ fn decoration_head(decorations: &Decorations) -> Option<gix::ObjectId> {
     })
 }
 
+fn decoration_successor(selected: gix::ObjectId, current: &Decorations, next: &Decorations) -> Option<gix::ObjectId> {
+    let selected = current.get(&selected)?;
+    let mut matches = next.iter().filter_map(|(id, decorations)| {
+        decorations
+            .iter()
+            .any(|decoration| selected.contains(decoration))
+            .then_some(*id)
+    });
+    let successor = matches.next()?;
+    matches.all(|candidate| candidate == successor).then_some(successor)
+}
+
 fn update_hidden_branch_behind(app: &mut App, graph: Option<&HistoryGraph>, refs: &history::RefSnapshot) {
     let markers = graph.map_or_else(HashMap::new, |graph| {
         graph.hidden_branch_behind(
@@ -3772,6 +3788,20 @@ mod tests {
         assert!(!unseen_filesystem_redraw(true, true, true));
     }
 
+    #[test]
+    fn follows_a_reference_across_a_rewrite() {
+        let old = gix::ObjectId::Sha1([1; 20]);
+        let new = gix::ObjectId::Sha1([2; 20]);
+        let decoration = history::Decoration {
+            name: "refs/patches/topic/selected".into(),
+            kind: history::DecorationKind::Special,
+        };
+        let current = Decorations::from([(old, vec![decoration.clone()])]);
+        let next = Decorations::from([(new, vec![decoration])]);
+
+        assert_eq!(decoration_successor(old, &current, &next), Some(new));
+    }
+
     #[test]
     fn reference_watcher_observes_new_loose_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;

From 1f39ff5a840ffce593d6afa1532ed12fb31422ec Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 19:57:39 +0200
Subject: [PATCH 073/282] feat: resume conflicting lazy rebases in tix

Keep all history edits lazy and suspend unresolved time-travel cherry-picks in memory. Let the user materialize the prepared conflict for normal index-based resolution, while preventing further time travel until the index is resolved.
---
 gix-tix/AGENTS.md                             |   2 +-
 gix-tix/spec.md                               |  35 +-
 gix-tix/src/app.rs                            |  50 +++
 gix-tix/src/edit/create.rs                    |  14 +-
 gix-tix/src/edit/forget.rs                    |  15 +-
 gix-tix/src/edit/head.rs                      |   3 +-
 gix-tix/src/edit/rebase.rs                    | 326 ++++++++++++++----
 gix-tix/src/edit/reword.rs                    |   5 +-
 ...sts__accepted-pending-rebase-conflict.snap |  55 +++
 gix-tix/src/edit/split.rs                     |   3 +-
 gix-tix/src/edit/time_travel.rs               | 228 +++++++++++-
 gix-tix/src/lib.rs                            |  56 ++-
 gix-tix/src/ui.rs                             |  62 +++-
 13 files changed, 720 insertions(+), 134 deletions(-)
 create mode 100644 gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index c6f6856879b..769df6a9b68 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -19,7 +19,7 @@
   the original worktree directory and process CWD may no longer exist; recover
   to the normalized common repository before processing watchers, loading view
   data, or drawing.
-- Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle.
+- Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle. The sole exception is an unresolved in-memory rebase result awaiting the user's immediate accept-or-cancel key; dropping it must leave no observable repository state.
 - Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
 - The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
 - Filesystem watchers retain paths and native watcher handles, never repositories.
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1fd076d6a90..b656f6d90ae 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -340,7 +340,7 @@ space first; changes blocks adapt within the remaining history width.
   title, a `why` body, optional attribution trailers, and a commented Git-style
   per-path diffstat with signed net line counts. Commit hooks are not run.
 - After editing, tix revalidates the destination, applies configured signing,
-  rebases linear descendants, persists the prepared objects, and atomically
+  marks linear descendants for lazy replay, persists the prepared objects, and atomically
   advances mutable refs throughout the rewritten stack. This includes local
   branches, custom refs, direct tix pins, and a detached `HEAD`, while excluding
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
@@ -372,9 +372,16 @@ space first; changes blocks adapt within the remaining history width.
   use a bright-cyan commit marker.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
-- Time travel from either endpoint of a pending region completes the entire
-  marked rebase with cherry-picking and configured signing before checkout. A
-  conflict aborts before refs or worktrees change.
+- Time travel from either endpoint of a pending region completes the marked
+  rebase with cherry-picking and configured signing before checkout. A conflict
+  retains the exact merge tree, conflict stages, prepared commits, and in-memory
+  objects without changing the repository. The conflicting row shows a blinking
+  red `C`; `<enter>` persists the prepared rebase, leaves later descendants lazy,
+  and checks out the conflict tree with an unmerged index. Any other key discards
+  the suspended operation.
+- A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
+  disables time travel until all conflict stages are resolved. The worktree
+  changes block is shown for resolution.
 
 ### Forget commits
 
@@ -382,10 +389,9 @@ space first; changes blocks adapt within the remaining history width.
   commit with no known merge descendant. The first `d` arms a
   `d again forget` confirmation; the second performs it. Navigation, refresh,
   cancellation, selection changes, and other commands disarm confirmation.
-- Forgetting does not require a worktree. Linear descendants are cherry-picked
-  onto the selected commit's parent, and mutable refs throughout the rewritten
-  stack move atomically. Empty commits only need parent rewriting. Tags and
-  remote-tracking refs remain unchanged.
+- Forgetting does not require a worktree. Linear descendants are reparented with
+  unchanged trees and marked for lazy replay; mutable refs throughout the
+  rewritten stack move atomically. Tags and remote-tracking refs remain unchanged.
 - When the selected commit is the current worktree `HEAD`, Git preflights and
   applies a two-tree index/worktree transition which discards only that commit's
   tracked delta. Conflicting staged, tracked, or untracked state refuses the
@@ -397,15 +403,16 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Transactional rebases
 
-- Reword, new-commit, and forget edits share one in-memory rebase primitive.
+- All edits share one in-memory rebase primitive.
   Forks are preserved, descendant merges are rejected, and all commit/tree
   preparation—including cherry-pick conflict detection—finishes before objects
   become reachable through refs.
 - `Tree::LeaveAsIs` rewrites parentage without changing trees;
   `LeaveAsIsAndMark` additionally writes `tix-rebase: pending`; and `CherryPick`
-  transplants each tree delta, aborting the entire edit on unresolved conflicts.
-  A marked operation can be repeated from its marked base and clears all markers
-  after a successful cherry-pick.
+  transplants each tree delta. User edits use `LeaveAsIsAndMark`; time travel is
+  the only eager `CherryPick` caller. A successful repeated rebase clears its
+  markers. On conflict, the existing `tix-rebase-parent` identifies the original
+  base and later descendants remain marked instead of being cherry-picked.
 - `Signature::RedoIfNeeded` signs every rewritten commit when signing is
   configured and otherwise removes stale signature headers.
   `InvalidateExisting` empties existing signature values when signing is
@@ -416,6 +423,10 @@ space first; changes blocks adapt within the remaining history width.
   one compare-and-swap transaction. A checkout failure rolls back already-applied
   worktree transitions and the ref transaction; newly written unreachable objects
   may remain for normal Git garbage collection.
+- A suspended conflict temporarily owns a cloned repository with object memory
+  while awaiting one confirmation key. Dropping it writes nothing; accepting it
+  consumes the repository immediately after persisting and checking out the
+  retained merge result.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index fed7b070597..53e77977b6f 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -389,6 +389,8 @@ pub(crate) struct App {
     worktree_head: Option<ObjectId>,
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
+    pending_rebase_conflict: Option<ObjectId>,
+    worktree_conflicted: bool,
     amend_available: bool,
     spill_available: bool,
     split_available: bool,
@@ -470,6 +472,8 @@ impl App {
             worktree_head: None,
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
+            pending_rebase_conflict: None,
+            worktree_conflicted: false,
             amend_available: false,
             spill_available: false,
             split_available: false,
@@ -512,6 +516,31 @@ impl App {
         self.worktree_head_unborn = unborn;
     }
 
+    pub(crate) fn arm_rebase_conflict(&mut self, id: ObjectId) {
+        self.pending_rebase_conflict = Some(id);
+        self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
+    }
+
+    pub(crate) fn clear_rebase_conflict(&mut self) {
+        self.pending_rebase_conflict = None;
+        self.message = None;
+    }
+
+    pub(crate) fn begin_conflict_resolution(&mut self) {
+        self.pending_rebase_conflict = None;
+        self.worktree_conflicted = true;
+        self.changes_mode = Some(ChangesMode::Both);
+        self.changes_focus = None;
+    }
+
+    pub(crate) fn set_worktree_conflicted(&mut self, conflicted: bool) {
+        self.worktree_conflicted = conflicted;
+    }
+
+    pub(crate) fn conflict_marker(&self, id: ObjectId, head: bool) -> bool {
+        self.pending_rebase_conflict == Some(id) || (head && self.worktree_conflicted)
+    }
+
     pub(crate) fn set_known_descendants(&mut self, ids: HashSet<ObjectId>) {
         self.known_descendants = ids;
         self.update_worktree_head_descendants();
@@ -1464,6 +1493,8 @@ impl App {
 
     pub(crate) fn time_travel_shortcut_visible(&self) -> bool {
         self.worktree_changes_available
+            && self.pending_rebase_conflict.is_none()
+            && !self.worktree_conflicted
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && self.selected.is_some()
@@ -2291,6 +2322,25 @@ mod tests {
         assert!(app.update(Action::TimeTravel).is_empty());
     }
 
+    #[test]
+    fn unresolved_conflicts_disable_time_travel() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        app.set_worktree_head(Some(id(2)), false);
+        complete(&mut app);
+        app.update(Action::MoveDown);
+        assert!(app.time_travel_shortcut_visible());
+
+        app.set_worktree_conflicted(true);
+        assert!(!app.time_travel_shortcut_visible());
+        assert!(app.update(Action::TimeTravel).is_empty());
+        app.set_worktree_conflicted(false);
+        app.arm_rebase_conflict(id(1));
+        assert!(!app.time_travel_shortcut_visible());
+        app.clear_rebase_conflict();
+        assert!(app.time_travel_shortcut_visible());
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index dacde6d9f38..b90c4d7af0a 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -199,25 +199,17 @@ pub(crate) fn apply(
 ) -> Result<ObjectId> {
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
     let commit = commit_from_edit(&prepared, edited)?;
-    let base_tree = match prepared.parent {
-        Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
-        None => repo.empty_tree().id,
-    };
-    let tree_mode = if base_tree == commit.tree {
-        rebase::Tree::LeaveAsIs
-    } else {
-        rebase::Tree::CherryPick
-    };
     rebase::perform(
-        repo,
+        &repo,
         graph,
         rebase::Edit::Insert {
             anchor: prepared.parent,
             commit,
         },
         rebase::Signature::RedoIfNeeded,
-        tree_mode,
+        rebase::Tree::LeaveAsIsAndMark,
     )?
+    .complete()?
     .selected
     .context("inserting a commit did not produce a selection")
 }
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index 9302a64cc7f..b5cc4f77df8 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -12,24 +12,15 @@ pub(crate) fn perform(
     id: ObjectId,
 ) -> Result<Option<ObjectId>> {
     let commit = repo.find_commit(id).context("could not find the commit to forget")?;
-    let parent = commit.parent_ids().next().map(gix::Id::detach);
-    let tree = commit.tree_id()?.detach();
-    let parent_tree = match parent {
-        Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
-        None => repo.empty_tree().id,
-    };
     drop(commit);
     Ok(rebase::perform(
-        repo,
+        &repo,
         graph,
         rebase::Edit::Remove { target: id },
         rebase::Signature::RedoIfNeeded,
-        if tree == parent_tree {
-            rebase::Tree::LeaveAsIs
-        } else {
-            rebase::Tree::CherryPick
-        },
+        rebase::Tree::LeaveAsIsAndMark,
     )?
+    .complete()?
     .selected)
 }
 
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index b40cfadcfe1..2630258722e 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -68,12 +68,13 @@ pub fn perform(
     }
     commit.tree = tree;
     Ok(rebase::perform(
-        repo,
+        &repo,
         graph,
         rebase::Edit::Replace { target: head, commit },
         rebase::Signature::InvalidateExisting,
         rebase::Tree::LeaveAsIsAndMark,
     )?
+    .complete()?
     .selected)
 }
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index bb65651f350..12501d55da8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -29,6 +29,7 @@ pub(crate) enum Signature {
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum Tree {
+    #[cfg_attr(not(test), allow(dead_code))]
     LeaveAsIs,
     LeaveAsIsAndMark,
     CherryPick,
@@ -67,14 +68,94 @@ impl Outcome {
     }
 }
 
+pub(crate) enum Perform {
+    Complete(Outcome),
+    Conflict(Conflict),
+}
+
+impl Perform {
+    pub(crate) fn complete(self) -> Result<Outcome> {
+        match self {
+            Perform::Complete(outcome) => Ok(outcome),
+            Perform::Conflict(_) => anyhow::bail!("an edit unexpectedly produced a merge conflict"),
+        }
+    }
+}
+
+pub(crate) struct Conflict {
+    prepared: Prepared,
+    conflicts: Vec<gix::merge::tree::Conflict>,
+    tree: ObjectId,
+    commit: ObjectId,
+    original: ObjectId,
+}
+
+impl Conflict {
+    pub(crate) fn original(&self) -> ObjectId {
+        self.original
+    }
+
+    pub(crate) fn persist(mut self) -> Result<PersistedConflict> {
+        let outcome = self.prepared.finish()?;
+        Ok(PersistedConflict {
+            repo: self.prepared.repo,
+            outcome,
+            conflicts: self.conflicts,
+            tree: self.tree,
+            commit: self.commit,
+        })
+    }
+}
+
+pub(crate) struct PersistedConflict {
+    repo: gix::Repository,
+    pub(crate) outcome: Outcome,
+    conflicts: Vec<gix::merge::tree::Conflict>,
+    tree: ObjectId,
+    pub(crate) commit: ObjectId,
+}
+
+impl PersistedConflict {
+    pub(crate) fn write_index(&mut self) -> Result<()> {
+        let mut index = self
+            .repo
+            .index_from_tree(&self.tree)
+            .context("could not prepare the conflicting index")?;
+        if !gix::merge::tree::apply_index_entries(
+            &self.conflicts,
+            gix::merge::tree::TreatAsUnresolved::git(),
+            &mut index,
+            gix::merge::tree::apply_index_entries::RemovalMode::Prune,
+        ) {
+            anyhow::bail!("could not apply conflict stages to the prepared index");
+        }
+        index.remove_tree();
+        index
+            .write(gix::index::write::Options::default())
+            .context("could not write the conflicting index")
+    }
+}
+
+struct Prepared {
+    repo: gix::Repository,
+    root: Option<ObjectId>,
+    inserted: bool,
+    marked: bool,
+    skip_worktree_transitions: bool,
+    selected: Option<ObjectId>,
+    rewritten: HashMap<ObjectId, Option<ObjectId>>,
+    committer: gix::actor::Signature,
+}
+
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
 pub(crate) fn perform(
-    mut repo: gix::Repository,
+    repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     mut tree_mode: Tree,
-) -> Result<Outcome> {
+) -> Result<Perform> {
+    let mut repo = repo.clone();
     let (root, replacement, inserted, removed, repeat, mut split_upper) = match edit {
         Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, None),
         Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false, None),
@@ -107,6 +188,7 @@ pub(crate) fn perform(
 
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
     let mut selected = None;
+    let mut conflict = None;
     if inserted {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
@@ -163,7 +245,7 @@ pub(crate) fn perform(
         }
         let original_parent = repeat.then(|| marked_parent(&commit)).transpose()?.flatten();
         let original_parents = original_parent.into_iter().collect::<Vec<_>>();
-        commit.tree = rewritten_tree(
+        let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
             if original_parents.is_empty() {
@@ -172,16 +254,42 @@ pub(crate) fn perform(
                 &original_parents
             },
             &new_parents,
-            tree_mode,
+            if conflict.is_some() {
+                Tree::LeaveAsIsAndMark
+            } else {
+                tree_mode
+            },
         )?;
+        let mut new_conflict = None;
+        commit.tree = match rewritten_tree {
+            TreeRewrite::Complete(tree) => tree,
+            TreeRewrite::Conflict { tree, conflicts } => {
+                new_conflict = Some((tree, conflicts));
+                tree
+            }
+        };
         commit.parents = new_parents.into_iter().collect();
+        let pending = tree_mode == Tree::LeaveAsIsAndMark || conflict.is_some();
         marker(
             &mut commit,
-            tree_mode == Tree::LeaveAsIsAndMark,
-            old_parents.first().copied(),
+            pending,
+            original_parent.or_else(|| old_parents.first().copied()),
         );
-        let new_id = write_commit(&repo, commit, signature, signing.clone())?;
+        let is_conflicting_commit = new_conflict.is_some();
+        let new_id = write_commit(
+            &repo,
+            commit,
+            if conflict.is_some() || is_conflicting_commit {
+                Signature::InvalidateExisting
+            } else {
+                signature
+            },
+            signing.clone(),
+        )?;
         rewritten.insert(old_id, Some(new_id));
+        if let Some((tree, conflicts)) = new_conflict {
+            conflict = Some((old_id, tree, conflicts, new_id));
+        }
         if Some(old_id) == root {
             if let Some(mut upper) = split_upper.take() {
                 upper.parents = [new_id].into_iter().collect();
@@ -195,50 +303,89 @@ pub(crate) fn perform(
         }
     }
 
-    let objects = repo
-        .objects
-        .take_object_memory()
-        .context("candidate object memory was unavailable")?;
-    for (id, (kind, data)) in objects.iter() {
-        repo.write_buf_with_known_id(*kind, data, *id)
-            .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
+    let mut prepared = Prepared {
+        repo,
+        root,
+        inserted,
+        marked: tree_mode == Tree::LeaveAsIsAndMark || conflict.is_some(),
+        skip_worktree_transitions: inserted || (tree_mode == Tree::LeaveAsIsAndMark && !removed),
+        selected,
+        rewritten,
+        committer,
+    };
+    match conflict {
+        Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
+            prepared,
+            conflicts,
+            tree,
+            commit,
+            original,
+        })),
+        None => Ok(Perform::Complete(prepared.finish()?)),
     }
+}
 
-    let transitions = worktree_transitions(&repo, &rewritten, inserted || tree_mode == Tree::LeaveAsIsAndMark)?;
-    let index_reset_from = if inserted || tree_mode == Tree::LeaveAsIsAndMark {
-        root
-    } else {
-        None
-    };
-    let index_resets = index_reset_from
-        .map(|old| index_resets(&repo, &rewritten, old))
-        .transpose()?;
-    for transition in &transitions {
-        super::forget::preflight_tree_transition(
-            &transition.repo,
-            &transition.workdir,
-            transition.old,
-            transition.new,
+impl Prepared {
+    fn finish(&mut self) -> Result<Outcome> {
+        let objects = self
+            .repo
+            .objects
+            .take_object_memory()
+            .context("candidate object memory was unavailable")?;
+        for (id, (kind, data)) in objects.iter() {
+            self.repo
+                .write_buf_with_known_id(*kind, data, *id)
+                .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
+        }
+
+        let transitions = worktree_transitions(&self.repo, &self.rewritten, self.skip_worktree_transitions)?;
+        let index_reset_from = if self.inserted || self.marked { self.root } else { None };
+        let index_resets = index_reset_from
+            .map(|old| index_resets(&self.repo, &self.rewritten, old))
+            .transpose()?;
+        for transition in &transitions {
+            super::forget::preflight_tree_transition(
+                &transition.repo,
+                &transition.workdir,
+                transition.old,
+                transition.new,
+            )?;
+        }
+        let rollback_refs = update_refs(
+            &self.repo,
+            &self.rewritten,
+            self.root.is_none(),
+            self.selected,
+            &self.committer,
         )?;
-    }
-    let rollback_refs = update_refs(&repo, &rewritten, root.is_none(), selected, &committer)?;
-    for (transitioned, transition) in transitions.iter().enumerate() {
-        if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new) {
-            return rollback(&repo, &committer, &transitions[..transitioned], &rollback_refs, err);
+        for (transitioned, transition) in transitions.iter().enumerate() {
+            if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
+            {
+                return rollback(
+                    &self.repo,
+                    &self.committer,
+                    &transitions[..transitioned],
+                    &rollback_refs,
+                    err,
+                );
+            }
         }
-    }
-    let index_resets = index_resets.unwrap_or_default();
-    for (index, reset) in index_resets.iter().enumerate() {
-        if let Err(mut err) = reset_index(&reset.workdir, reset.new) {
-            for applied in index_resets[..=index].iter().rev() {
-                if let Err(restore) = std::fs::write(&applied.index, &applied.before) {
-                    err = err.context(format!("index rollback failed: {restore}"));
+        let index_resets = index_resets.unwrap_or_default();
+        for (index, reset) in index_resets.iter().enumerate() {
+            if let Err(mut err) = reset_index(&reset.workdir, reset.new) {
+                for applied in index_resets[..=index].iter().rev() {
+                    if let Err(restore) = std::fs::write(&applied.index, &applied.before) {
+                        err = err.context(format!("index rollback failed: {restore}"));
+                    }
                 }
+                return rollback(&self.repo, &self.committer, &transitions, &rollback_refs, err);
             }
-            return rollback(&repo, &committer, &transitions, &rollback_refs, err);
         }
+        Ok(Outcome {
+            selected: self.selected,
+            rewritten: std::mem::take(&mut self.rewritten),
+        })
     }
-    Ok(Outcome { selected, rewritten })
 }
 
 fn rollback<T>(
@@ -363,25 +510,33 @@ fn validate(
     Ok(())
 }
 
+enum TreeRewrite {
+    Complete(ObjectId),
+    Conflict {
+        tree: ObjectId,
+        conflicts: Vec<gix::merge::tree::Conflict>,
+    },
+}
+
 fn rewritten_tree(
     repo: &gix::Repository,
     commit: &gix::objs::Commit,
     old_parents: &[ObjectId],
     new_parents: &[ObjectId],
     mode: Tree,
-) -> Result<ObjectId> {
+) -> Result<TreeRewrite> {
     if mode != Tree::CherryPick || old_parents == new_parents {
-        return Ok(commit.tree);
+        return Ok(TreeRewrite::Complete(commit.tree));
     }
     let old_base = parent_tree(repo, old_parents.first().copied())?;
     let new_base = parent_tree(repo, new_parents.first().copied())?;
     if commit.tree == old_base {
-        return Ok(new_base);
+        return Ok(TreeRewrite::Complete(new_base));
     }
     if old_base == new_base {
-        return Ok(commit.tree);
+        return Ok(TreeRewrite::Complete(commit.tree));
     }
-    cherry_pick_tree(repo, old_base, new_base, commit.tree)
+    cherry_pick_tree_outcome(repo, old_base, new_base, commit.tree)
 }
 
 pub(super) fn cherry_pick_tree(
@@ -390,11 +545,23 @@ pub(super) fn cherry_pick_tree(
     new_base: ObjectId,
     tree: ObjectId,
 ) -> Result<ObjectId> {
+    match cherry_pick_tree_outcome(repo, old_base, new_base, tree)? {
+        TreeRewrite::Complete(tree) => Ok(tree),
+        TreeRewrite::Conflict { .. } => anyhow::bail!("rebasing would cause a merge conflict"),
+    }
+}
+
+fn cherry_pick_tree_outcome(
+    repo: &gix::Repository,
+    old_base: ObjectId,
+    new_base: ObjectId,
+    tree: ObjectId,
+) -> Result<TreeRewrite> {
     if tree == old_base {
-        return Ok(new_base);
+        return Ok(TreeRewrite::Complete(new_base));
     }
     if old_base == new_base {
-        return Ok(tree);
+        return Ok(TreeRewrite::Complete(tree));
     }
     let labels = gix::merge::blob::builtin_driver::text::Labels {
         ancestor: Some(BStr::new(b"parent")),
@@ -404,14 +571,20 @@ pub(super) fn cherry_pick_tree(
     let mut outcome = repo
         .merge_trees(old_base, new_base, tree, labels, repo.tree_merge_options()?)
         .context("could not cherry-pick a descendant tree")?;
-    if outcome.has_unresolved_conflicts(gix::merge::tree::TreatAsUnresolved::git()) {
-        anyhow::bail!("rebasing would cause a merge conflict");
-    }
-    Ok(outcome
+    let unresolved = outcome.has_unresolved_conflicts(gix::merge::tree::TreatAsUnresolved::git());
+    let tree = outcome
         .tree
         .write()
         .context("could not prepare a rebased tree")?
-        .detach())
+        .detach();
+    if unresolved {
+        Ok(TreeRewrite::Conflict {
+            tree,
+            conflicts: outcome.conflicts,
+        })
+    } else {
+        Ok(TreeRewrite::Complete(tree))
+    }
 }
 
 fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<ObjectId> {
@@ -707,12 +880,13 @@ mod tests {
         commit.message = "rewritten middle".into();
 
         let outcome = perform(
-            repo.clone(),
+            &repo,
             &graph,
             Edit::Replace { target: middle, commit },
             Signature::RedoIfNeeded,
             Tree::LeaveAsIs,
-        )?;
+        )?
+        .complete()?;
         let new_middle = outcome.selected.expect("replacement selects the rewritten commit");
         let new_tip = repo.head_id()?.detach();
         assert_ne!(new_tip, old_tip, "the descendant is rewritten");
@@ -743,12 +917,13 @@ mod tests {
         let old_tip_tree = repo.find_commit(repo.head_id()?)?.tree_id()?.detach();
 
         let outcome = perform(
-            repo.clone(),
+            &repo,
             &graph,
             Edit::Remove { target: middle },
             Signature::RedoIfNeeded,
             Tree::CherryPick,
-        )?;
+        )?
+        .complete()?;
         assert_eq!(outcome.selected, Some(base), "removal selects its parent");
         let tip = repo.head_id()?.detach();
         assert_eq!(
@@ -773,23 +948,25 @@ mod tests {
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
         commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~2")?)?.tree_id()?.detach();
         let marked = perform(
-            repo.clone(),
+            &repo,
             &graph,
             Edit::Replace { target: middle, commit },
             Signature::InvalidateExisting,
             Tree::LeaveAsIsAndMark,
         )?
+        .complete()?
         .selected
         .expect("marking rewrites the selected commit");
 
         let graph = super::super::loaded_graph(&repo)?;
         perform(
-            repo.clone(),
+            &repo,
             &graph,
             Edit::Repeat { base: marked },
             Signature::RedoIfNeeded,
             Tree::CherryPick,
-        )?;
+        )?
+        .complete()?;
         let mut id = Some(repo.head_id()?.detach());
         while let Some(current) = id {
             let commit = repo.find_commit(current)?.decode()?.into_owned()?;
@@ -848,12 +1025,13 @@ mod tests {
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
         commit.message = "fork point".into();
         let rewritten_middle = perform(
-            repo.clone(),
+            &repo,
             &graph,
             Edit::Replace { target: middle, commit },
             Signature::RedoIfNeeded,
             Tree::LeaveAsIs,
         )?
+        .complete()?
         .selected
         .expect("the fork point is rewritten");
 
@@ -884,17 +1062,17 @@ mod tests {
             .output()?
             .stdout;
 
-        assert!(
-            perform(
-                repo,
-                &graph,
-                Edit::Remove { target: middle },
-                Signature::RedoIfNeeded,
-                Tree::CherryPick,
-            )
-            .is_err(),
-            "an unresolved cherry-pick aborts the complete rebase"
-        );
+        let Perform::Conflict(conflict) = perform(
+            &repo,
+            &graph,
+            Edit::Remove { target: middle },
+            Signature::RedoIfNeeded,
+            Tree::CherryPick,
+        )?
+        else {
+            return Err("the unresolved cherry-pick should suspend the complete rebase".into());
+        };
+        drop(conflict);
         assert_eq!(
             gix_testtools::repository::snapshot(fixture.path())?,
             before,
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index ff1c050c4b7..95a73a0360f 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -91,12 +91,13 @@ pub(crate) fn apply(
     commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
     commit.message = edit.message;
     let outcome = rebase::perform(
-        repo,
+        &repo,
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
-    )?;
+    )?
+    .complete()?;
     Ok(outcome.selected.filter(|new_id| *new_id != old_id))
 }
 
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
new file mode 100644
index 00000000000..30e04dfef37
--- /dev/null
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -0,0 +1,55 @@
+---
+source: gix-tix/src/edit/time_travel.rs
+expression: "gix_testtools::repository::snapshot(fixture.path())?\n.to_string().replace(\"\\n  \\n\", \"\\n\\n\")"
+---
+HEAD detached C1
+
+[refs]
+refs/heads/main = C2
+refs/tix/pins/6a06a74d = -> refs/heads/main
+
+[commits]
+C0
+  tree T1
+  author author <author@example.com> 946684800 +0000
+  committer committer <committer@example.com> 946684800 +0000
+
+  base
+
+C1
+  tree T0
+  parent C0
+  author author <author@example.com> 946684800 +0000
+  committer author <author@example.com> 978307200 +0000
+
+  tip
+
+C2
+  tree T2
+  parent C1
+  author author <author@example.com> 946944000 +0000
+  committer author <author@example.com> 978307200 +0000
+  tix-rebase pending
+  tix-rebase-parent 76ca9987dd431a8b8be20a52aeed5066cd1058fe
+
+  after
+
+[index]
+tree = conflicted
+100644 B2 stage=1 "file"
+100644 B1 stage=2 "file"
+100644 B0 stage=3 "file"
+
+[worktree]
+100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
+
+[objects]
+T0 = 0f42ecffc297189265600788215c8b0055d862b8
+C1 = 54b039307b71caeb5f620a9ad9c965d10db1f598
+C2 = 6a06a74d441ff8640e0951400beff9498ded5814
+T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+T2 = 6f2762b571ef9a93001cc607058818aa5d0d055c
+B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
+C0 = c0b811a58f27425263a4276fe881de38736a9446
+B1 = df967b96a579e45a18b8251732d16804b2e56a55
+B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index d0d5340e670..5f844f22000 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -78,7 +78,7 @@ pub(crate) fn apply(
     let mut upper = create::commit_from_edit(&prepared.create, edited)?;
     upper.tree = prepared.tree;
     rebase::perform(
-        repo,
+        &repo,
         graph,
         rebase::Edit::Split {
             target: prepared.target,
@@ -88,6 +88,7 @@ pub(crate) fn apply(
         rebase::Signature::InvalidateExisting,
         rebase::Tree::LeaveAsIsAndMark,
     )?
+    .complete()?
     .selected
     .context("splitting HEAD did not produce a selection")
 }
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index cf01542466f..6de6b0c172b 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -1,4 +1,8 @@
-use std::{ffi::OsString, path::Path, process::Command};
+use std::{
+    ffi::OsString,
+    path::{Path, PathBuf},
+    process::Command,
+};
 
 use anyhow::{Context, Result};
 use gix::{
@@ -12,6 +16,74 @@ use gix::{
 
 use crate::{history, open_repository};
 
+pub(crate) enum Perform {
+    Complete(Option<String>),
+    Conflict(Conflict),
+}
+
+impl Perform {
+    #[cfg(test)]
+    fn complete(self) -> Result<Option<String>> {
+        match self {
+            Perform::Complete(notice) => Ok(notice),
+            Perform::Conflict(_) => anyhow::bail!("time-travel unexpectedly suspended on a conflict"),
+        }
+    }
+}
+
+pub(crate) struct Conflict {
+    rebase: super::rebase::Conflict,
+    repository_path: PathBuf,
+    bare: bool,
+    workdir: PathBuf,
+    saved_target: Target,
+    head: ObjectId,
+}
+
+impl Conflict {
+    pub(crate) fn original(&self) -> ObjectId {
+        self.rebase.original()
+    }
+
+    #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
+    pub(crate) fn accept(self) -> Result<(String, ObjectId)> {
+        let mut conflict = self.rebase.persist()?;
+        let head = conflict
+            .outcome
+            .map(self.head)
+            .context("HEAD disappeared while preparing conflict resolution")?;
+        let repository = open_repository(&self.repository_path, self.bare, false)
+            .context("could not reopen repository before conflict checkout")?;
+        let provisional = contains(&repository, conflict.commit, head)
+            .then(|| create_or_reuse_pin(&repository, self.saved_target, head))
+            .transpose()?;
+        drop(repository);
+        if let Err(checkout) = checkout_detached(&self.workdir, conflict.commit) {
+            if let Some((pin, true)) = &provisional {
+                let cleanup = open_repository(&self.repository_path, self.bare, false)
+                    .context("could not reopen repository to remove a provisional pin")
+                    .and_then(|repository| delete_pin(&repository, pin));
+                if let Err(cleanup) = cleanup {
+                    return Err(checkout.context(format!(
+                        "checkout failed and {} could not be removed: {cleanup:#}",
+                        pin_label(pin)
+                    )));
+                }
+            }
+            return Err(checkout);
+        }
+        conflict.write_index()?;
+        let mut notice = format!(
+            "checked out conflicting {} for resolution",
+            conflict.commit.to_hex_with_len(7)
+        );
+        if let Some((pin, true)) = provisional {
+            notice = format!("{notice}; saved {}", pin_label(&pin));
+        }
+        Ok((notice, conflict.commit))
+    }
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %selected))]
 pub(crate) fn perform(
     repository_path: &Path,
@@ -20,7 +92,7 @@ pub(crate) fn perform(
     graph: &history::HistoryGraph,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<Option<String>> {
+) -> Result<Perform> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
     let workdir = repository
@@ -33,15 +105,37 @@ pub(crate) fn perform(
     };
     let head_referent = head.referent_name().map(ToOwned::to_owned);
     drop(head);
+    if repository
+        .index_or_empty()
+        .context("could not inspect the index before time-travel")?
+        .entries()
+        .iter()
+        .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+    {
+        anyhow::bail!("cannot time-travel with unresolved index conflicts");
+    }
     let mut completed_graph = None;
     while let Some(base) = pending_base(&repository, head_id, selected)? {
         let outcome = super::rebase::perform(
-            repository,
+            &repository,
             completed_graph.as_ref().unwrap_or(graph),
             super::rebase::Edit::Repeat { base },
             super::rebase::Signature::RedoIfNeeded,
             super::rebase::Tree::CherryPick,
         )?;
+        let outcome = match outcome {
+            super::rebase::Perform::Complete(outcome) => outcome,
+            super::rebase::Perform::Conflict(rebase) => {
+                return Ok(Perform::Conflict(Conflict {
+                    rebase,
+                    repository_path: repository_path.to_owned(),
+                    bare,
+                    workdir,
+                    saved_target: head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id)),
+                    head: head_id,
+                }));
+            }
+        };
         selected = outcome
             .map(selected)
             .context("the time-travel destination disappeared while completing its rebase")?;
@@ -54,17 +148,17 @@ pub(crate) fn perform(
     }
     let graph = completed_graph.as_ref().unwrap_or(graph);
     if selected == head_id {
-        return Ok(None);
+        return Ok(Perform::Complete(None));
     }
     if let Some(pin) = selected_pin(&repository, selected)? {
         drop(repository);
         checkout_pin(&workdir, &pin)?;
         let repository = open_repository(repository_path, bare, false)
             .context("could not reopen repository after returning from time-travel")?;
-        return Ok(Some(match delete_pin(&repository, &pin) {
+        return Ok(Perform::Complete(Some(match delete_pin(&repository, &pin) {
             Ok(()) => format!("returned from {}", pin_label(&pin)),
             Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
-        }));
+        })));
     }
     let saved_target = head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id));
     let provisional = graph
@@ -107,7 +201,7 @@ pub(crate) fn perform(
             notice = format!("{notice}; saved {}", pin_label(&pin));
         }
     }
-    Ok(Some(notice))
+    Ok(Perform::Complete(Some(notice)))
 }
 
 fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId) -> Result<Option<ObjectId>> {
@@ -329,7 +423,9 @@ mod tests {
         assert!(!contains(&repository, main, root));
         drop(repository);
 
-        let notice = perform(&repository_path, false, root, &graph, &[], false)?.context("time-travel changed HEAD")?;
+        let notice = perform(&repository_path, false, root, &graph, &[], false)?
+            .complete()?
+            .context("time-travel changed HEAD")?;
         assert!(notice.contains("saved pin:"), "{notice}");
         let repository = crate::open_test_repository(fixture.path())?;
         assert!(repository.head()?.is_detached(), "travel detaches HEAD");
@@ -354,7 +450,7 @@ mod tests {
         assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
         drop(repository);
 
-        perform(&repository_path, false, topic, &graph, &[], false)?;
+        perform(&repository_path, false, topic, &graph, &[], false)?.complete()?;
         let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -370,12 +466,12 @@ mod tests {
             .status()?;
         assert!(detach.success());
         let graph = loaded_graph(&crate::open_test_repository(fixture.path())?, &[])?;
-        perform(&repository_path, false, root, &graph, &[], false)?;
+        perform(&repository_path, false, root, &graph, &[], false)?.complete()?;
         let pin = history::all_pins(&crate::open_test_repository(fixture.path())?)?
             .pop()
             .context("direct pin is present")?;
         assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
-        perform(&repository_path, false, main, &graph, &[], false)?;
+        perform(&repository_path, false, main, &graph, &[], false)?.complete()?;
         let repository = crate::open_test_repository(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
@@ -397,7 +493,7 @@ mod tests {
         let graph = loaded_graph(&repository, &revisions)?;
         drop(repository);
 
-        perform(&repository_path, false, root, &graph, &revisions, false)?;
+        perform(&repository_path, false, root, &graph, &revisions, false)?.complete()?;
         assert!(
             history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty(),
             "an explicit tip already retains the former HEAD"
@@ -410,8 +506,9 @@ mod tests {
             .status()?;
         assert!(checkout.success());
         std::fs::write(fixture.path().join("main"), "dirty\n")?;
-        let err =
-            perform(&repository_path, false, root, &graph, &[], false).expect_err("Git rejects a conflicting checkout");
+        let err = perform(&repository_path, false, root, &graph, &[], false)
+            .and_then(Perform::complete)
+            .expect_err("Git rejects a conflicting checkout");
         assert!(format!("{err:#}").contains("git checkout failed"));
         let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
@@ -422,6 +519,105 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn conflicting_pending_rebases_are_unobservable_until_accepted() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000",])
+                .status()?
+                .success()
+        );
+        let repository = crate::open_test_repository(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        std::fs::write(fixture.path().join("after"), "after\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "after"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "-m", "after"])
+                .env("GIT_AUTHOR_DATE", "2000-01-04T00:00:00 +0000")
+                .env("GIT_COMMITTER_DATE", "2000-01-04T00:00:00 +0000")
+                .status()?
+                .success()
+        );
+        let graph = super::super::loaded_graph(&repository)?;
+        super::super::rebase::perform(
+            &repository,
+            &graph,
+            super::super::rebase::Edit::Remove { target: middle },
+            super::super::rebase::Signature::RedoIfNeeded,
+            super::super::rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let graph = super::super::loaded_graph(&repository)?;
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let Perform::Conflict(conflict) = perform(&repository_path, false, root, &graph, &[], false)? else {
+            return Err("the pending rebase should suspend at its conflicting cherry-pick".into());
+        };
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "preparing the exact merge result changes no repository state"
+        );
+
+        let (_notice, conflict_id) = conflict.accept()?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(
+            repository.head_id()?.detach(),
+            conflict_id,
+            "the conflicting commit is checked out"
+        );
+        assert!(repository.head()?.is_detached(), "conflict resolution detaches HEAD");
+        let branch = repository.find_reference("refs/heads/main")?.id().detach();
+        assert_ne!(
+            branch, conflict_id,
+            "the remaining descendant stays on the saved branch"
+        );
+        assert!(
+            super::super::rebase::has_marker(&repository.find_commit(branch)?.decode()?.into_owned()?),
+            "remaining descendants stay as lazy rewrites"
+        );
+        let index = repository.index_or_empty()?;
+        assert!(
+            index
+                .entries()
+                .iter()
+                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted),
+            "the retained merge outcome supplies unresolved index stages"
+        );
+        assert!(
+            std::fs::read(fixture.path().join("file"))?
+                .as_bstr()
+                .contains_str("<<<<<<<"),
+            "the checked-out merge tree contains conflict markers"
+        );
+        insta::assert_snapshot!(
+            "accepted-pending-rebase-conflict",
+            gix_testtools::repository::snapshot(fixture.path())?
+                .to_string()
+                .replace("\n  \n", "\n\n")
+        );
+        let err = perform(&repository_path, false, root, &graph, &[], false)
+            .and_then(Perform::complete)
+            .expect_err("time-travel is disabled until the index conflict is resolved");
+        assert!(format!("{err:#}").contains("unresolved index conflicts"));
+        Ok(())
+    }
+
     #[test]
     fn travelling_completes_the_whole_pending_rebase() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -432,14 +628,14 @@ mod tests {
         let graph = loaded_graph(&repository, &[])?;
         let commit = repository.find_commit(middle)?.decode()?.into_owned()?;
         super::super::rebase::perform(
-            repository.clone(),
+            &repository,
             &graph,
             super::super::rebase::Edit::Replace { target: middle, commit },
             super::super::rebase::Signature::InvalidateExisting,
             super::super::rebase::Tree::LeaveAsIsAndMark,
         )?;
         let graph = loaded_graph(&repository, &[])?;
-        perform(&repository_path, false, root, &graph, &[], false)?;
+        perform(&repository_path, false, root, &graph, &[], false)?.complete()?;
 
         let repository = crate::open_test_repository(fixture.path())?;
         let mut current = Some(repository.find_reference("refs/heads/main")?.id().detach());
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d004e84375d..07dd893251c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -999,6 +999,7 @@ fn event_loop(
     let mut repeat_deadline: Option<Instant> = None;
     let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
+    let mut pending_rebase_conflict: Option<edit::time_travel::Conflict> = None;
     let result: Result<Option<Duration>> = (|| loop {
         if let Some(mut recovered) =
             recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
@@ -1505,6 +1506,7 @@ fn event_loop(
         let Some(terminal_event) = terminal_event else {
             continue;
         };
+        let is_key_event = matches!(&terminal_event, TerminalEvent::Key(_));
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
                 let action = action_with_shortcut_groups(key, app.history_display_expanded, app.edit_expanded);
@@ -1607,6 +1609,50 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        if is_key_event && pending_rebase_conflict.is_some() {
+            if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
+                let conflict = pending_rebase_conflict
+                    .take()
+                    .expect("a pending conflict was checked before accepting it");
+                match conflict.accept() {
+                    Ok((notice, id)) => {
+                        app.begin_conflict_resolution();
+                        app.leave_message(notice);
+                        app.select_commit_after_refresh(id);
+                    }
+                    Err(err) => {
+                        app.clear_rebase_conflict();
+                        app.leave_message(format!("conflict checkout: {err:#}"));
+                    }
+                }
+                sync_line_diff_pool(
+                    &mut line_diff_pool,
+                    app.changes_mode.is_some(),
+                    &repository_path,
+                    repository_is_bare,
+                    line_diff_parallelism,
+                )?;
+                if worktree_watcher.is_none() {
+                    match start_worktree_watcher(&repository_path, repository_is_bare) {
+                        Ok(watcher) => worktree_watcher = Some(watcher),
+                        Err(err) => {
+                            tracing::warn!(error = %err, "worktree watcher startup after conflict failed");
+                            app.worktree_changes.error = Some(format!("worktree watch: {err}"));
+                            schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
+                        }
+                    }
+                }
+                invalidate_worktree_changes(&mut worktree_changes);
+                refresh_pending = true;
+                dirty = true;
+                urgent = true;
+                continue;
+            }
+            pending_rebase_conflict = None;
+            app.clear_rebase_conflict();
+            dirty = true;
+            urgent = true;
+        }
         let Some(action) = action else {
             continue;
         };
@@ -1895,7 +1941,7 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(Some(notice)) => {
+                        Ok(edit::time_travel::Perform::Complete(Some(notice))) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
                             app.leave_message(notice);
                             if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
@@ -1906,7 +1952,13 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Ok(None) => {}
+                        Ok(edit::time_travel::Perform::Complete(None)) => {}
+                        Ok(edit::time_travel::Perform::Conflict(conflict)) => {
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Err(err) => app.leave_message(format!("time-travel: {err:#}")),
                     }
                 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 125696c0e27..4389d12ee5d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -243,6 +243,9 @@ pub(crate) fn draw_with_worktree(
         && changes_panes
             .iter()
             .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0);
+    if let Some(changes) = worktree_changes {
+        app.set_worktree_conflicted(changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
+    }
     let selected_is_head = app.selected.and_then(|index| app.rows.get(index)).is_some_and(|row| {
         decorations
             .get(&row.id)
@@ -422,15 +425,24 @@ pub(crate) fn draw_with_worktree(
         let style = highlight.map_or_else(Style::default, |highlight| {
             color(highlight).add_modifier(Modifier::REVERSED)
         });
+        let conflict = app.conflict_marker(visible_rows[index].id, head);
         frame.render_widget(
-            Paragraph::new(if head && worktree_dirty {
+            Paragraph::new(if conflict {
+                "C "
+            } else if head && worktree_dirty {
                 "D "
             } else if selected {
                 "> "
             } else {
                 "  "
             })
-            .style(if selected { style } else { Style::default() }),
+            .style(if conflict {
+                color(Color::LightRed).add_modifier(Modifier::SLOW_BLINK)
+            } else if selected {
+                style
+            } else {
+                Style::default()
+            }),
             Rect::new(body.x, y, body.width.min(2), 1),
         );
 
@@ -3099,6 +3111,52 @@ mod tests {
                 .contains(Modifier::REVERSED)
         );
 
+        let conflicted = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Unmerged,
+                group: ChangeGroup::Unstaged,
+                source: None,
+                path: "dirty".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&conflicted),
+            );
+        })?;
+        assert!(rendered_line(&terminal, 0).starts_with("C @"));
+        assert_eq!(terminal.backend().buffer()[(0, 0)].fg, Color::LightRed);
+        assert!(
+            terminal.backend().buffer()[(0, 0)]
+                .modifier
+                .contains(Modifier::SLOW_BLINK),
+            "the conflict marker remains visually urgent"
+        );
+
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&dirty),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 0).starts_with("D @"),
+            "resolving the index restores the ordinary dirty marker"
+        );
+
         app.changes_mode = Some(ChangesMode::Tree);
         terminal.draw(|frame| {
             super::draw_with_worktree(

From 04dde842ba2570580746159ea3b9ee04d332f37f Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 21:56:48 +0200
Subject: [PATCH 074/282] feat: order tix history status actions

---
 gix-tix/src/ui.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4389d12ee5d..efca70d97e3 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -844,31 +844,31 @@ pub(crate) fn draw_with_worktree(
     } else {
         shortcut("copy", 'y', true)
     });
-    ordered.append(&mut footer_spans);
-    footer_spans = ordered;
-    footer_spans.push(Span::raw(" · "));
+    ordered.push(Span::raw(" · "));
     if app.preview_author_copy && app.manual_refresh {
-        footer_spans.extend(shortcut(
+        ordered.extend(shortcut(
             "Refresh",
             'R',
             matches!(history_state, State::Complete | State::Cancelled),
         ));
     } else {
-        footer_spans.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
+        ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     }
     if app.signature_failures > 0 {
-        footer_spans.extend([
+        ordered.extend([
             Span::raw(format!(" · s {} ", app.signature_failures)),
             Span::styled("●", color(Color::LightRed)),
         ]);
     } else if has_verifiable_signatures {
-        footer_spans.extend([
+        ordered.extend([
             Span::raw(" · s "),
             Span::styled("●", color(Color::Rgb(255, 165, 0))),
             Span::raw(" -> "),
             Span::styled("●", color(Color::Green)),
         ]);
     }
+    ordered.append(&mut footer_spans);
+    footer_spans = ordered;
     if app.changes_focus.is_none() && history_state == State::Loading {
         footer_spans.push(Span::raw(" · Esc cancel"));
     }
@@ -2401,7 +2401,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
         let footer_text =
-            "#1 · view · edit · copy · [ align · message · changes · refs · ↑↓/jk move · h/l pan · <enter> diff · quit";
+            "#1 · view · edit · copy · refs · [ align · message · changes · ↑↓/jk move · h/l pan · <enter> diff · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -3192,7 +3192,7 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("s ● -> ●"));
+        assert!(rendered_line(&terminal, 1).contains("copy · refs · s ● -> ●"));
 
         app.finish_signature_verification(vec![(id, false)]);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;

From 9cfc22f6d27ce2ace66a49e7b8f58f2c9f96cfd4 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Thu, 13 Aug 2026 22:30:12 +0200
Subject: [PATCH 075/282] feat: inspect hidden branch bases in tix

Make hidden ancestry boundaries selectable for read-only inspection. Reuse the cached history graph to identify boundaries with one visible descendant leaf, then use the existing tree-diff pipeline for base-to-tip stats, changed paths, and full diffs.

Keep ambiguous multi-leaf boundaries on their ordinary commit diff and continue excluding hidden rows from editing, signature verification, time travel, and Shift reachability navigation.
---
 gix-tix/spec.md    |  10 +-
 gix-tix/src/app.rs | 214 +++++++++++++++++++++++++++++----------
 gix-tix/src/lib.rs | 243 ++++++++++++++++++++++++++++++---------------
 gix-tix/src/ui.rs  | 100 +++++++++++++++----
 4 files changed, 416 insertions(+), 151 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b656f6d90ae..983330aeeea 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -56,8 +56,14 @@ without trading responsiveness for metadata that is not visible.
 - Hidden ancestry is removed from the selectable view by default. Direct parents
   that connect visible history to hidden history remain as boundary rows.
 - Boundary rows retain graph styling but use terminal-default colors, are dimmed,
-  and cannot be selected, paged to, copied, signature-verified, restored as a
-  selection, or entered by Shift navigation.
+  and can be selected, paged to, restored as a selection, copied, and inspected.
+  They cannot be edited, signature-verified, or used for time travel, and Shift
+  navigation continues to skip them.
+- If a boundary has exactly one leaf among its visible descendants, selecting it
+  uses the boundary-to-leaf tree comparison for the changes block and selection
+  diff-stat. Forks which merge back into one leaf qualify; multiple surviving
+  leaves retain the boundary commit's ordinary parent diff. Enter opens the same
+  complete branch diff, labelled `<base>..<leaf>`.
 - Hidden revisions do not change the default reference display mode.
 - `v`, then `h`, toggles the full hidden projection. Toggling preserves the
   selected commit when it still exists and otherwise selects the newest
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 53e77977b6f..f52b2596b8f 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -137,15 +137,22 @@ pub(crate) struct PathChange {
 #[derive(Clone, Debug, Default, PartialEq)]
 pub(crate) struct Changes {
     pub parent: Option<ComparedParent>,
+    pub range: Option<ComparedRange>,
     pub paths: Vec<PathChange>,
     pub diffs: Vec<crate::FileChange>,
     pub lines_added: u64,
     pub lines_removed: u64,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) struct ComparedRange {
+    pub base: ObjectId,
+    pub tip: ObjectId,
+}
+
 impl Changes {
     pub(crate) fn is_visible(&self) -> bool {
-        self.parent.is_some() || !self.paths.is_empty()
+        self.parent.is_some() || self.range.is_some() || !self.paths.is_empty()
     }
 }
 
@@ -310,7 +317,7 @@ pub(crate) enum Effect {
     CopyAuthor(&'static Author),
     Reload(bool),
     OpenDiff(ChangePane, usize),
-    OpenCommitDiff(ObjectId),
+    OpenCommitDiff(TreeDiffTarget),
     Reword(ObjectId),
     NewCommit(Option<ObjectId>),
     Amend(ObjectId),
@@ -322,12 +329,28 @@ pub(crate) enum Effect {
     Quit,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum TreeDiffTarget {
+    Commit { id: ObjectId, parent: usize },
+    Branch { base: ObjectId, tip: ObjectId },
+}
+
+impl TreeDiffTarget {
+    pub(crate) fn selected(self) -> ObjectId {
+        match self {
+            TreeDiffTarget::Commit { id, .. } => id,
+            TreeDiffTarget::Branch { base, .. } => base,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub(crate) struct App {
     pub rows: Vec<SharedCommitRow>,
     all_rows: HashMap<ObjectId, SharedCommitRow>,
     all_order: Vec<ObjectId>,
     hidden_rows: HashSet<ObjectId>,
+    hidden_branch_targets: HashMap<ObjectId, ObjectId>,
     pending_hidden_rows: Option<HashSet<ObjectId>>,
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
@@ -411,6 +434,7 @@ impl App {
             all_rows: HashMap::new(),
             all_order: Vec::new(),
             hidden_rows: HashSet::new(),
+            hidden_branch_targets: HashMap::new(),
             pending_hidden_rows: None,
             titles: Vec::new(),
             notes: HashMap::new(),
@@ -577,9 +601,7 @@ impl App {
             .reload_selection
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
         {
-            if !self.is_row_hidden(index) {
-                self.selected = Some(index);
-            }
+            self.selected = Some(index);
             self.reload_selection = None;
             self.ensure_visible();
         }
@@ -587,9 +609,7 @@ impl App {
             .pending_initial_selection
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
         {
-            if !self.is_row_hidden(index) {
-                self.selected = Some(index);
-            }
+            self.selected = Some(index);
             self.pending_initial_selection = None;
             self.ensure_visible();
         }
@@ -900,8 +920,8 @@ impl App {
                 return vec![Effect::OpenDiff(pane, changes.selected)];
             }
             Action::OpenDiff => {
-                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
-                    return vec![Effect::OpenCommitDiff(id)];
+                if let Some(target) = self.selected_tree_diff_target() {
+                    return vec![Effect::OpenCommitDiff(target)];
                 }
             }
             Action::Reword if self.can_reword() => {
@@ -1038,6 +1058,61 @@ impl App {
         self.hidden_branch_behind.get(&id).copied()
     }
 
+    pub(crate) fn selected_tree_diff_target(&self) -> Option<TreeDiffTarget> {
+        let id = self.selected.and_then(|index| self.rows.get(index))?.id;
+        Some(match self.hidden_branch_targets.get(&id) {
+            Some(&tip) => TreeDiffTarget::Branch { base: id, tip },
+            None => TreeDiffTarget::Commit {
+                id,
+                parent: self.changes_parent,
+            },
+        })
+    }
+
+    fn update_hidden_branch_targets(&mut self) {
+        #[derive(Clone, Copy)]
+        enum Leaves {
+            One(ObjectId),
+            Many,
+        }
+
+        let visible_parents: HashSet<_> = self
+            .rows
+            .iter()
+            .filter(|row| !self.hidden_rows.contains(&row.id))
+            .flat_map(|row| row.parent_ids.iter().copied())
+            .collect();
+        let mut leaves = HashMap::<ObjectId, Leaves>::new();
+        let mut targets = HashMap::new();
+        for row in &self.rows {
+            let state = if self.hidden_rows.contains(&row.id) {
+                leaves.get(&row.id).copied()
+            } else if !visible_parents.contains(&row.id) {
+                Some(Leaves::One(row.id))
+            } else {
+                leaves.get(&row.id).copied()
+            };
+            let Some(state) = state else { continue };
+            if self.hidden_rows.contains(&row.id) {
+                if let Leaves::One(tip) = state {
+                    targets.insert(row.id, tip);
+                }
+                continue;
+            }
+            for parent in &row.parent_ids {
+                leaves
+                    .entry(*parent)
+                    .and_modify(|existing| {
+                        if !matches!((*existing, state), (Leaves::One(a), Leaves::One(b)) if a == b) {
+                            *existing = Leaves::Many;
+                        }
+                    })
+                    .or_insert(state);
+            }
+        }
+        self.hidden_branch_targets = targets;
+    }
+
     pub(crate) fn start_refresh(
         &mut self,
         commits: LoadedCommits,
@@ -1125,6 +1200,7 @@ impl App {
         if let Some(hidden) = self.pending_hidden_rows.take() {
             self.hidden_rows = hidden;
         }
+        self.update_hidden_branch_targets();
         for row in &mut self.rows {
             if let Some(metadata) = metadata.get(&row.id) {
                 let row = Arc::make_mut(row);
@@ -1158,6 +1234,7 @@ impl App {
         self.all_rows.clear();
         self.all_order.clear();
         self.hidden_rows.clear();
+        self.hidden_branch_targets.clear();
         self.hidden_branch_behind.clear();
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
@@ -1391,7 +1468,7 @@ impl App {
 
     fn select(&mut self, selected: usize) {
         self.pending_initial_selection = None;
-        if !self.rows.is_empty() && !self.is_row_hidden(selected) {
+        if !self.rows.is_empty() {
             let previous = self.selected;
             self.selected = Some(selected.min(self.rows.len() - 1));
             if self.selected != previous {
@@ -1403,7 +1480,7 @@ impl App {
     }
 
     fn first_selectable(&self) -> Option<usize> {
-        (0..self.rows.len()).find(|index| !self.is_row_hidden(*index))
+        (!self.rows.is_empty()).then_some(0)
     }
 
     fn update_worktree_head_descendants(&mut self) {
@@ -1421,10 +1498,9 @@ impl App {
     pub(crate) fn reword_shortcut_visible(&self) -> bool {
         self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self
-                .selected
-                .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| !self.known_merge_descendants.contains(&row.id))
+            && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
+                !self.hidden_rows.contains(&row.id) && !self.known_merge_descendants.contains(&row.id)
+            })
     }
 
     pub(crate) fn can_create_commit(&self) -> bool {
@@ -1433,7 +1509,7 @@ impl App {
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && match self.selected.and_then(|index| self.rows.get(index)) {
-                Some(row) => !self.known_merge_descendants.contains(&row.id),
+                Some(row) => !self.hidden_rows.contains(&row.id) && !self.known_merge_descendants.contains(&row.id),
                 None => self.worktree_head_unborn,
             }
     }
@@ -1442,10 +1518,11 @@ impl App {
         self.state == State::Complete
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self
-                .selected
-                .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| row.parent_ids.len() <= 1 && !self.known_merge_descendants.contains(&row.id))
+            && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
+                !self.hidden_rows.contains(&row.id)
+                    && row.parent_ids.len() <= 1
+                    && !self.known_merge_descendants.contains(&row.id)
+            })
     }
 
     fn can_edit_head(&self) -> bool {
@@ -1453,7 +1530,9 @@ impl App {
             && self.worktree_changes_available
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
-                Some(row.id) == self.worktree_head && !self.known_merge_descendants.contains(&row.id)
+                !self.hidden_rows.contains(&row.id)
+                    && Some(row.id) == self.worktree_head
+                    && !self.known_merge_descendants.contains(&row.id)
             })
     }
 
@@ -1497,24 +1576,18 @@ impl App {
             && !self.worktree_conflicted
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self.selected.is_some()
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| !self.hidden_rows.contains(&row.id))
     }
 
     fn last_selectable(&self) -> Option<usize> {
-        (0..self.rows.len()).rev().find(|index| !self.is_row_hidden(*index))
+        self.rows.len().checked_sub(1)
     }
 
-    fn nearest_selectable(&self, target: usize, down: bool) -> Option<usize> {
-        if down {
-            (target..self.rows.len())
-                .find(|index| !self.is_row_hidden(*index))
-                .or_else(|| (0..target).rev().find(|index| !self.is_row_hidden(*index)))
-        } else {
-            (0..=target)
-                .rev()
-                .find(|index| !self.is_row_hidden(*index))
-                .or_else(|| (target + 1..self.rows.len()).find(|index| !self.is_row_hidden(*index)))
-        }
+    fn nearest_selectable(&self, target: usize, _down: bool) -> Option<usize> {
+        (!self.rows.is_empty()).then_some(target.min(self.rows.len() - 1))
     }
 
     fn retry_failed_signatures(&mut self) {
@@ -2609,7 +2682,11 @@ mod tests {
         hidden.extend_commits(vec![row(3)]);
         hidden.extend_hidden_commits(vec![row(2)]);
         complete(&mut hidden);
-        assert_eq!(hidden.selected, Some(0), "a hidden HEAD cannot become selected");
+        assert_eq!(
+            hidden.rows[hidden.selected.expect("the boundary HEAD is selected")].id,
+            id(2),
+            "a selectable boundary retains the normal startup HEAD selection"
+        );
     }
 
     #[test]
@@ -2637,29 +2714,63 @@ mod tests {
     }
 
     #[test]
-    fn hidden_boundary_rows_are_not_selectable_or_verifiable() {
+    fn hidden_boundary_rows_are_selectable_for_inspection_only() {
         let mut app = App::new(4);
         app.extend_commits(vec![row(1), row(2), row(3)]);
-        app.update(Action::Last);
         app.extend_hidden_commits(vec![row(4)]);
+        complete(&mut app);
         Arc::make_mut(&mut app.rows[3]).signature = SignatureState::Unverified;
 
-        assert_eq!(
-            app.selected,
-            Some(2),
-            "following the tail stops at the oldest visible commit"
-        );
-        app.update(Action::MoveDown);
-        assert_eq!(app.selected, Some(2), "j cannot enter the hidden boundary");
         app.update(Action::First);
         app.update(Action::PageDown);
-        assert_eq!(app.selected, Some(2), "paging skips the hidden boundary");
+        assert_eq!(app.selected, Some(3), "paging can select the hidden boundary");
+        assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(id(4))]);
+        assert!(!app.can_reword());
+        assert!(!app.can_forget());
         assert!(
             app.update(Action::VerifySignatures).is_empty(),
             "hidden signatures are not actionable"
         );
     }
 
+    #[test]
+    fn hidden_boundary_branch_diffs_require_one_descendant_leaf() {
+        let target = |visible: Vec<LoadedCommit>| {
+            let mut app = App::new(10);
+            app.extend_commits(visible);
+            app.extend_hidden_commits(vec![row(1)]);
+            complete(&mut app);
+            app.select_commit(id(1));
+            app.selected_tree_diff_target()
+        };
+
+        assert_eq!(
+            target(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1])]),
+            Some(TreeDiffTarget::Branch {
+                base: id(1),
+                tip: id(3),
+            }),
+            "a linear branch compares its boundary to its only leaf"
+        );
+        assert_eq!(
+            target(vec![
+                row_with_parents(4, &[2, 3]),
+                row_with_parents(2, &[1]),
+                row_with_parents(3, &[1]),
+            ]),
+            Some(TreeDiffTarget::Branch {
+                base: id(1),
+                tip: id(4),
+            }),
+            "forks which merge again still have one leaf"
+        );
+        assert_eq!(
+            target(vec![row_with_parents(2, &[1]), row_with_parents(3, &[1])]),
+            Some(TreeDiffTarget::Commit { id: id(1), parent: 0 }),
+            "multiple leaves retain the boundary commit's ordinary diff"
+        );
+    }
+
     #[test]
     fn full_pages_target_changes_then_commit_messages_then_history() {
         let mut app = App::new(2);
@@ -2758,7 +2869,10 @@ mod tests {
         app.update(Action::ToggleChanges);
         app.update(Action::ToggleChanges);
         assert_eq!(app.changes_focus, None, "closing the panel returns focus to history");
-        assert_eq!(app.update(Action::OpenDiff), vec![Effect::OpenCommitDiff(id(1))]);
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::OpenCommitDiff(TreeDiffTarget::Commit { id: id(1), parent: 0 })]
+        );
         assert_eq!(app.tree_changes.selected, 0);
         assert_eq!(app.tree_changes.offset, 0);
         assert_eq!(app.tree_changes.horizontal_offset, 0);
@@ -3059,9 +3173,9 @@ mod tests {
         app.extend_hidden_commits(vec![row(2)]);
         complete(&mut app);
         assert_eq!(
-            app.selected,
-            Some(0),
-            "a selection which becomes a hidden boundary falls back to the top row"
+            app.rows[app.selected.expect("the boundary selection is retained")].id,
+            selected,
+            "a selection which becomes a hidden boundary remains selected"
         );
     }
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 07dd893251c..947bbe10b2e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -374,7 +374,7 @@ impl MotionState {
 }
 
 const TREE_CHANGES_CACHE_SIZE: usize = 8;
-type TreeChangesEntry = (gix::ObjectId, usize, Changes);
+type TreeChangesEntry = (app::TreeDiffTarget, Changes);
 
 #[derive(Default)]
 struct TreeChangesCache(VecDeque<TreeChangesEntry>);
@@ -384,12 +384,8 @@ impl TreeChangesCache {
         self.0.front()
     }
 
-    fn activate(&mut self, id: gix::ObjectId, parent: usize) -> bool {
-        let Some(position) = self
-            .0
-            .iter()
-            .position(|(cached_id, cached_parent, _)| *cached_id == id && *cached_parent == parent)
-        else {
+    fn activate(&mut self, target: app::TreeDiffTarget) -> bool {
+        let Some(position) = self.0.iter().position(|(cached, _)| *cached == target) else {
             return false;
         };
         if position != 0 {
@@ -1659,7 +1655,7 @@ fn event_loop(
         let action = copy_selected_path_action(
             action,
             &app,
-            tree_changes.as_ref().map(|(_, _, changes)| changes),
+            tree_changes.as_ref().map(|(_, changes)| changes),
             worktree_changes.as_ref().map(|(_, changes)| changes),
         );
         dirty = true;
@@ -1736,7 +1732,7 @@ fn event_loop(
                 }
                 Effect::OpenDiff(pane, index) => {
                     let changes = match pane {
-                        ChangePane::Tree => tree_changes.as_ref().map(|(_, _, changes)| changes),
+                        ChangePane::Tree => tree_changes.as_ref().map(|(_, changes)| changes),
                         ChangePane::Worktree => worktree_changes.as_ref().map(|(_, changes)| changes),
                     };
                     let result = changes
@@ -1752,19 +1748,25 @@ fn event_loop(
                         Ok(false) => {}
                     }
                 }
-                Effect::OpenCommitDiff(id) => {
-                    let title = app
-                        .rows
-                        .iter()
-                        .find(|row| row.id == id)
-                        .map(|row| {
-                            ui::commit_diff_title(row, app.title(row), &mailmap, app.use_mailmap, app.show_emails)
-                        })
-                        .context("selected commit is no longer available")?;
-                    let cached = tree_changes.as_ref().filter(|(cached_id, _, _)| *cached_id == id);
-                    let parent = cached.map_or(0, |(_, parent, _)| *parent);
-                    let cached = cached.map(|(_, _, changes)| changes);
-                    let result = prepare_commit_diff(&repository_path, repository_is_bare, id, parent, cached, title)
+                Effect::OpenCommitDiff(target) => {
+                    let title = match target {
+                        app::TreeDiffTarget::Commit { id, .. } => app
+                            .rows
+                            .iter()
+                            .find(|row| row.id == id)
+                            .map(|row| {
+                                ui::commit_diff_title(row, app.title(row), &mailmap, app.use_mailmap, app.show_emails)
+                            })
+                            .context("selected commit is no longer available")?,
+                        app::TreeDiffTarget::Branch { base, tip } => {
+                            format!("{}..{}", base.to_hex_with_len(7), tip.to_hex_with_len(7)).into()
+                        }
+                    };
+                    let cached = tree_changes
+                        .as_ref()
+                        .filter(|(cached_target, _)| *cached_target == target)
+                        .map(|(_, changes)| changes);
+                    let result = prepare_commit_diff(&repository_path, repository_is_bare, target, cached, title)
                         .and_then(|diff| show_commit_diff(terminal, diff, enhanced_keyboard));
                     match result {
                         Ok(true) => app.focus_history(),
@@ -1865,8 +1867,8 @@ fn event_loop(
                         .then(|| {
                             tree_changes
                                 .as_ref()
-                                .filter(|(cached_id, _, _)| *cached_id == id)
-                                .and_then(|(_, _, changes)| {
+                                .filter(|(target, _)| target.selected() == id)
+                                .and_then(|(_, changes)| {
                                     changes
                                         .paths
                                         .get(app.tree_changes.selected)
@@ -2320,27 +2322,21 @@ fn draw(
     if message_to_load.is_some() {
         app.reset_commit_view();
     }
-    if changes_visible && selected.is_some() && tree_changes.as_ref().map(|(cached, _, _)| *cached) != selected {
+    if changes_visible && selected.is_some() && tree_changes.as_ref().map(|(target, _)| target.selected()) != selected {
         app.changes_parent = 0;
     }
     let desired_tree_changes = (changes_visible && app.changes_mode.is_some())
-        .then_some(selected)
-        .flatten()
-        .map(|id| (id, app.changes_parent));
-    let tree_changes_changed = desired_tree_changes.is_some_and(|(id, parent)| {
-        tree_changes
-            .as_ref()
-            .is_none_or(|(cached, cached_parent, _)| *cached != id || *cached_parent != parent)
-    });
+        .then(|| app.selected_tree_diff_target())
+        .flatten();
+    let tree_changes_changed =
+        desired_tree_changes.is_some_and(|target| tree_changes.as_ref().is_none_or(|(cached, _)| *cached != target));
     let tree_selection = tree_changes_changed
-        .then(|| remembered_change_selection(&app.tree_changes, tree_changes.as_ref().map(|(_, _, changes)| changes)))
+        .then(|| remembered_change_selection(&app.tree_changes, tree_changes.as_ref().map(|(_, changes)| changes)))
         .flatten();
-    let tree_changes_to_load = desired_tree_changes
-        .filter(|(id, parent)| !tree_changes.activate(*id, *parent))
-        .map(|(id, _)| id);
+    let tree_changes_to_load = desired_tree_changes.filter(|target| !tree_changes.activate(*target));
     if tree_changes_changed
         && tree_changes_to_load.is_none()
-        && let Some(changes) = tree_changes.as_ref().map(|(_, _, changes)| changes)
+        && let Some(changes) = tree_changes.as_ref().map(|(_, changes)| changes)
     {
         restore_change_selection(&mut app.tree_changes, changes, tree_selection.clone());
     }
@@ -2418,12 +2414,11 @@ fn draw(
         if let Some(id) = message_to_load {
             *commit_message = Some((id, load_commit_message(repository, id)?));
         }
-        if let Some(id) = tree_changes_to_load {
+        if let Some(target) = tree_changes_to_load {
             repository.object_cache_size(OBJECT_CACHE_SIZE);
             let loaded = load_changes(
                 repository,
-                id,
-                app.changes_parent,
+                target,
                 line_diff_pool
                     .as_mut()
                     .context("line diff pool is missing while the changes pane is visible")?,
@@ -2432,7 +2427,7 @@ fn draw(
             let loaded = loaded?;
             app.changes_parent = loaded.parent.map_or(0, |parent| parent.index);
             restore_change_selection(&mut app.tree_changes, &loaded, tree_selection);
-            tree_changes.insert((id, app.changes_parent, loaded));
+            tree_changes.insert((target, loaded));
         }
         if worktree_changes_to_load {
             let started = Instant::now();
@@ -2475,7 +2470,7 @@ fn draw(
         }
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
-    let tree_changes = tree_changes.as_ref().map(|(_, _, changes)| changes);
+    let tree_changes = tree_changes.as_ref().map(|(_, changes)| changes);
     let worktree_changes = worktree_changes.as_ref().map(|(_, changes)| changes);
     terminal
         .autoresize()
@@ -2654,27 +2649,25 @@ fn prepare_file_diff(repository_path: &Path, bare: bool, change: &FileChange, pa
 fn prepare_commit_diff(
     repository_path: &Path,
     bare: bool,
-    id: gix::ObjectId,
-    requested_parent: usize,
+    target: app::TreeDiffTarget,
     cached: Option<&Changes>,
     title: BString,
 ) -> Result<CommitDiff> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for commit diff")?;
     repository.object_cache_size(OBJECT_CACHE_SIZE);
-    prepare_commit_diff_with_repository(&repository, id, requested_parent, cached, title)
+    prepare_commit_diff_with_repository(&repository, target, cached, title)
 }
 
 fn prepare_commit_diff_with_repository(
     repository: &gix::Repository,
-    id: gix::ObjectId,
-    requested_parent: usize,
+    target: app::TreeDiffTarget,
     cached: Option<&Changes>,
     title: BString,
 ) -> Result<CommitDiff> {
     let loaded = cached
         .is_none()
-        .then(|| load_changes_without_lines(repository, id, requested_parent))
+        .then(|| load_changes_without_lines(repository, target))
         .transpose()?;
     let changes = cached
         .or(loaded.as_ref())
@@ -3201,11 +3194,10 @@ fn load_commit_message(repository: &gix::Repository, id: gix::ObjectId) -> Resul
 
 fn load_changes(
     repository: &gix::Repository,
-    id: gix::ObjectId,
-    requested_parent: usize,
+    target: app::TreeDiffTarget,
     line_diff_pool: &mut LineDiffPool,
 ) -> Result<Changes> {
-    let mut out = load_changes_without_lines(repository, id, requested_parent)?;
+    let mut out = load_changes_without_lines(repository, target)?;
     let diffs = std::mem::take(&mut out.diffs);
     for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
         path.lines = lines;
@@ -3218,11 +3210,29 @@ fn load_changes(
     Ok(out)
 }
 
-fn load_changes_without_lines(
-    repository: &gix::Repository,
-    id: gix::ObjectId,
-    requested_parent: usize,
-) -> Result<Changes> {
+fn load_changes_without_lines(repository: &gix::Repository, target: app::TreeDiffTarget) -> Result<Changes> {
+    let app::TreeDiffTarget::Commit {
+        id,
+        parent: requested_parent,
+    } = target
+    else {
+        let app::TreeDiffTarget::Branch { base, tip } = target else {
+            unreachable!("all tree diff targets are covered")
+        };
+        let old_tree = repository
+            .find_commit(base)
+            .context("could not load branch base")?
+            .tree()
+            .context("could not load branch base tree")?;
+        let new_tree = repository
+            .find_commit(tip)
+            .context("could not load branch tip")?
+            .tree()
+            .context("could not load branch tip tree")?;
+        let mut changes = load_tree_changes_without_lines(repository, Some(&old_tree), &new_tree, None)?;
+        changes.range = Some(app::ComparedRange { base, tip });
+        return Ok(changes);
+    };
     let commit = repository.find_commit(id).context("could not load changed paths")?;
     let parents: Vec<_> = commit.parent_ids().collect();
     let parent_index = requested_parent.checked_rem(parents.len()).unwrap_or_default();
@@ -3896,29 +3906,52 @@ mod tests {
             gix::ObjectId::Sha1(bytes)
         };
         let mut cache = TreeChangesCache::default();
-        cache.insert((id(42), 0, Changes::default()));
         cache.insert((
-            id(42),
-            1,
+            app::TreeDiffTarget::Commit { id: id(42), parent: 0 },
+            Changes::default(),
+        ));
+        cache.insert((
+            app::TreeDiffTarget::Commit { id: id(42), parent: 1 },
             Changes {
                 lines_added: 42,
                 ..Changes::default()
             },
         ));
-        assert!(cache.activate(id(42), 0));
-        assert_eq!(cache.as_ref().map(|(_, parent, _)| *parent), Some(0));
-        assert!(cache.activate(id(42), 1));
+        assert!(cache.activate(app::TreeDiffTarget::Commit { id: id(42), parent: 0 }));
+        assert_eq!(
+            cache.as_ref().map(|(target, _)| *target),
+            Some(app::TreeDiffTarget::Commit { id: id(42), parent: 0 })
+        );
+        assert!(cache.activate(app::TreeDiffTarget::Commit { id: id(42), parent: 1 }));
         assert_eq!(
-            cache.as_ref().map(|(_, _, changes)| changes.lines_added),
+            cache.as_ref().map(|(_, changes)| changes.lines_added),
             Some(42),
             "each merge parent retains its own diff result"
         );
+        cache.insert((
+            app::TreeDiffTarget::Branch {
+                base: id(42),
+                tip: id(43),
+            },
+            Changes {
+                lines_removed: 43,
+                ..Changes::default()
+            },
+        ));
+        assert!(cache.activate(app::TreeDiffTarget::Commit { id: id(42), parent: 1 }));
+        assert_eq!(
+            cache.as_ref().map(|(_, changes)| changes.lines_added),
+            Some(42),
+            "a branch range cannot replace the base commit's ordinary diff"
+        );
         cache.clear();
 
         for value in 0..=TREE_CHANGES_CACHE_SIZE as u8 {
             cache.insert((
-                id(value),
-                usize::from(value),
+                app::TreeDiffTarget::Commit {
+                    id: id(value),
+                    parent: usize::from(value),
+                },
                 Changes {
                     lines_added: u64::from(value),
                     ..Changes::default()
@@ -3927,11 +3960,14 @@ mod tests {
         }
 
         assert!(
-            cache.activate(id(1), 1),
+            cache.activate(app::TreeDiffTarget::Commit { id: id(1), parent: 1 }),
             "a recently viewed commit and parent restores its computed diff"
         );
-        assert_eq!(cache.as_ref().map(|(_, _, changes)| changes.lines_added), Some(1));
-        assert!(!cache.activate(id(0), 0), "the oldest entry is evicted at the bound");
+        assert_eq!(cache.as_ref().map(|(_, changes)| changes.lines_added), Some(1));
+        assert!(
+            !cache.activate(app::TreeDiffTarget::Commit { id: id(0), parent: 0 }),
+            "the oldest entry is evicted at the bound"
+        );
         cache.clear();
         assert!(
             cache.as_ref().is_none(),
@@ -4116,8 +4152,10 @@ mod tests {
 
         let root = load_changes(
             &repository,
-            repository.rev_parse_single("v1^{}")?.detach(),
-            0,
+            app::TreeDiffTarget::Commit {
+                id: repository.rev_parse_single("v1^{}")?.detach(),
+                parent: 0,
+            },
             line_diff_pool,
         )?;
         assert_eq!(
@@ -4191,7 +4229,11 @@ mod tests {
         }
 
         let topic_id = repository.rev_parse_single("topic")?.detach();
-        let topic = load_changes(&repository, topic_id, 0, line_diff_pool)?;
+        let topic_target = app::TreeDiffTarget::Commit {
+            id: topic_id,
+            parent: 0,
+        };
+        let topic = load_changes(&repository, topic_target, line_diff_pool)?;
         assert_eq!(
             topic.paths,
             [
@@ -4214,7 +4256,7 @@ mod tests {
         );
         assert_eq!((topic.lines_added, topic.lines_removed), (2, 0));
         let title: BString = format!("{} author topic", topic_id.to_hex_with_len(7)).into();
-        let commit_diff = prepare_commit_diff_with_repository(&repository, topic_id, 0, None, title.clone())?;
+        let commit_diff = prepare_commit_diff_with_repository(&repository, topic_target, None, title.clone())?;
         assert!(commit_diff.external.is_empty());
         let FileDiff::BuiltIn(diff) = commit_diff.internal else {
             unreachable!("an isolated repository uses the built-in commit viewer")
@@ -4248,8 +4290,36 @@ mod tests {
             topic_position < extra_position,
             "whole-commit patches retain tree-diff order"
         );
+        let base = repository.rev_parse_single("v1^{}")?.detach();
+        let branch_target = app::TreeDiffTarget::Branch { base, tip: topic_id };
+        let branch = load_changes(&repository, branch_target, line_diff_pool)?;
+        assert_eq!(branch.range, Some(app::ComparedRange { base, tip: topic_id }));
+        assert_eq!(
+            branch
+                .paths
+                .iter()
+                .map(|change| change.path.as_bstr())
+                .collect::<Vec<_>>(),
+            ["main", "topic", "topic-extra"],
+            "branch diffs compare the boundary tree directly to its unique leaf"
+        );
+        let branch_diff =
+            prepare_commit_diff_with_repository(&repository, branch_target, Some(&branch), "branch".into())?;
+        let FileDiff::BuiltIn(branch_diff) = branch_diff.internal else {
+            unreachable!("an isolated repository uses the built-in branch viewer")
+        };
+        assert!(
+            branch_diff
+                .summary
+                .expect("branch diffs have a summary")
+                .last()
+                .expect("the branch aggregate follows path statistics")
+                .to_string()
+                .contains(&format!("{}..{}", base.to_hex_with_len(7), topic_id.to_hex_with_len(7))),
+            "the whole-diff viewer identifies the compared range"
+        );
         let empty =
-            prepare_commit_diff_with_repository(&repository, topic_id, 0, Some(&Changes::default()), title.clone())?;
+            prepare_commit_diff_with_repository(&repository, topic_target, Some(&Changes::default()), title.clone())?;
         let FileDiff::BuiltIn(empty) = empty.internal else {
             unreachable!("empty commits retain the built-in viewer")
         };
@@ -4265,7 +4335,7 @@ mod tests {
         );
 
         let pager_diff =
-            prepare_commit_diff_with_repository(&pager_repository, topic_id, 0, Some(&topic), title.clone())?;
+            prepare_commit_diff_with_repository(&pager_repository, topic_target, Some(&topic), title.clone())?;
         assert!(pager_diff.external.is_empty());
         let FileDiff::Pager { diff, .. } = pager_diff.internal else {
             unreachable!("one configured pager receives the aggregate commit patch")
@@ -4279,7 +4349,7 @@ mod tests {
             "the pager receives path statistics and the aggregate before the patch"
         );
         let external_diff =
-            prepare_commit_diff_with_repository(&external_repository, topic_id, 0, Some(&topic), title.clone())?;
+            prepare_commit_diff_with_repository(&external_repository, topic_target, Some(&topic), title.clone())?;
         assert_eq!(
             external_diff.external.len(),
             2,
@@ -4294,7 +4364,8 @@ mod tests {
         );
 
         let merge = repository.rev_parse_single("main")?.detach();
-        let first_parent = load_changes(&repository, merge, 0, line_diff_pool)?;
+        let first_parent_target = app::TreeDiffTarget::Commit { id: merge, parent: 0 };
+        let first_parent = load_changes(&repository, first_parent_target, line_diff_pool)?;
         assert_eq!(
             first_parent.parent,
             Some(ComparedParent {
@@ -4315,7 +4386,8 @@ mod tests {
             "the default merge diff compares the result to its first parent"
         );
 
-        let second_parent = load_changes(&repository, merge, 1, line_diff_pool)?;
+        let second_parent_target = app::TreeDiffTarget::Commit { id: merge, parent: 1 };
+        let second_parent = load_changes(&repository, second_parent_target, line_diff_pool)?;
         assert_eq!(
             second_parent.parent,
             Some(ComparedParent {
@@ -4335,8 +4407,12 @@ mod tests {
             }],
             "later parents can be selected independently"
         );
-        let second_parent_diff =
-            prepare_commit_diff_with_repository(&repository, merge, 1, Some(&second_parent), "merge title".into())?;
+        let second_parent_diff = prepare_commit_diff_with_repository(
+            &repository,
+            second_parent_target,
+            Some(&second_parent),
+            "merge title".into(),
+        )?;
         let FileDiff::BuiltIn(diff) = second_parent_diff.internal else {
             unreachable!("an isolated repository uses the built-in commit viewer")
         };
@@ -4349,7 +4425,12 @@ mod tests {
             "the commit viewer identifies the selected merge parent"
         );
         assert_eq!(
-            load_changes(&repository, merge, 2, line_diff_pool)?.parent,
+            load_changes(
+                &repository,
+                app::TreeDiffTarget::Commit { id: merge, parent: 2 },
+                line_diff_pool,
+            )?
+            .parent,
             first_parent.parent,
             "parent selection wraps around"
         );
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index efca70d97e3..31fe4658304 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -409,7 +409,14 @@ pub(crate) fn draw_with_worktree(
                 let natural_x = content
                     .x
                     .saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
-                    .saturating_add(1);
+                    .saturating_add(1)
+                    .saturating_add(if selected && app.show_selection_tail && selection_info_width > 0 {
+                        u16::try_from(selection_info_width)
+                            .unwrap_or(u16::MAX)
+                            .saturating_add(3)
+                    } else {
+                        0
+                    });
                 let x = natural_x.min(body.right().saturating_sub(width).saturating_sub(1));
                 (marker, x, width)
             })
@@ -561,6 +568,9 @@ pub(crate) fn draw_with_worktree(
                     .set_bg(Color::Reset)
                     .set_style(Style::default().add_modifier(Modifier::DIM));
             }
+            if selected && let Some(area) = selection_info_area {
+                frame.render_widget(Paragraph::new(selection_info.clone()), area);
+            }
         }
         if let Some((marker, x, width)) = hidden_branch_marker {
             frame.buffer_mut()[(x - 1, y)].set_symbol(" ");
@@ -1211,8 +1221,12 @@ pub(crate) fn commit_diff_summary(
             Line::from(spans)
         })
         .collect::<Vec<_>>();
-    let mut spans = match changes.parent {
-        Some(parent) if parent.total > 1 => vec![Span::styled(
+    let mut spans = match (changes.range, changes.parent) {
+        (Some(range), _) => vec![Span::styled(
+            format!("{}..{} · ", range.base.to_hex_with_len(7), range.tip.to_hex_with_len(7)),
+            color(COMPARED_PARENT_COLOR),
+        )],
+        (None, Some(parent)) if parent.total > 1 => vec![Span::styled(
             format!(
                 "vs parent {}/{} {} · ",
                 parent.index + 1,
@@ -1221,11 +1235,11 @@ pub(crate) fn commit_diff_summary(
             ),
             color(COMPARED_PARENT_COLOR),
         )],
-        Some(parent) => vec![Span::styled(
+        (None, Some(parent)) => vec![Span::styled(
             format!("vs parent {} · ", parent.id.to_hex_with_len(7)),
             color(COMPARED_PARENT_COLOR),
         )],
-        None => vec![Span::styled("root · ", color(COMPARED_PARENT_COLOR))],
+        (None, None) => vec![Span::styled("root · ", color(COMPARED_PARENT_COLOR))],
     };
     if changes.paths.is_empty() {
         spans.push(Span::styled("No changes", Style::default().add_modifier(Modifier::DIM)));
@@ -1245,11 +1259,15 @@ pub(crate) fn commit_diff_summary(
 fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'static> {
     let mut spans = match pane {
         ChangePane::Tree => {
-            let id = app
-                .selected
-                .and_then(|index| app.rows.get(index))
-                .map_or_else(|| "-------".into(), |row| row.id.to_hex_with_len(7).to_string());
-            vec![Span::raw(format!("─ Tree {id} ── "))]
+            let label = changes.range.map_or_else(
+                || {
+                    app.selected
+                        .and_then(|index| app.rows.get(index))
+                        .map_or_else(|| "-------".into(), |row| row.id.to_hex_with_len(7).to_string())
+                },
+                |range| format!("{}..{}", range.base.to_hex_with_len(7), range.tip.to_hex_with_len(7)),
+            );
+            vec![Span::raw(format!("─ Tree {label} ── "))]
         }
         ChangePane::Worktree if changes.paths.is_empty() => vec![
             Span::raw("─ Worktree "),
@@ -2691,7 +2709,7 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "view (date · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · copy · [ align")),
+            footer.starts_with(&format!("0 commits · {view} · copy · refs · [ align")),
             "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
@@ -2708,7 +2726,7 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · [ align"),
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · refs · [ align"),
             "the edit prefix follows the view prefix even when no action is available"
         );
         Ok(())
@@ -3528,6 +3546,7 @@ mod tests {
         complete(&mut app);
         let changes = Changes {
             parent: None,
+            range: None,
             paths: vec![
                 crate::app::PathChange {
                     kind: ChangeKind::Added,
@@ -4401,15 +4420,44 @@ mod tests {
         app.extend_commits(vec![commit(1)]);
         app.extend_hidden_commits(vec![commit(2)]);
         complete(&mut app);
+        app.select_commit(gix::ObjectId::Sha1([2; 20]));
         app.set_hidden_branch_behind(std::collections::HashMap::from([(gix::ObjectId::Sha1([2; 20]), 2)]));
         app.set_lane(0, "● ");
         app.set_lane(1, "● ");
-        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+        let changes = Changes {
+            range: Some(crate::app::ComparedRange {
+                base: gix::ObjectId::Sha1([2; 20]),
+                tip: gix::ObjectId::Sha1([1; 20]),
+            }),
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group: ChangeGroup::Tree,
+                source: None,
+                path: "changed".into(),
+                lines: Some((3, 1)),
+            }],
+            lines_added: 3,
+            lines_removed: 1,
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(120, 8))?;
 
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &Default::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
 
         let line = rendered_line(&terminal, 1);
-        assert!(line.contains("subject 2"), "the hidden commit keeps its normal content");
+        assert!(
+            line.contains("subject 2"),
+            "the hidden commit keeps its normal content: {line:?}"
+        );
         let visible = rendered_line(&terminal, 0);
         let visible_hash = visible.find("0101010").expect("the visible hash is present") as u16;
         assert_ne!(terminal.backend().buffer()[(visible_hash, 0)].fg, Color::Reset);
@@ -4420,13 +4468,22 @@ mod tests {
         );
         let marker_byte = line.find("⇣2").expect("the behind count is visible");
         let marker = line[..marker_byte].chars().count() as u16;
+        let added_byte = line.find("+3").expect("the branch additions are visible");
+        let added = line[..added_byte].chars().count() as u16;
+        let removed_byte = line.find("-1").expect("the branch removals are visible");
+        let removed = line[..removed_byte].chars().count() as u16;
         assert_eq!(&line[marker_byte - 1..marker_byte], " ", "the marker has a left margin");
         assert_eq!(
             terminal.backend().buffer()[(marker + 2, 1)].symbol(),
             " ",
             "the marker has a right margin"
         );
-        assert!(line.contains("subject 2 ⇣2 "), "the marker naturally follows the title");
+        assert!(
+            line.find("subject 2") < line.find("+3")
+                && line.find("+3") < line.find("-1")
+                && line.find("-1") < line.find("⇣2"),
+            "the branch diff-stat and behind marker follow the title: {line:?}"
+        );
         for x in 0..terminal.backend().buffer().area.width {
             let cell = &terminal.backend().buffer()[(x, 1)];
             if (marker..marker + 2).contains(&x) {
@@ -4434,14 +4491,21 @@ mod tests {
                 assert!(!cell.modifier.contains(Modifier::DIM));
                 continue;
             }
+            if (added..added + 2).contains(&x) || (removed..removed + 2).contains(&x) {
+                assert!(
+                    !cell.modifier.contains(Modifier::DIM),
+                    "branch diff-stat remains prominent"
+                );
+                continue;
+            }
             assert_eq!(cell.fg, Color::Reset, "the hidden row has no foreground colors");
             assert_eq!(cell.bg, Color::Reset, "the hidden row has no background colors");
             assert!(cell.modifier.contains(Modifier::DIM), "the hidden row is dimmed");
         }
-        assert_ne!(
+        assert_eq!(
             terminal.backend().buffer()[(0, 1)].symbol(),
             ">",
-            "the hidden row is not selected"
+            "the hidden base is selectable"
         );
 
         let mut narrow = Terminal::new(TestBackend::new(28, 3))?;

From 05efbc63a5b9869e5b8b7a78d39f310702ec19fc Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 05:39:42 +0200
Subject: [PATCH 076/282] feat: edit forked history from hidden bases

Offer a Markdown rebase todo when a selectable hidden boundary anchors merge-free visible descendants. Preserve forks while allowing picks to be reordered or dropped, new forks and empty commits to be added, and the worktree checkout marker to move.

Replay only the ancestry ending at the checkout marker eagerly. Keep other stacks lazy, retain unreferenced leaves with tix pins, and update the pre-editor mutable-reference snapshot atomically so concurrent ref changes remain authoritative.
---
 gix-tix/spec.md                 |  36 ++-
 gix-tix/src/app.rs              | 106 ++++++-
 gix-tix/src/edit/mod.rs         |   1 +
 gix-tix/src/edit/rebase.rs      | 538 ++++++++++++++++++++++++++++++--
 gix-tix/src/edit/time_travel.rs | 104 ++++++
 gix-tix/src/edit/todo.rs        | 382 +++++++++++++++++++++++
 gix-tix/src/lib.rs              | 126 ++++++++
 gix-tix/src/ui.rs               |  52 +++
 8 files changed, 1305 insertions(+), 40 deletions(-)
 create mode 100644 gix-tix/src/edit/todo.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 983330aeeea..dbd8f156a1e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -57,8 +57,10 @@ without trading responsiveness for metadata that is not visible.
   that connect visible history to hidden history remain as boundary rows.
 - Boundary rows retain graph styling but use terminal-default colors, are dimmed,
   and can be selected, paged to, restored as a selection, copied, and inspected.
-  They cannot be edited, signature-verified, or used for time travel, and Shift
-  navigation continues to skip them.
+  They cannot be reworded, forgotten, signature-verified, or used for time travel,
+  and Shift navigation continues to skip them. A boundary whose visible
+  descendants contain no merge commit offers the history-rebase editor, including
+  when those descendants fork into multiple linear stacks.
 - If a boundary has exactly one leaf among its visible descendants, selecting it
   uses the boundary-to-leaf tree comparison for the changes block and selection
   diff-stat. Forks which merge back into one leaf qualify; multiple surviving
@@ -434,9 +436,37 @@ space first; changes blocks adapt within the remaining history width.
   consumes the repository immediately after persisting and checking out the
   retained merge result.
 
+### History rebase editor
+
+- Selecting an eligible hidden boundary and pressing `e b` opens a Markdown
+  `.md` todo. It grows upward like the history view: each `## fork <id>` section
+  lists its commits oldest-to-newest as `` `pick <short-id>` <displayed metadata> ``.
+  IDs are shortened through repository configuration; metadata repeats the
+  information visible in history and always includes the subject.
+- Pick lines may be reordered or removed. Fork headings may target an earlier
+  pick or any existing commit, so adding and removing headings creates and joins
+  branches. `empty <title>` inserts an empty commit. Markdown code spans and
+  equivalent plain commands are accepted; display text after a pick ID is
+  informational.
+- `@pick` or `@empty` chooses the post-rebase checkout. When the current worktree
+  `HEAD` is in the editable region, exactly one generated `@` must remain; without
+  one, zero or one may be added. A checkout marker is invalid without a worktree.
+- Only the ancestry ending at `@` is eagerly cherry-picked and re-signed. Other
+  resulting stacks retain their trees, receive pending-rebase markers, and
+  invalidate old signatures for later time travel. With no `@`, the entire edit
+  is lazy. The existing suspended-conflict acceptance path handles eager
+  conflicts; bare repositories reject a conflict without persisting it.
+- Mutable refs captured before the editor opened follow retained or dropped
+  commits through one compare-and-swap transaction. Tags and remote-tracking refs
+  remain untouched. Every resulting leaf without a surviving mutable ref gets a
+  direct `refs/tix/pins/*` ref, except the checked-out leaf. Concurrent ref edits
+  win by making the transaction fail; the editor result is not rebuilt against a
+  later graph snapshot. Leaving the document unchanged is a no-op.
+
 ### Editing shortcuts
 
-- `e` toggles the edit shortcut group. `e r` rewords, `e n` creates a commit,
+- `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base,
+  `e r` rewords, `e n` creates a commit,
   `e a` amends `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   `e d d` confirms forgetting a top commit, and `e t` enters or returns from
   time travel when each action is available.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index f52b2596b8f..be56f8ecc04 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -298,6 +298,7 @@ pub(crate) enum Action {
     Spill,
     Split,
     Forget,
+    Rebase,
     TimeTravel,
     VerifySignatures,
     Cancel,
@@ -324,6 +325,11 @@ pub(crate) enum Effect {
     Spill(ObjectId),
     Split(ObjectId),
     Forget(ObjectId),
+    Rebase {
+        base: ObjectId,
+        commits: Vec<ObjectId>,
+        head: Option<ObjectId>,
+    },
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
@@ -351,6 +357,7 @@ pub(crate) struct App {
     all_order: Vec<ObjectId>,
     hidden_rows: HashSet<ObjectId>,
     hidden_branch_targets: HashMap<ObjectId, ObjectId>,
+    hidden_rebase_bases: HashSet<ObjectId>,
     pending_hidden_rows: Option<HashSet<ObjectId>>,
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
@@ -435,6 +442,7 @@ impl App {
             all_order: Vec::new(),
             hidden_rows: HashSet::new(),
             hidden_branch_targets: HashMap::new(),
+            hidden_rebase_bases: HashSet::new(),
             pending_hidden_rows: None,
             titles: Vec::new(),
             notes: HashMap::new(),
@@ -957,6 +965,14 @@ impl App {
                 }
                 self.forget_confirmation = Some(id);
             }
+            Action::Rebase if self.can_rebase() => {
+                let base = self.rows[self.selected.expect("rebase requires a selection")].id;
+                return vec![Effect::Rebase {
+                    base,
+                    commits: self.hidden_descendants(base),
+                    head: self.worktree_head,
+                }];
+            }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
@@ -1071,9 +1087,9 @@ impl App {
 
     fn update_hidden_branch_targets(&mut self) {
         #[derive(Clone, Copy)]
-        enum Leaves {
-            One(ObjectId),
-            Many,
+        struct State {
+            leaf: Option<ObjectId>,
+            has_merge: bool,
         }
 
         let visible_parents: HashSet<_> = self
@@ -1082,35 +1098,61 @@ impl App {
             .filter(|row| !self.hidden_rows.contains(&row.id))
             .flat_map(|row| row.parent_ids.iter().copied())
             .collect();
-        let mut leaves = HashMap::<ObjectId, Leaves>::new();
+        let mut states = HashMap::<ObjectId, State>::new();
         let mut targets = HashMap::new();
+        let mut rebase_bases = HashSet::new();
         for row in &self.rows {
             let state = if self.hidden_rows.contains(&row.id) {
-                leaves.get(&row.id).copied()
+                states.get(&row.id).copied()
             } else if !visible_parents.contains(&row.id) {
-                Some(Leaves::One(row.id))
+                Some(State {
+                    leaf: Some(row.id),
+                    has_merge: row.parent_ids.len() > 1,
+                })
             } else {
-                leaves.get(&row.id).copied()
+                states.get(&row.id).copied().map(|mut state| {
+                    state.has_merge |= row.parent_ids.len() > 1;
+                    state
+                })
             };
             let Some(state) = state else { continue };
             if self.hidden_rows.contains(&row.id) {
-                if let Leaves::One(tip) = state {
+                if let Some(tip) = state.leaf {
                     targets.insert(row.id, tip);
                 }
+                if !state.has_merge {
+                    rebase_bases.insert(row.id);
+                }
                 continue;
             }
             for parent in &row.parent_ids {
-                leaves
+                states
                     .entry(*parent)
                     .and_modify(|existing| {
-                        if !matches!((*existing, state), (Leaves::One(a), Leaves::One(b)) if a == b) {
-                            *existing = Leaves::Many;
+                        if existing.leaf != state.leaf {
+                            existing.leaf = None;
                         }
+                        existing.has_merge |= state.has_merge;
                     })
                     .or_insert(state);
             }
         }
         self.hidden_branch_targets = targets;
+        self.hidden_rebase_bases = rebase_bases;
+    }
+
+    fn hidden_descendants(&self, base: ObjectId) -> Vec<ObjectId> {
+        let mut reachable = HashSet::from([base]);
+        let mut out = Vec::new();
+        for row in self.rows.iter().rev() {
+            if self.hidden_rows.contains(&row.id) || !row.parent_ids.iter().any(|parent| reachable.contains(parent)) {
+                continue;
+            }
+            reachable.insert(row.id);
+            out.push(row.id);
+        }
+        out.reverse();
+        out
     }
 
     pub(crate) fn start_refresh(
@@ -1235,6 +1277,7 @@ impl App {
         self.all_order.clear();
         self.hidden_rows.clear();
         self.hidden_branch_targets.clear();
+        self.hidden_rebase_bases.clear();
         self.hidden_branch_behind.clear();
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
@@ -1525,6 +1568,16 @@ impl App {
             })
     }
 
+    pub(crate) fn can_rebase(&self) -> bool {
+        self.state == State::Complete
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| self.hidden_rebase_bases.contains(&row.id))
+    }
+
     fn can_edit_head(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -2771,6 +2824,37 @@ mod tests {
         );
     }
 
+    #[test]
+    fn hidden_boundary_rebase_accepts_forks_but_rejects_descendant_merges() {
+        let eligible = |visible: Vec<LoadedCommit>| {
+            let mut app = App::new(10);
+            app.extend_commits(visible);
+            app.extend_hidden_commits(vec![row(1)]);
+            complete(&mut app);
+            app.select_commit(id(1));
+            app
+        };
+
+        let mut fork = eligible(vec![row_with_parents(3, &[1]), row_with_parents(2, &[1])]);
+        assert!(fork.can_rebase(), "forked linear stacks can be edited together");
+        assert_eq!(
+            fork.update(Action::Rebase),
+            vec![Effect::Rebase {
+                base: id(1),
+                commits: vec![id(3), id(2)],
+                head: None,
+            }],
+            "the todo receives all visible descendants"
+        );
+
+        let merged = eligible(vec![
+            row_with_parents(4, &[3, 2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+        ]);
+        assert!(!merged.can_rebase(), "a merge across editable descendants is rejected");
+    }
+
     #[test]
     fn full_pages_target_changes_then_commit_messages_then_history() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index f03f14ce97b..85d0e06fdb6 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -58,6 +58,7 @@ pub(crate) mod rebase;
 pub(crate) mod reword;
 pub(crate) mod split;
 pub(crate) mod time_travel;
+pub(crate) mod todo;
 
 #[tracing::instrument(skip_all, fields(filename))]
 pub(crate) fn edit_document(
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 12501d55da8..39b9d47a7b8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -57,6 +57,39 @@ pub(crate) enum Edit {
     },
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum PlanParent {
+    Existing(ObjectId),
+    Step(usize),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum PlanCommit {
+    Pick(ObjectId),
+    Empty(BString),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct PlanStep {
+    pub parent: PlanParent,
+    pub commit: PlanCommit,
+}
+
+#[derive(Debug)]
+pub(crate) struct ExpectedRef {
+    pub name: gix::refs::FullName,
+    pub old: ObjectId,
+}
+
+#[derive(Debug)]
+pub(crate) struct Plan {
+    pub base: ObjectId,
+    pub scope: Vec<ObjectId>,
+    pub steps: Vec<PlanStep>,
+    pub checkout: Option<usize>,
+    pub expected_refs: Vec<ExpectedRef>,
+}
+
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
@@ -145,6 +178,47 @@ struct Prepared {
     selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
     committer: gix::actor::Signature,
+    expected_refs: Option<Vec<ExpectedRef>>,
+    pins: Vec<ObjectId>,
+}
+
+pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result<Vec<ExpectedRef>> {
+    let scope: HashSet<_> = scope.iter().copied().collect();
+    let mut out = Vec::new();
+    let mut seen = HashSet::new();
+    for reference in repo.references()?.all()? {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => anyhow::bail!("could not inspect a reference before editing: {err}"),
+        };
+        if matches!(
+            reference.name().category(),
+            Some(Category::Tag | Category::RemoteBranch)
+        ) {
+            continue;
+        }
+        let Some(old) = reference.try_id().map(gix::Id::detach) else {
+            continue;
+        };
+        if scope.contains(&old) && seen.insert(reference.name().to_owned()) {
+            out.push(ExpectedRef {
+                name: reference.name().to_owned(),
+                old,
+            });
+        }
+    }
+    if let Some(head) = repo.try_find_reference("HEAD")?
+        && let Some(old) = head.try_id().map(gix::Id::detach)
+        && scope.contains(&old)
+        && seen.insert(head.name().to_owned())
+    {
+        out.push(ExpectedRef {
+            name: head.name().to_owned(),
+            old,
+        });
+    }
+    Ok(out)
 }
 
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
@@ -312,6 +386,194 @@ pub(crate) fn perform(
         selected,
         rewritten,
         committer,
+        expected_refs: None,
+        pins: Vec::new(),
+    };
+    match conflict {
+        Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
+            prepared,
+            conflicts,
+            tree,
+            commit,
+            original,
+        })),
+        None => Ok(Perform::Complete(prepared.finish()?)),
+    }
+}
+
+#[tracing::instrument(skip_all, fields(base = %plan.base, steps = plan.steps.len()))]
+pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: Plan) -> Result<Perform> {
+    let mut repo = repo.clone();
+    let signing = repo
+        .commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+    let author = repo
+        .author()
+        .context("no Git author is configured")?
+        .context("could not resolve the Git author")?
+        .to_owned()
+        .context("could not own the Git author")?;
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()
+        .context("could not own the Git committer")?;
+    repo = repo.with_object_memory();
+
+    let scope: HashSet<_> = plan.scope.iter().copied().collect();
+    let mut picked = HashSet::new();
+    for step in &plan.steps {
+        if let PlanCommit::Pick(id) = step.commit {
+            if !scope.contains(&id) || !picked.insert(id) {
+                anyhow::bail!("a rebase plan contains an invalid or duplicate pick");
+            }
+            if graph.parents_of(id).context("a picked commit is incomplete")?.len() > 1 {
+                anyhow::bail!("merge commits cannot be picked by the rebase editor");
+            }
+        }
+    }
+
+    let mut eager = HashSet::new();
+    let mut cursor = plan.checkout;
+    while let Some(index) = cursor {
+        if !eager.insert(index) {
+            anyhow::bail!("the checkout ancestry contains a cycle");
+        }
+        cursor = match plan.steps.get(index).context("the checkout step is missing")?.parent {
+            PlanParent::Step(parent) => Some(parent),
+            PlanParent::Existing(_) => None,
+        };
+    }
+
+    let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut produced = Vec::with_capacity(plan.steps.len());
+    let mut conflict = None;
+    for (index, step) in plan.steps.iter().enumerate() {
+        let parent = match step.parent {
+            PlanParent::Existing(id) => {
+                repo.find_commit(id).context("could not find a fork target")?;
+                id
+            }
+            PlanParent::Step(parent) => *produced.get(parent).context("a fork points to a later commit")?,
+        };
+        let eager = eager.contains(&index) && conflict.is_none();
+        let mut commit = match &step.commit {
+            PlanCommit::Pick(id) => repo
+                .find_commit(*id)
+                .context("could not find a picked commit")?
+                .decode()
+                .context("could not decode a picked commit")?
+                .into_owned()
+                .context("could not own a picked commit")?,
+            PlanCommit::Empty(title) => gix::objs::Commit {
+                tree: parent_tree(&repo, Some(parent))?,
+                parents: [parent].into_iter().collect(),
+                author: author.clone(),
+                committer: committer.clone(),
+                encoding: None,
+                message: title.clone(),
+                extra_headers: Vec::new(),
+            },
+        };
+        let old_parents = match step.commit {
+            PlanCommit::Pick(id) => graph.parents_of(id).context("a picked commit is incomplete")?,
+            PlanCommit::Empty(_) => vec![parent],
+        };
+        let mode = if eager {
+            Tree::CherryPick
+        } else {
+            Tree::LeaveAsIsAndMark
+        };
+        let mut new_conflict = None;
+        commit.tree = match rewritten_tree(&repo, &commit, &old_parents, &[parent], mode)? {
+            TreeRewrite::Complete(tree) => tree,
+            TreeRewrite::Conflict { tree, conflicts } => {
+                new_conflict = Some((tree, conflicts));
+                tree
+            }
+        };
+        commit.parents = [parent].into_iter().collect();
+        commit.committer = committer.clone();
+        marker(
+            &mut commit,
+            !eager || new_conflict.is_some(),
+            old_parents.first().copied(),
+        );
+        let signature = if eager && new_conflict.is_none() {
+            Signature::RedoIfNeeded
+        } else {
+            Signature::InvalidateExisting
+        };
+        let new_id = write_commit(&repo, commit, signature, signing.clone())?;
+        if let PlanCommit::Pick(old_id) = step.commit {
+            rewritten.insert(old_id, Some(new_id));
+        }
+        produced.push(new_id);
+        if let Some((tree, conflicts)) = new_conflict {
+            let PlanCommit::Pick(original) = step.commit else {
+                unreachable!("empty commits cannot conflict")
+            };
+            conflict = Some((original, tree, conflicts, new_id));
+        }
+    }
+
+    for dropped in plan.scope.iter().copied().filter(|id| !picked.contains(id)) {
+        let mut ancestor = graph
+            .parents_of(dropped)
+            .context("a dropped commit is incomplete")?
+            .first()
+            .copied();
+        while let Some(id) = ancestor {
+            if let Some(new) = rewritten.get(&id).copied().flatten() {
+                ancestor = Some(new);
+                break;
+            }
+            if !scope.contains(&id) {
+                break;
+            }
+            ancestor = graph
+                .parents_of(id)
+                .context("a dropped ancestor is incomplete")?
+                .first()
+                .copied();
+        }
+        rewritten.insert(dropped, ancestor.or(Some(plan.base)));
+    }
+
+    let planned_non_leaves: HashSet<_> = plan
+        .steps
+        .iter()
+        .filter_map(|step| match step.parent {
+            PlanParent::Step(index) => Some(index),
+            PlanParent::Existing(_) => None,
+        })
+        .collect();
+    let mut pins = Vec::new();
+    for (index, id) in produced.iter().copied().enumerate() {
+        if planned_non_leaves.contains(&index) || plan.checkout == Some(index) {
+            continue;
+        }
+        let referenced = plan
+            .expected_refs
+            .iter()
+            .any(|expected| rewritten.get(&expected.old).copied().flatten() == Some(id));
+        if !referenced {
+            pins.push(id);
+        }
+    }
+    let selected = plan.checkout.map(|index| produced[index]);
+    let mut prepared = Prepared {
+        repo,
+        root: Some(plan.base),
+        inserted: false,
+        marked: plan.steps.iter().enumerate().any(|(index, _)| !eager.contains(&index)) || conflict.is_some(),
+        skip_worktree_transitions: false,
+        selected,
+        rewritten,
+        committer,
+        expected_refs: Some(plan.expected_refs),
+        pins,
     };
     match conflict {
         Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
@@ -357,6 +619,8 @@ impl Prepared {
             self.root.is_none(),
             self.selected,
             &self.committer,
+            self.expected_refs.take(),
+            &self.pins,
         )?;
         for (transitioned, transition) in transitions.iter().enumerate() {
             if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
@@ -725,36 +989,46 @@ fn update_refs(
     unborn: bool,
     inserted: Option<ObjectId>,
     committer: &gix::actor::Signature,
+    expected_refs: Option<Vec<ExpectedRef>>,
+    pins: &[ObjectId],
 ) -> Result<Vec<RefEdit>> {
     let mut edits = Vec::new();
     let mut rollback = Vec::new();
-    for reference in repo.references()?.all()? {
-        let reference = match reference {
-            Ok(reference) => reference,
-            Err(err) if is_missing_ref(&*err) => continue,
-            Err(err) => anyhow::bail!("could not inspect a reference before rebasing: {err}"),
-        };
-        if matches!(
-            reference.name().category(),
-            Some(Category::Tag | Category::RemoteBranch)
-        ) {
-            continue;
+    if let Some(expected_refs) = expected_refs {
+        for ExpectedRef { name, old } in expected_refs {
+            let Some(new) = rewritten.get(&old) else { continue };
+            edits.push(ref_edit(name.clone(), old, *new));
+            rollback.push(reverse_ref_edit(name, old, *new));
+        }
+    } else {
+        for reference in repo.references()?.all()? {
+            let reference = match reference {
+                Ok(reference) => reference,
+                Err(err) if is_missing_ref(&*err) => continue,
+                Err(err) => anyhow::bail!("could not inspect a reference before rebasing: {err}"),
+            };
+            if matches!(
+                reference.name().category(),
+                Some(Category::Tag | Category::RemoteBranch)
+            ) {
+                continue;
+            }
+            let Some(old) = reference.try_id().map(gix::Id::detach) else {
+                continue;
+            };
+            let Some(new) = rewritten.get(&old) else { continue };
+            let name = reference.name().to_owned();
+            edits.push(ref_edit(name.clone(), old, *new));
+            rollback.push(reverse_ref_edit(name, old, *new));
+        }
+        if let Some(head) = repo.try_find_reference("HEAD")?
+            && let Some(old) = head.try_id().map(gix::Id::detach)
+            && let Some(new) = rewritten.get(&old)
+        {
+            let name = head.name().to_owned();
+            edits.push(ref_edit(name.clone(), old, *new));
+            rollback.push(reverse_ref_edit(name, old, *new));
         }
-        let Some(old) = reference.try_id().map(gix::Id::detach) else {
-            continue;
-        };
-        let Some(new) = rewritten.get(&old) else { continue };
-        let name = reference.name().to_owned();
-        edits.push(ref_edit(name.clone(), old, *new));
-        rollback.push(reverse_ref_edit(name, old, *new));
-    }
-    if let Some(head) = repo.try_find_reference("HEAD")?
-        && let Some(old) = head.try_id().map(gix::Id::detach)
-        && let Some(new) = rewritten.get(&old)
-    {
-        let name = head.name().to_owned();
-        edits.push(ref_edit(name.clone(), old, *new));
-        rollback.push(reverse_ref_edit(name, old, *new));
     }
     if unborn {
         let name = repo
@@ -781,6 +1055,28 @@ fn update_refs(
             },
         });
     }
+    let mut reserved = HashSet::new();
+    for id in pins {
+        let name = pin_name(repo, *id, &reserved)?;
+        reserved.insert(name.clone());
+        edits.push(RefEdit {
+            name: name.clone(),
+            deref: false,
+            change: Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustNotExist,
+                new: Target::Object(*id),
+            },
+        });
+        rollback.push(RefEdit {
+            name,
+            deref: false,
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(Target::Object(*id)),
+                log: RefLog::AndReference,
+            },
+        });
+    }
     if edits.is_empty() {
         anyhow::bail!("no mutable reference points to an affected commit");
     }
@@ -790,6 +1086,36 @@ fn update_refs(
     Ok(rollback)
 }
 
+fn pin_name(
+    repo: &gix::Repository,
+    id: ObjectId,
+    reserved: &HashSet<gix::refs::FullName>,
+) -> Result<gix::refs::FullName> {
+    let hex = id.to_hex().to_string();
+    let mut len = 8.min(hex.len());
+    let mut number = 2;
+    loop {
+        let suffix = if len <= hex.len() {
+            hex[..len].to_owned()
+        } else {
+            let suffix = format!("{hex}{number}");
+            number += 1;
+            suffix
+        };
+        let name: gix::refs::FullName = format!("{}{}", String::from_utf8_lossy(crate::history::PIN_PREFIX), suffix)
+            .try_into()
+            .context("generated an invalid tix pin name")?;
+        if !reserved.contains(&name) && repo.try_find_reference(name.as_ref())?.is_none() {
+            return Ok(name);
+        }
+        if len < hex.len() {
+            len += 1;
+        } else {
+            len = hex.len() + 1;
+        }
+    }
+}
+
 fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
     loop {
         if err
@@ -1090,4 +1416,164 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn a_todo_rebase_eagerly_replays_only_the_checkout_ancestry_and_pins_a_new_leaf() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let old_middle_tree = repo.find_commit(middle)?.tree_id()?.detach();
+        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![
+                    PlanStep {
+                        parent: PlanParent::Existing(base),
+                        commit: PlanCommit::Pick(tip),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Pick(middle),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(1),
+                        commit: PlanCommit::Empty("checkpoint".into()),
+                    },
+                ],
+                checkout: Some(0),
+                expected_refs,
+            },
+        )?
+        .complete()?;
+        let new_tip = outcome.map(tip).context("the picked tip is retained")?;
+        let new_middle = outcome.map(middle).context("the picked middle is retained")?;
+        assert_eq!(
+            repo.head_id()?.detach(),
+            new_tip,
+            "the branch follows its rewritten commit"
+        );
+        let tip_commit = repo.find_commit(new_tip)?.decode()?.into_owned()?;
+        assert!(!has_marker(&tip_commit), "the checkout ancestry is eagerly replayed");
+        assert_eq!(tip_commit.parents.first().copied(), Some(base));
+        let middle_commit = repo.find_commit(new_middle)?.decode()?.into_owned()?;
+        assert!(
+            has_marker(&middle_commit),
+            "history outside the checkout ancestry stays lazy"
+        );
+        assert_eq!(
+            middle_commit.tree, old_middle_tree,
+            "a lazy rewrite keeps its original tree"
+        );
+        assert_eq!(middle_commit.parents.first().copied(), Some(new_tip));
+
+        let pins = crate::history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "the unreferenced new empty leaf receives one pin");
+        let empty = repo.find_commit(pins[0].id)?.decode()?.into_owned()?;
+        assert_eq!(
+            empty.message, b"checkpoint",
+            "the complete empty-commit title becomes its message"
+        );
+        assert!(has_marker(&empty), "an empty commit outside @ remains lazy");
+        assert_eq!(empty.parents.first().copied(), Some(new_middle));
+        assert_eq!(
+            empty.tree, middle_commit.tree,
+            "the empty commit reuses its parent tree"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn a_todo_rebase_uses_the_reference_snapshot_from_before_editing() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["update-ref", "refs/heads/main", &base.to_string(), &tip.to_string()])
+                .status()?
+                .success(),
+            "the branch moves while the editor is open"
+        );
+
+        let err = match perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                }],
+                checkout: None,
+                expected_refs,
+            },
+        ) {
+            Ok(_) => return Err("the stale reference snapshot must fail its compare-and-swap".into()),
+            Err(err) => err,
+        };
+        assert_eq!(
+            repo.find_reference("refs/heads/main")?.id().detach(),
+            base,
+            "a concurrent branch update wins"
+        );
+        assert!(
+            format!("{err:#}").contains("reference"),
+            "the failure identifies reference persistence: {err:#}"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn dropping_a_pick_moves_its_mutable_refs_to_the_nearest_retained_ancestor() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        repo.reference(
+            "refs/patches/example",
+            middle,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test reference",
+        )?;
+        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+
+        perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                }],
+                checkout: None,
+                expected_refs,
+            },
+        )?
+        .complete()?;
+        assert_eq!(
+            repo.find_reference("refs/patches/example")?.id().detach(),
+            base,
+            "the dropped commit's ref does not keep the old history alive"
+        );
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 6de6b0c172b..794e06c35b0 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -41,6 +41,34 @@ pub(crate) struct Conflict {
 }
 
 impl Conflict {
+    pub(crate) fn from_rebase(repository_path: &Path, bare: bool, rebase: super::rebase::Conflict) -> Result<Self> {
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not open a worktree for conflict resolution")?;
+        let workdir = repository
+            .workdir()
+            .context("a conflicting rebase requires a worktree")?
+            .to_owned();
+        let head = repository
+            .head()
+            .context("could not read HEAD before conflict resolution")?;
+        let head_id = head
+            .id()
+            .map(gix::Id::detach)
+            .context("conflict resolution requires a born HEAD")?;
+        let saved_target = head
+            .referent_name()
+            .map(ToOwned::to_owned)
+            .map_or(Target::Object(head_id), Target::Symbolic);
+        Ok(Conflict {
+            rebase,
+            repository_path: repository_path.to_owned(),
+            bare,
+            workdir,
+            saved_target,
+            head: head_id,
+        })
+    }
+
     pub(crate) fn original(&self) -> ObjectId {
         self.rebase.original()
     }
@@ -84,6 +112,82 @@ impl Conflict {
     }
 }
 
+pub(crate) fn checkout_without_replay(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<Option<String>> {
+    let repository =
+        open_repository(repository_path, bare, false).context("could not open repository for rebase checkout")?;
+    let workdir = repository
+        .workdir()
+        .context("the rebase todo selected a checkout without a worktree")?
+        .to_owned();
+    let head = repository
+        .head()
+        .context("could not read HEAD before rebase checkout")?;
+    let head_id = head
+        .id()
+        .map(gix::Id::detach)
+        .context("cannot move an unborn HEAD after rebasing")?;
+    let head_referent = head.referent_name().map(ToOwned::to_owned);
+    drop(head);
+    if selected == head_id {
+        return Ok(None);
+    }
+    if let Some(pin) = selected_pin(&repository, selected)? {
+        drop(repository);
+        checkout_pin(&workdir, &pin)?;
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not reopen repository after returning through a pin")?;
+        return Ok(Some(match delete_pin(&repository, &pin) {
+            Ok(()) => format!("returned from {}", pin_label(&pin)),
+            Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
+        }));
+    }
+    let saved_target = head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id));
+    let provisional = contains(&repository, selected, head_id)
+        .then(|| create_or_reuse_pin(&repository, saved_target, head_id))
+        .transpose()?;
+    drop(repository);
+    if let Err(checkout) = checkout_detached(&workdir, selected) {
+        if let Some((pin, true)) = &provisional {
+            let cleanup = open_repository(repository_path, bare, false)
+                .context("could not reopen repository to remove a provisional pin")
+                .and_then(|repository| delete_pin(&repository, pin));
+            if let Err(cleanup) = cleanup {
+                return Err(checkout.context(format!(
+                    "checkout failed and {} could not be removed: {cleanup:#}",
+                    pin_label(pin)
+                )));
+            }
+        }
+        return Err(checkout);
+    }
+    let mut notice = format!("time-travelled to {}", selected.to_hex_with_len(7));
+    if let Some((pin, true)) = provisional {
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not reopen repository after rebase time-travel")?;
+        let snapshot =
+            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
+        if snapshot
+            .view_tips
+            .iter()
+            .copied()
+            .any(|tip| contains(&repository, head_id, tip))
+        {
+            if let Err(err) = delete_pin(&repository, &pin) {
+                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
+            }
+        } else {
+            notice = format!("{notice}; saved {}", pin_label(&pin));
+        }
+    }
+    Ok(Some(notice))
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %selected))]
 pub(crate) fn perform(
     repository_path: &Path,
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
new file mode 100644
index 00000000000..2227a1a740a
--- /dev/null
+++ b/gix-tix/src/edit/todo.rs
@@ -0,0 +1,382 @@
+use std::collections::{HashMap, HashSet};
+
+use anyhow::{Context, Result};
+use gix::{ObjectId, bstr::BString, prelude::ObjectIdExt};
+
+use super::rebase;
+
+pub(crate) struct Commit {
+    pub id: ObjectId,
+    pub parents: Vec<ObjectId>,
+    pub info: String,
+}
+
+pub(crate) struct Prepared {
+    pub editor: std::ffi::OsString,
+    pub document: Vec<u8>,
+    base: ObjectId,
+    scope: Vec<ObjectId>,
+    marker_required: bool,
+    checkout_allowed: bool,
+    expected_refs: Vec<rebase::ExpectedRef>,
+}
+
+struct Section {
+    parent: ObjectId,
+    commits: Vec<ObjectId>,
+}
+
+#[tracing::instrument(skip_all, fields(base = %base, commits = commits.len()))]
+pub(crate) fn prepare(
+    repo: &gix::Repository,
+    base: ObjectId,
+    commits: &[Commit],
+    head: Option<ObjectId>,
+) -> Result<Prepared> {
+    let editor = repo.editor().context("no Git editor is available")?;
+    repo.find_commit(base)
+        .context("could not find the selected rebase base")?;
+    let scope: Vec<_> = commits.iter().map(|commit| commit.id).collect();
+    let scope_set: HashSet<_> = scope.iter().copied().collect();
+    let marker_required = head.is_some_and(|head| scope_set.contains(&head));
+    let expected_refs = rebase::capture_refs(repo, &scope)?;
+
+    let mut children = HashMap::<ObjectId, Vec<ObjectId>>::new();
+    let by_id: HashMap<_, _> = commits.iter().map(|commit| (commit.id, commit)).collect();
+    for commit in commits {
+        let parent = commit
+            .parents
+            .first()
+            .copied()
+            .context("an editable commit has no parent")?;
+        if parent != base && !scope_set.contains(&parent) {
+            anyhow::bail!("an editable commit is not connected to the selected base");
+        }
+        children.entry(parent).or_default().push(commit.id);
+    }
+    let mut sections = Vec::new();
+    for child in children.get(&base).into_iter().flatten().copied() {
+        let mut section = Section {
+            parent: base,
+            commits: Vec::new(),
+        };
+        let mut branches = Vec::new();
+        walk(child, &children, &mut section, &mut branches);
+        sections.push(section);
+        sections.extend(branches);
+    }
+
+    let mut document = format!(
+        "# Rebase from `{}`\n\n<!-- Reorder or delete pick lines. Add `## fork <id>` headings or `empty <title>` commits. Move `@` to choose the checkout. -->\n\n",
+        short(repo, base)?
+    )
+    .into_bytes();
+    for (section_index, section) in sections.iter().enumerate() {
+        if section_index > 0 {
+            document.push(b'\n');
+        }
+        document.extend_from_slice(format!("## fork {}\n", short(repo, section.parent)?).as_bytes());
+        for id in &section.commits {
+            let commit = by_id[id];
+            let verb = if Some(*id) == head { "@pick" } else { "pick" };
+            document.extend_from_slice(
+                format!("`{verb} {}` {}\n", short(repo, *id)?, escape_markdown(&commit.info)).as_bytes(),
+            );
+        }
+    }
+    if sections.is_empty() {
+        document.extend_from_slice(format!("## fork {}\n", short(repo, base)?).as_bytes());
+    }
+    Ok(Prepared {
+        editor,
+        document,
+        base,
+        scope,
+        marker_required,
+        checkout_allowed: repo.workdir().is_some(),
+        expected_refs,
+    })
+}
+
+fn walk(id: ObjectId, children: &HashMap<ObjectId, Vec<ObjectId>>, section: &mut Section, sections: &mut Vec<Section>) {
+    section.commits.push(id);
+    let Some(child_ids) = children.get(&id) else { return };
+    if let Some(first) = child_ids.first() {
+        walk(*first, children, section, sections);
+    }
+    for child in child_ids.iter().skip(1) {
+        let mut branch = Section {
+            parent: id,
+            commits: Vec::new(),
+        };
+        let mut nested = Vec::new();
+        walk(*child, children, &mut branch, &mut nested);
+        sections.push(branch);
+        sections.extend(nested);
+    }
+}
+
+fn short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+    Ok(id
+        .attach(repo)
+        .shorten()
+        .context("could not shorten a rebase todo ID")?
+        .to_string())
+}
+
+fn escape_markdown(input: &str) -> String {
+    let mut out = String::with_capacity(input.len());
+    for ch in input.chars() {
+        if matches!(ch, '\\' | '`' | '*' | '_' | '[' | ']' | '<' | '>') {
+            out.push('\\');
+        }
+        out.push(ch);
+    }
+    out
+}
+
+pub(crate) fn parse(repo: &gix::Repository, prepared: Prepared, edited: &[u8]) -> Result<rebase::Plan> {
+    let input = std::str::from_utf8(edited).context("the rebase todo is not UTF-8")?;
+    let scope: HashSet<_> = prepared.scope.iter().copied().collect();
+    let mut picked = HashMap::<ObjectId, usize>::new();
+    let mut steps = Vec::new();
+    let mut cursor = None;
+    let mut checkout = None;
+    let mut marker_count = 0;
+    let mut sections = 0;
+    let mut section_has_commit = false;
+    let mut in_comment = false;
+
+    for raw in input.lines() {
+        let line = raw.trim();
+        if in_comment {
+            if line.contains("-->") {
+                in_comment = false;
+            }
+            continue;
+        }
+        if line.starts_with("<!--") {
+            in_comment = !line.contains("-->");
+            continue;
+        }
+        if line.is_empty() || line.starts_with("# ") {
+            continue;
+        }
+        if let Some(target) = line.strip_prefix("## fork ") {
+            if sections > 0 && !section_has_commit {
+                anyhow::bail!("a fork section contains no commits");
+            }
+            let id = resolve_commit(
+                repo,
+                target
+                    .split_whitespace()
+                    .next()
+                    .context("a fork heading needs a commit ID")?,
+            )?;
+            cursor = Some(if let Some(index) = picked.get(&id) {
+                rebase::PlanParent::Step(*index)
+            } else if scope.contains(&id) {
+                anyhow::bail!("a fork target must be picked before it is used");
+            } else {
+                rebase::PlanParent::Existing(id)
+            });
+            sections += 1;
+            section_has_commit = false;
+            continue;
+        }
+
+        let (command, tail) = if let Some(line) = line.strip_prefix('`') {
+            let (command, tail) = line
+                .split_once('`')
+                .context("a Markdown todo command has no closing backtick")?;
+            (command, tail.trim())
+        } else {
+            (line, "")
+        };
+        let (verb, value) = command.split_once(char::is_whitespace).unwrap_or((command, ""));
+        let marked = verb.starts_with('@');
+        let verb = verb.strip_prefix('@').unwrap_or(verb);
+        if marked {
+            marker_count += 1;
+            if marker_count > 1 {
+                anyhow::bail!("the rebase todo contains more than one @ marker");
+            }
+            if !prepared.checkout_allowed {
+                anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
+            }
+        }
+        let parent = cursor.context("the first todo command must follow a fork heading")?;
+        let commit = match verb {
+            "pick" => {
+                let id = resolve_commit(
+                    repo,
+                    value.split_whitespace().next().context("a pick needs a commit ID")?,
+                )?;
+                if !scope.contains(&id) {
+                    anyhow::bail!("a pick is outside the editable history");
+                }
+                if picked.contains_key(&id) {
+                    anyhow::bail!("a commit is picked more than once");
+                }
+                rebase::PlanCommit::Pick(id)
+            }
+            "empty" => {
+                let title = if value.trim().is_empty() { tail } else { value.trim() };
+                if title.is_empty() {
+                    anyhow::bail!("an empty commit needs a title");
+                }
+                rebase::PlanCommit::Empty(BString::from(title))
+            }
+            _ => anyhow::bail!("unsupported rebase todo command {verb:?}"),
+        };
+        let index = steps.len();
+        if let rebase::PlanCommit::Pick(id) = commit {
+            picked.insert(id, index);
+        }
+        steps.push(rebase::PlanStep { parent, commit });
+        cursor = Some(rebase::PlanParent::Step(index));
+        if marked {
+            checkout = Some(index);
+        }
+        section_has_commit = true;
+    }
+    if sections == 0 {
+        anyhow::bail!("the rebase todo has no fork heading");
+    }
+    if sections > 1 && !section_has_commit {
+        anyhow::bail!("the last fork section contains no commits");
+    }
+    if prepared.marker_required && marker_count != 1 {
+        anyhow::bail!("the current checkout marker must be retained");
+    }
+    Ok(rebase::Plan {
+        base: prepared.base,
+        scope: prepared.scope,
+        steps,
+        checkout,
+        expected_refs: prepared.expected_refs,
+    })
+}
+
+fn resolve_commit(repo: &gix::Repository, value: &str) -> Result<ObjectId> {
+    if value.len() < 4 || !value.bytes().all(|byte| byte.is_ascii_hexdigit()) {
+        anyhow::bail!("{value:?} is not a commit ID prefix");
+    }
+    let id = repo
+        .rev_parse_single(value)
+        .with_context(|| format!("could not resolve commit ID {value:?}"))?;
+    id.object()
+        .context("could not load a todo object")?
+        .try_into_commit()
+        .context("a todo ID does not name a commit")?;
+    Ok(id.detach())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn repo() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "core.abbrev=7".to_owned(),
+                "user.name=todo author".to_owned(),
+                "user.email=todo@example.com".to_owned(),
+            ]),
+        )?;
+        Ok((fixture, repo))
+    }
+
+    fn commits(repo: &gix::Repository) -> gix_testtools::Result<(ObjectId, ObjectId, ObjectId, Vec<Commit>)> {
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        Ok((
+            base,
+            middle,
+            tip,
+            vec![
+                Commit {
+                    id: tip,
+                    parents: vec![middle],
+                    info: "(main) 2000-01-03 author tip".into(),
+                },
+                Commit {
+                    id: middle,
+                    parents: vec![base],
+                    info: "2000-01-02 author middle * markdown".into(),
+                },
+            ],
+        ))
+    }
+
+    #[test]
+    fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, _middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let document = String::from_utf8(prepared.document.clone())?;
+        assert!(document.starts_with(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!("## fork {}", base.to_hex_with_len(7))));
+        let middle = document.find("`pick ").expect("the oldest pick is shown");
+        let tip = document.find("`@pick ").expect("HEAD is marked");
+        assert!(middle < tip, "the todo grows from the base towards the tip");
+        assert!(
+            document.contains("middle \\* markdown"),
+            "metadata is escaped for Markdown"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn parses_reordering_forks_empty_commits_and_a_moved_checkout() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let edited = format!(
+            "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
+            base.to_hex_with_len(7),
+            tip.to_hex_with_len(7),
+            tip.to_hex_with_len(7),
+            middle.to_hex_with_len(7),
+        );
+        let err = parse(&repo, prepared, edited.as_bytes()).expect_err("two checkout markers are invalid");
+        assert!(format!("{err:#}").contains("more than one @"));
+
+        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let edited = format!(
+            "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
+            base.to_hex_with_len(7),
+            tip.to_hex_with_len(7),
+            tip.to_hex_with_len(7),
+            middle.to_hex_with_len(7),
+        );
+        let plan = parse(&repo, prepared, edited.as_bytes())?;
+        assert_eq!(plan.steps.len(), 3);
+        assert_eq!(plan.checkout, Some(2));
+        assert_eq!(plan.steps[2].parent, rebase::PlanParent::Step(0));
+        assert!(matches!(&plan.steps[1].commit, rebase::PlanCommit::Empty(title) if title == b"a new checkpoint"));
+        Ok(())
+    }
+
+    #[test]
+    fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, _middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let edited = format!("## fork {}\n", base.to_hex_with_len(7));
+        let err = parse(&repo, prepared, edited.as_bytes()).expect_err("HEAD must be moved before its pick is dropped");
+        assert!(format!("{err:#}").contains("checkout marker"));
+
+        let prepared = prepare(&repo, base, &commits, None)?;
+        let plan = parse(&repo, prepared, edited.as_bytes())?;
+        assert!(
+            plan.steps.is_empty(),
+            "all picks may be dropped when no marker is required"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 947bbe10b2e..93eaaf176e7 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1926,6 +1926,87 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("forget: {err:#}")),
                     }
                 }
+                Effect::Rebase { base, commits, head } => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let todo_commits = commits
+                        .iter()
+                        .map(|id| {
+                            let row = app
+                                .rows
+                                .iter()
+                                .find(|row| row.id == *id)
+                                .context("an editable commit disappeared from the view")?;
+                            Ok(edit::todo::Commit {
+                                id: *id,
+                                parents: row.parent_ids.to_vec(),
+                                info: ui::todo_metadata(&app, row, &decorations, &mailmap),
+                            })
+                        })
+                        .collect::<Result<Vec<_>>>();
+                    let result = history_graph
+                        .as_ref()
+                        .context("rebasing requires a completed history graph")
+                        .and_then(|graph| {
+                            rebase_history(
+                                terminal,
+                                &repository_path,
+                                repository_is_bare,
+                                graph,
+                                base,
+                                todo_commits?,
+                                head,
+                                enhanced_keyboard,
+                            )
+                        });
+                    match result {
+                        Ok(Some(edit::rebase::Perform::Complete(outcome))) => {
+                            let checkout = outcome.selected;
+                            let notice = checkout
+                                .map(|selected| {
+                                    edit::time_travel::checkout_without_replay(
+                                        &repository_path,
+                                        repository_is_bare,
+                                        selected,
+                                        &revisions,
+                                        worktrees,
+                                    )
+                                })
+                                .transpose()
+                                .map(Option::flatten);
+                            match notice {
+                                Ok(notice) => {
+                                    app.leave_message(notice.unwrap_or_else(|| "rebased history".to_owned()));
+                                    app.select_commit_after_refresh(base);
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                                Err(err) => {
+                                    app.leave_message(format!("rebase applied, checkout failed: {err:#}"));
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                            }
+                        }
+                        Ok(Some(edit::rebase::Perform::Conflict(conflict))) => {
+                            match edit::time_travel::Conflict::from_rebase(
+                                &repository_path,
+                                repository_is_bare,
+                                conflict,
+                            ) {
+                                Ok(conflict) => {
+                                    let original = conflict.original();
+                                    app.arm_rebase_conflict(original);
+                                    app.select_commit(original);
+                                    pending_rebase_conflict = Some(conflict);
+                                }
+                                Err(err) => app.leave_message(format!("rebase conflict: {err:#}")),
+                            }
+                        }
+                        Ok(None) => app.leave_message("no rebase performed: the todo was unchanged"),
+                        Err(err) => app.leave_message(format!("rebase: {err:#}")),
+                    }
+                }
                 Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2959,6 +3040,44 @@ fn reword_commit(
     edit::reword::apply(repository, graph, id, &edited)
 }
 
+#[tracing::instrument(skip_all, fields(base = %base, commits = commits.len()))]
+#[expect(
+    clippy::too_many_arguments,
+    reason = "the editor bridges terminal, repository, and selected view state"
+)]
+fn rebase_history(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    graph: &HistoryGraph,
+    base: gix::ObjectId,
+    commits: Vec<edit::todo::Commit>,
+    head: Option<gix::ObjectId>,
+    enhanced_keyboard: bool,
+) -> Result<Option<edit::rebase::Perform>> {
+    let prepared = {
+        let mut repository =
+            open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;
+        repository.object_cache_size(None);
+        edit::todo::prepare(&repository, base, &commits, head)?
+    };
+    let Some(edited) = edit::edit_document(
+        terminal,
+        &prepared.editor,
+        &prepared.document,
+        &format!("tix-rebase-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?
+    else {
+        return Ok(None);
+    };
+    let mut repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing rebase")?;
+    repository.object_cache_size(None);
+    let plan = edit::todo::parse(&repository, prepared, &edited)?;
+    edit::rebase::perform_plan(&repository, graph, plan).map(Some)
+}
+
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
@@ -3731,6 +3850,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
         KeyCode::Char('c') => Some(Action::ToggleChanges),
         KeyCode::Char('p') if edit_expanded => Some(Action::Split),
+        KeyCode::Char('b') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -4736,6 +4856,7 @@ mod tests {
             "v closes the view shortcut group"
         );
         for (key, expected) in [
+            ('b', Action::Rebase),
             ('r', Action::Reword),
             ('n', Action::NewCommit),
             ('a', Action::Amend),
@@ -4750,6 +4871,11 @@ mod tests {
                 "{key} is available after the edit prefix"
             );
         }
+        assert_eq!(
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL), false, true,),
+            Some(Action::PageUp),
+            "navigation keeps priority over the edit shortcut"
+        );
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE), false, true),
             Some(Action::ToggleEdit),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 31fe4658304..5f0886d763f 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -744,6 +744,9 @@ pub(crate) fn draw_with_worktree(
         };
         if app.edit_expanded {
             let mut options = Vec::new();
+            if app.can_rebase() {
+                options.push(("rebase", 'b'));
+            }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'r'));
             }
@@ -1728,6 +1731,49 @@ fn metadata_line<'a>(
     Line::from(spans)
 }
 
+pub(crate) fn todo_metadata(
+    app: &App,
+    row: &CommitRow,
+    decorations: &Decorations,
+    mailmap: &gix::mailmap::Snapshot,
+) -> String {
+    let title = app.title(row);
+    let line = metadata_line(
+        row,
+        title,
+        app.attributions(row),
+        decorations,
+        mailmap,
+        MetadataOptions {
+            show_committer_date: app.show_committer_date,
+            show_author_name: app.name_mode != crate::app::NameMode::None,
+            show_emails: app.show_emails,
+            show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
+            has_notes: !app.notes(row.id).is_empty(),
+            use_mailmap: app.use_mailmap,
+            ref_mode: app.ref_mode,
+            selected: false,
+            preview_author_copy: false,
+            copy_feedback: None,
+        },
+    );
+    let mut out = line
+        .spans
+        .into_iter()
+        .skip(1)
+        .map(|span| span.content.into_owned())
+        .collect::<String>()
+        .trim()
+        .to_owned();
+    if app.show_emails {
+        if !out.is_empty() {
+            out.push(' ');
+        }
+        out.push_str(&title.to_str_lossy());
+    }
+    out
+}
+
 fn author_label(
     author: &crate::app::Author,
     mailmap: &gix::mailmap::Snapshot,
@@ -4418,6 +4464,7 @@ mod tests {
         };
         let mut app = App::new(2);
         app.extend_commits(vec![commit(1)]);
+        std::sync::Arc::make_mut(&mut app.rows[0]).parent_ids = [gix::ObjectId::Sha1([2; 20])].into_iter().collect();
         app.extend_hidden_commits(vec![commit(2)]);
         complete(&mut app);
         app.select_commit(gix::ObjectId::Sha1([2; 20]));
@@ -4509,11 +4556,16 @@ mod tests {
         );
 
         let mut narrow = Terminal::new(TestBackend::new(28, 3))?;
+        app.edit_expanded = true;
         narrow.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
             rendered_line(&narrow, 1).ends_with(" ⇣2 "),
             "the terminal edge pushes the marker over clipped title text"
         );
+        assert!(
+            rendered_line(&narrow, 2).contains("edit (rebase)"),
+            "the selected hidden base offers only its rebase edit"
+        );
         Ok(())
     }
 

From df1ab2b6791ab1de85ef0ac3c3c2de788a78e970 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 06:08:00 +0200
Subject: [PATCH 077/282] feat: fork commits from any tix history entry

Allow hidden boundaries, merges, and ordinary commits to become parents of an independent commit without rewriting their descendants. Reuse new-commit preparation and signing, retain the new leaf with a temporary tix pin, and automatically time-travel to it.

Centralize HEAD movement and pin reconciliation so ordinary time travel, post-rebase checkout, fork checkout, and conflict acceptance preserve departures, consume destination pins, and clean up redundant pins consistently.
---
 gix-tix/spec.md                 |  37 +++-
 gix-tix/src/app.rs              |  31 +++-
 gix-tix/src/edit/create.rs      |  69 +++++++
 gix-tix/src/edit/rebase.rs      |  47 +++--
 gix-tix/src/edit/time_travel.rs | 307 +++++++++++++++-----------------
 gix-tix/src/lib.rs              |  83 ++++++++-
 gix-tix/src/ui.rs               |  12 +-
 7 files changed, 381 insertions(+), 205 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index dbd8f156a1e..fcc3226585e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -57,8 +57,9 @@ without trading responsiveness for metadata that is not visible.
   that connect visible history to hidden history remain as boundary rows.
 - Boundary rows retain graph styling but use terminal-default colors, are dimmed,
   and can be selected, paged to, restored as a selection, copied, and inspected.
-  They cannot be reworded, forgotten, signature-verified, or used for time travel,
-  and Shift navigation continues to skip them. A boundary whose visible
+  They cannot be reworded, forgotten, or signature-verified, and Shift navigation
+  continues to skip them. They may be used for time travel or as the parent of an
+  independent fork commit. A boundary whose visible
   descendants contain no merge commit offers the history-rebase editor, including
   when those descendants fork into multiple linear stacks.
 - If a boundary has exactly one leaf among its visible descendants, selecting it
@@ -187,9 +188,10 @@ The Enter key is written as `<enter>` throughout.
 
 - On a completed, focused history in a worktree repository, `t` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
-- If the selected commit is known to be an ancestor of the previous `HEAD`, tix
-  retains descendants that would otherwise leave the view with a
-  `refs/tix/pins/<suffix>` ref. Pins use at least four alphanumeric characters;
+- Before every move, tix provisionally retains the previous `HEAD` with a
+  `refs/tix/pins/<suffix>` ref. After a successful checkout it removes that pin
+  when the old `HEAD` remains reachable from another view tip, and retains it
+  otherwise. Pins use at least four alphanumeric characters;
   generated pins start with eight hexadecimal characters from the saved commit.
 - A pin is symbolic when the previous `HEAD` named a local branch, so later branch
   advances move the pinned tip. An already detached `HEAD` receives a direct pin.
@@ -201,9 +203,12 @@ The Enter key is written as `<enter>` throughout.
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
-- Checkout failures retain the original `HEAD` and remove any newly created
-  provisional pin. Successful travel preserves the selected row, refreshes
-  history directly, and invalidates worktree status.
+- Checkout failures retain the original `HEAD`, remove only a newly created
+  source pin, and leave destination pins intact. Successful travel consumes a
+  destination pin and applies the same source-pin reconciliation for ancestor,
+  descendant, and sideways moves. Conflict acceptance, history-rebase checkout,
+  and automatic fork travel use this same primitive. Successful travel preserves
+  the selected row, refreshes history directly, and invalidates worktree status.
 
 ### Held Shift ancestry mode
 
@@ -354,6 +359,20 @@ space first; changes blocks adapt within the remaining history width.
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
   inaccessible or conflicting affected worktrees abort safely.
 
+### Fork commits
+
+- `e f` creates an independent child of any selected commit, including a hidden
+  boundary or merge commit. It requires completed history and a live,
+  conflict-free worktree, but unlike `e n` it is not restricted by descendants
+  because it rewrites none of them. It is unavailable for unborn history.
+- Fork preparation reuses the new-commit editor, candidate-tree, identity, and
+  signing rules. Saving writes only the new commit and a temporary direct
+  `refs/tix/pins/*` ref; existing refs, descendants, indexes, and worktrees do not
+  move during creation.
+- Tix immediately time-travels to the new fork. A successful checkout consumes
+  its temporary pin and reconciles the departed `HEAD` through the standard pin
+  primitive. If checkout fails, the fork remains pinned and visible.
+
 ### Amend, spill, and split
 
 - `e a` amends the current worktree's `@` commit with the changed index, or
@@ -466,7 +485,7 @@ space first; changes blocks adapt within the remaining history width.
 ### Editing shortcuts
 
 - `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base,
-  `e r` rewords, `e n` creates a commit,
+  `e r` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   `e d d` confirms forgetting a top commit, and `e t` enters or returns from
   time travel when each action is available.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index be56f8ecc04..e65d8553774 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -294,6 +294,7 @@ pub(crate) enum Action {
     OpenDiff,
     Reword,
     NewCommit,
+    ForkCommit,
     Amend,
     Spill,
     Split,
@@ -321,6 +322,7 @@ pub(crate) enum Effect {
     OpenCommitDiff(TreeDiffTarget),
     Reword(ObjectId),
     NewCommit(Option<ObjectId>),
+    ForkCommit(ObjectId),
     Amend(ObjectId),
     Spill(ObjectId),
     Split(ObjectId),
@@ -763,6 +765,7 @@ impl App {
             Action::ToggleEdit
                 | Action::Reword
                 | Action::NewCommit
+                | Action::ForkCommit
                 | Action::Amend
                 | Action::Spill
                 | Action::Split
@@ -942,6 +945,11 @@ impl App {
                     self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
                 )];
             }
+            Action::ForkCommit if self.can_fork_commit() => {
+                return vec![Effect::ForkCommit(
+                    self.rows[self.selected.expect("fork requires a selection")].id,
+                )];
+            }
             Action::Amend if self.can_amend() => {
                 return vec![Effect::Amend(
                     self.rows[self.selected.expect("amend requires a selection")].id,
@@ -1557,6 +1565,16 @@ impl App {
             }
     }
 
+    pub(crate) fn can_fork_commit(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && !self.worktree_conflicted
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.selected.and_then(|index| self.rows.get(index)).is_some()
+    }
+
     pub(crate) fn can_forget(&self) -> bool {
         self.state == State::Complete
             && self.changes_focus.is_none()
@@ -1629,10 +1647,7 @@ impl App {
             && !self.worktree_conflicted
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self
-                .selected
-                .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| !self.hidden_rows.contains(&row.id))
+            && self.selected.and_then(|index| self.rows.get(index)).is_some()
     }
 
     fn last_selectable(&self) -> Option<usize> {
@@ -2426,6 +2441,8 @@ mod tests {
             !app.can_create_commit(),
             "a merge descendant outside the visible projection prevents a child"
         );
+        assert!(app.can_fork_commit(), "a fork does not rewrite merge descendants");
+        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(2))]);
 
         let mut unborn = App::new(10);
         unborn.set_worktree_head_unborn(true);
@@ -2435,6 +2452,7 @@ mod tests {
             "an unborn worktree can create its root commit"
         );
         assert_eq!(unborn.update(Action::NewCommit), vec![Effect::NewCommit(None)]);
+        assert!(!unborn.can_fork_commit(), "a fork requires a selected parent");
     }
 
     #[test]
@@ -2767,7 +2785,7 @@ mod tests {
     }
 
     #[test]
-    fn hidden_boundary_rows_are_selectable_for_inspection_only() {
+    fn hidden_boundary_rows_are_selectable_for_inspection_and_independent_edits() {
         let mut app = App::new(4);
         app.extend_commits(vec![row(1), row(2), row(3)]);
         app.extend_hidden_commits(vec![row(4)]);
@@ -2780,6 +2798,9 @@ mod tests {
         assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(id(4))]);
         assert!(!app.can_reword());
         assert!(!app.can_forget());
+        assert!(app.can_fork_commit());
+        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(4))]);
+        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(4))]);
         assert!(
             app.update(Action::VerifySignatures).is_empty(),
             "hidden signatures are not actionable"
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index b90c4d7af0a..6cfcb902fb5 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -214,6 +214,28 @@ pub(crate) fn apply(
     .context("inserting a commit did not produce a selection")
 }
 
+#[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
+pub(crate) fn apply_fork(
+    mut repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    mut prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
+    let parent = prepared.parent.context("a fork commit requires a parent")?;
+    let commit = commit_from_edit(&prepared, edited)?;
+    rebase::perform(
+        &repo,
+        graph,
+        rebase::Edit::Fork { anchor: parent, commit },
+        rebase::Signature::RedoIfNeeded,
+        rebase::Tree::LeaveAsIs,
+    )?
+    .complete()?
+    .selected
+    .context("forking a commit did not produce a selection")
+}
+
 pub(super) fn commit_from_edit(prepared: &Prepared, edited: &[u8]) -> Result<gix::objs::Commit> {
     let edit = reword::parse(edited)?;
     if edit.message.is_empty() {
@@ -390,6 +412,53 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn fork_creates_an_independent_pinned_child_then_time_travels_to_it() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let repository = open(fixture.path())?;
+        let main = repository.head_id()?.detach();
+        let parent = main;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"fork\n\nreason", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let fork = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
+
+        let repository = open(fixture.path())?;
+        assert_eq!(repository.head_id()?.detach(), main, "forking does not move HEAD");
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            main,
+            "forking does not move the source branch"
+        );
+        assert_eq!(
+            repository.find_commit(fork)?.parent_ids().next().map(gix::Id::detach),
+            Some(parent),
+            "the fork is a direct child of the selected commit"
+        );
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the new leaf is retained until checkout");
+        assert_eq!(pins[0].id, fork);
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?.worktree,
+            before.worktree,
+            "creating the fork leaves worktree files untouched"
+        );
+
+        let repository_path = repository.git_dir().to_owned();
+        let graph = super::super::loaded_graph(&repository)?;
+        drop(repository);
+        super::super::time_travel::perform(&repository_path, false, fork, &graph, &[], false)?.complete()?;
+        let repository = open(fixture.path())?;
+        assert!(repository.head()?.is_detached(), "automatic fork travel detaches HEAD");
+        assert_eq!(repository.head_id()?.detach(), fork);
+        assert!(
+            crate::history::all_pins(&repository)?.is_empty(),
+            "the checkout consumes the fork pin and does not retain a redundant source pin"
+        );
+        Ok(())
+    }
+
     #[test]
     fn creates_an_empty_root_commit_for_an_unborn_head() -> gix_testtools::Result {
         let fixture = gix_testtools::tempfile::tempdir()?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 39b9d47a7b8..f61b0b5ddc9 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -44,6 +44,10 @@ pub(crate) enum Edit {
         anchor: Option<ObjectId>,
         commit: gix::objs::Commit,
     },
+    Fork {
+        anchor: ObjectId,
+        commit: gix::objs::Commit,
+    },
     Remove {
         target: ObjectId,
     },
@@ -129,10 +133,9 @@ impl Conflict {
     }
 
     pub(crate) fn persist(mut self) -> Result<PersistedConflict> {
-        let outcome = self.prepared.finish()?;
+        self.prepared.finish()?;
         Ok(PersistedConflict {
             repo: self.prepared.repo,
-            outcome,
             conflicts: self.conflicts,
             tree: self.tree,
             commit: self.commit,
@@ -142,7 +145,6 @@ impl Conflict {
 
 pub(crate) struct PersistedConflict {
     repo: gix::Repository,
-    pub(crate) outcome: Outcome,
     conflicts: Vec<gix::merge::tree::Conflict>,
     tree: ObjectId,
     pub(crate) commit: ObjectId,
@@ -230,18 +232,19 @@ pub(crate) fn perform(
     mut tree_mode: Tree,
 ) -> Result<Perform> {
     let mut repo = repo.clone();
-    let (root, replacement, inserted, removed, repeat, mut split_upper) = match edit {
-        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, None),
-        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false, None),
-        Edit::Remove { target } => (Some(target), None, false, true, false, None),
-        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, Some(upper)),
-        Edit::Repeat { base } => (Some(base), None, false, false, true, None),
+    let (root, replacement, inserted, forked, removed, repeat, mut split_upper) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, None),
+        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false, false, None),
+        Edit::Fork { anchor, commit } => (Some(anchor), Some(commit), false, true, false, false, None),
+        Edit::Remove { target } => (Some(target), None, false, false, true, false, None),
+        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, false, Some(upper)),
+        Edit::Repeat { base } => (Some(base), None, false, false, false, true, None),
     };
     if repeat {
         tree_mode = Tree::CherryPick;
     }
 
-    let affected = match root {
+    let affected = match root.filter(|_| !forked) {
         Some(root) => graph
             .descendants_in_parent_order(root)
             .context("the edited commit is not in the loaded history")?,
@@ -263,16 +266,18 @@ pub(crate) fn perform(
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
     let mut selected = None;
     let mut conflict = None;
-    if inserted {
+    if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        marker(&mut commit, tree_mode == Tree::LeaveAsIsAndMark, root);
+        marker(&mut commit, inserted && tree_mode == Tree::LeaveAsIsAndMark, root);
         let id = write_commit(&repo, commit, signature, signing.clone())?;
         selected = Some(id);
-        if let Some(root) = root {
-            rewritten.insert(root, Some(id));
-        } else {
-            rewritten.insert(id, Some(id));
+        if inserted {
+            if let Some(root) = root {
+                rewritten.insert(root, Some(id));
+            } else {
+                rewritten.insert(id, Some(id));
+            }
         }
     } else if removed {
         let root = root.context("a removed commit is required")?;
@@ -381,13 +386,17 @@ pub(crate) fn perform(
         repo,
         root,
         inserted,
-        marked: tree_mode == Tree::LeaveAsIsAndMark || conflict.is_some(),
-        skip_worktree_transitions: inserted || (tree_mode == Tree::LeaveAsIsAndMark && !removed),
+        marked: (!forked && tree_mode == Tree::LeaveAsIsAndMark) || conflict.is_some(),
+        skip_worktree_transitions: inserted || forked || (tree_mode == Tree::LeaveAsIsAndMark && !removed),
         selected,
         rewritten,
         committer,
         expected_refs: None,
-        pins: Vec::new(),
+        pins: if forked {
+            selected.into_iter().collect()
+        } else {
+            Vec::new()
+        },
     };
     match conflict {
         Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 794e06c35b0..a42eb6b0a51 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -23,7 +23,7 @@ pub(crate) enum Perform {
 
 impl Perform {
     #[cfg(test)]
-    fn complete(self) -> Result<Option<String>> {
+    pub(crate) fn complete(self) -> Result<Option<String>> {
         match self {
             Perform::Complete(notice) => Ok(notice),
             Perform::Conflict(_) => anyhow::bail!("time-travel unexpectedly suspended on a conflict"),
@@ -35,37 +35,27 @@ pub(crate) struct Conflict {
     rebase: super::rebase::Conflict,
     repository_path: PathBuf,
     bare: bool,
-    workdir: PathBuf,
-    saved_target: Target,
-    head: ObjectId,
+    revisions: Vec<OsString>,
+    include_worktrees: bool,
 }
 
 impl Conflict {
-    pub(crate) fn from_rebase(repository_path: &Path, bare: bool, rebase: super::rebase::Conflict) -> Result<Self> {
-        let repository = open_repository(repository_path, bare, false)
-            .context("could not open a worktree for conflict resolution")?;
-        let workdir = repository
+    pub(crate) fn from_rebase(
+        repository_path: &Path,
+        bare: bool,
+        rebase: super::rebase::Conflict,
+        revisions: &[OsString],
+        include_worktrees: bool,
+    ) -> Result<Self> {
+        open_repository(repository_path, bare, false)?
             .workdir()
-            .context("a conflicting rebase requires a worktree")?
-            .to_owned();
-        let head = repository
-            .head()
-            .context("could not read HEAD before conflict resolution")?;
-        let head_id = head
-            .id()
-            .map(gix::Id::detach)
-            .context("conflict resolution requires a born HEAD")?;
-        let saved_target = head
-            .referent_name()
-            .map(ToOwned::to_owned)
-            .map_or(Target::Object(head_id), Target::Symbolic);
+            .context("a conflicting rebase requires a worktree")?;
         Ok(Conflict {
             rebase,
             repository_path: repository_path.to_owned(),
             bare,
-            workdir,
-            saved_target,
-            head: head_id,
+            revisions: revisions.to_vec(),
+            include_worktrees,
         })
     }
 
@@ -76,39 +66,16 @@ impl Conflict {
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
     pub(crate) fn accept(self) -> Result<(String, ObjectId)> {
         let mut conflict = self.rebase.persist()?;
-        let head = conflict
-            .outcome
-            .map(self.head)
-            .context("HEAD disappeared while preparing conflict resolution")?;
-        let repository = open_repository(&self.repository_path, self.bare, false)
-            .context("could not reopen repository before conflict checkout")?;
-        let provisional = contains(&repository, conflict.commit, head)
-            .then(|| create_or_reuse_pin(&repository, self.saved_target, head))
-            .transpose()?;
-        drop(repository);
-        if let Err(checkout) = checkout_detached(&self.workdir, conflict.commit) {
-            if let Some((pin, true)) = &provisional {
-                let cleanup = open_repository(&self.repository_path, self.bare, false)
-                    .context("could not reopen repository to remove a provisional pin")
-                    .and_then(|repository| delete_pin(&repository, pin));
-                if let Err(cleanup) = cleanup {
-                    return Err(checkout.context(format!(
-                        "checkout failed and {} could not be removed: {cleanup:#}",
-                        pin_label(pin)
-                    )));
-                }
-            }
-            return Err(checkout);
-        }
+        let notice = move_head(
+            &self.repository_path,
+            self.bare,
+            conflict.commit,
+            &self.revisions,
+            self.include_worktrees,
+        )?
+        .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         conflict.write_index()?;
-        let mut notice = format!(
-            "checked out conflicting {} for resolution",
-            conflict.commit.to_hex_with_len(7)
-        );
-        if let Some((pin, true)) = provisional {
-            notice = format!("{notice}; saved {}", pin_label(&pin));
-        }
-        Ok((notice, conflict.commit))
+        Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
     }
 }
 
@@ -119,71 +86,84 @@ pub(crate) fn checkout_without_replay(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
-    let repository =
-        open_repository(repository_path, bare, false).context("could not open repository for rebase checkout")?;
+    move_head(repository_path, bare, selected, revisions, include_worktrees)
+}
+
+fn move_head(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<Option<String>> {
+    let repository = open_repository(repository_path, bare, false).context("could not open repository for checkout")?;
     let workdir = repository
         .workdir()
-        .context("the rebase todo selected a checkout without a worktree")?
+        .context("time-travel requires a worktree")?
         .to_owned();
-    let head = repository
-        .head()
-        .context("could not read HEAD before rebase checkout")?;
+    let head = repository.head().context("could not read HEAD before time-travel")?;
     let head_id = head
         .id()
         .map(gix::Id::detach)
-        .context("cannot move an unborn HEAD after rebasing")?;
-    let head_referent = head.referent_name().map(ToOwned::to_owned);
+        .context("cannot time-travel from an unborn HEAD")?;
+    let saved_target = head
+        .referent_name()
+        .map(ToOwned::to_owned)
+        .map_or(Target::Object(head_id), Target::Symbolic);
     drop(head);
     if selected == head_id {
         return Ok(None);
     }
-    if let Some(pin) = selected_pin(&repository, selected)? {
-        drop(repository);
-        checkout_pin(&workdir, &pin)?;
-        let repository = open_repository(repository_path, bare, false)
-            .context("could not reopen repository after returning through a pin")?;
-        return Ok(Some(match delete_pin(&repository, &pin) {
-            Ok(()) => format!("returned from {}", pin_label(&pin)),
-            Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
-        }));
-    }
-    let saved_target = head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id));
-    let provisional = contains(&repository, selected, head_id)
-        .then(|| create_or_reuse_pin(&repository, saved_target, head_id))
-        .transpose()?;
+    let destination_pin = selected_pin(&repository, selected)?;
+    let provisional = create_or_reuse_pin(&repository, saved_target, head_id)?;
     drop(repository);
-    if let Err(checkout) = checkout_detached(&workdir, selected) {
-        if let Some((pin, true)) = &provisional {
+    let checkout = match &destination_pin {
+        Some(pin) => checkout_pin(&workdir, pin),
+        None => checkout_detached(&workdir, selected),
+    };
+    if let Err(checkout) = checkout {
+        if provisional.1 {
             let cleanup = open_repository(repository_path, bare, false)
                 .context("could not reopen repository to remove a provisional pin")
-                .and_then(|repository| delete_pin(&repository, pin));
+                .and_then(|repository| delete_pin(&repository, &provisional.0));
             if let Err(cleanup) = cleanup {
                 return Err(checkout.context(format!(
                     "checkout failed and {} could not be removed: {cleanup:#}",
-                    pin_label(pin)
+                    pin_label(&provisional.0)
                 )));
             }
         }
         return Err(checkout);
     }
-    let mut notice = format!("time-travelled to {}", selected.to_hex_with_len(7));
-    if let Some((pin, true)) = provisional {
-        let repository = open_repository(repository_path, bare, false)
-            .context("could not reopen repository after rebase time-travel")?;
-        let snapshot =
-            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
-        if snapshot
-            .view_tips
-            .iter()
-            .copied()
-            .any(|tip| contains(&repository, head_id, tip))
-        {
-            if let Err(err) = delete_pin(&repository, &pin) {
-                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
-            }
-        } else {
-            notice = format!("{notice}; saved {}", pin_label(&pin));
+    let mut notice = destination_pin.as_ref().map_or_else(
+        || format!("time-travelled to {}", selected.to_hex_with_len(7)),
+        |pin| format!("returned from {}", pin_label(pin)),
+    );
+    let repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
+    if let Some(pin) = destination_pin
+        && let Err(err) = delete_pin(&repository, &pin)
+    {
+        notice = format!("{notice}; destination pin remains: {err:#}");
+    }
+    let snapshot = history::snapshot_ignoring_pin(
+        &repository,
+        revisions,
+        &[],
+        include_worktrees,
+        Some(provisional.0.name.as_bstr()),
+    )?;
+    if snapshot
+        .view_tips
+        .iter()
+        .copied()
+        .any(|tip| contains(&repository, head_id, tip))
+    {
+        if let Err(err) = delete_pin(&repository, &provisional.0) {
+            notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&provisional.0));
         }
+    } else {
+        notice = format!("{notice}; saved {}", pin_label(&provisional.0));
     }
     Ok(Some(notice))
 }
@@ -199,15 +179,11 @@ pub(crate) fn perform(
 ) -> Result<Perform> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
-    let workdir = repository
-        .workdir()
-        .context("time-travel requires a worktree")?
-        .to_owned();
+    repository.workdir().context("time-travel requires a worktree")?;
     let head = repository.head().context("could not read HEAD before time-travel")?;
     let Some(mut head_id) = head.id().map(gix::Id::detach) else {
         anyhow::bail!("cannot time-travel from an unborn HEAD");
     };
-    let head_referent = head.referent_name().map(ToOwned::to_owned);
     drop(head);
     if repository
         .index_or_empty()
@@ -234,9 +210,8 @@ pub(crate) fn perform(
                     rebase,
                     repository_path: repository_path.to_owned(),
                     bare,
-                    workdir,
-                    saved_target: head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id)),
-                    head: head_id,
+                    revisions: revisions.to_vec(),
+                    include_worktrees,
                 }));
             }
         };
@@ -250,62 +225,14 @@ pub(crate) fn perform(
             .context("could not reopen repository after completing a pending rebase")?;
         completed_graph = Some(super::loaded_graph(&repository)?);
     }
-    let graph = completed_graph.as_ref().unwrap_or(graph);
-    if selected == head_id {
-        return Ok(Perform::Complete(None));
-    }
-    if let Some(pin) = selected_pin(&repository, selected)? {
-        drop(repository);
-        checkout_pin(&workdir, &pin)?;
-        let repository = open_repository(repository_path, bare, false)
-            .context("could not reopen repository after returning from time-travel")?;
-        return Ok(Perform::Complete(Some(match delete_pin(&repository, &pin) {
-            Ok(()) => format!("returned from {}", pin_label(&pin)),
-            Err(err) => format!("returned from {}; pin remains: {err:#}", pin_label(&pin)),
-        })));
-    }
-    let saved_target = head_referent.map(Target::Symbolic).unwrap_or(Target::Object(head_id));
-    let provisional = graph
-        .is_ancestor(selected, head_id)
-        .then(|| create_or_reuse_pin(&repository, saved_target, head_id))
-        .transpose()?;
     drop(repository);
-
-    if let Err(checkout) = checkout_detached(&workdir, selected) {
-        if let Some((pin, true)) = &provisional {
-            let cleanup = open_repository(repository_path, bare, false)
-                .context("could not reopen repository to remove a provisional pin")
-                .and_then(|repository| delete_pin(&repository, pin));
-            if let Err(cleanup) = cleanup {
-                return Err(checkout.context(format!(
-                    "checkout failed and {} could not be removed: {cleanup:#}",
-                    pin_label(pin)
-                )));
-            }
-        }
-        return Err(checkout);
-    }
-
-    let mut notice = format!("time-travelled to {}", selected.to_hex_with_len(7));
-    if let Some((pin, true)) = provisional {
-        let repository =
-            open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
-        let snapshot =
-            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
-        if snapshot
-            .view_tips
-            .iter()
-            .copied()
-            .any(|tip| contains(&repository, head_id, tip))
-        {
-            if let Err(err) = delete_pin(&repository, &pin) {
-                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
-            }
-        } else {
-            notice = format!("{notice}; saved {}", pin_label(&pin));
-        }
-    }
-    Ok(Perform::Complete(Some(notice)))
+    Ok(Perform::Complete(move_head(
+        repository_path,
+        bare,
+        selected,
+        revisions,
+        include_worktrees,
+    )?))
 }
 
 fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId) -> Result<Option<ObjectId>> {
@@ -335,7 +262,7 @@ fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId
 }
 
 fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
-    let mut pins: Vec<_> = history::applicable_pins(repository)?
+    let mut pins: Vec<_> = history::all_pins(repository)?
         .into_iter()
         .filter(|pin| pin.id == selected)
         .collect();
@@ -586,6 +513,45 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let main = repository.rev_parse_single("main")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "--detach", &main.to_string()])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["branch", "-D", "main"])
+                .status()?
+                .success()
+        );
+
+        perform(&repository_path, false, topic, &graph, &[], false)?.complete()?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(repository.head_id()?.detach(), topic);
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "sideways travel retains the otherwise lost departure");
+        assert_eq!(pins[0].id, main);
+        assert!(
+            pins[0].target.try_name().is_none(),
+            "the detached departure gets a direct pin"
+        );
+        Ok(())
+    }
+
     #[test]
     fn explicit_tips_avoid_redundant_pins_and_failed_checkouts_clean_up() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -609,6 +575,14 @@ mod tests {
             .args(["checkout", "--no-guess", "main"])
             .status()?;
         assert!(checkout.success());
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["update-ref", "refs/tix/pins/destination", &root.to_string()])
+                .status()?
+                .success()
+        );
         std::fs::write(fixture.path().join("main"), "dirty\n")?;
         let err = perform(&repository_path, false, root, &graph, &[], false)
             .and_then(Perform::complete)
@@ -616,10 +590,9 @@ mod tests {
         assert!(format!("{err:#}").contains("git checkout failed"));
         let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
-        assert!(
-            history::all_pins(&repository)?.is_empty(),
-            "the provisional pin is removed"
-        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the destination pin survives a failed checkout");
+        assert_eq!(pins[0].id, root);
         Ok(())
     }
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 93eaaf176e7..dd9333780f4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1813,6 +1813,7 @@ fn event_loop(
                                 repository_is_bare,
                                 graph,
                                 parent,
+                                CreateMode::Insert,
                                 enhanced_keyboard,
                             )
                         });
@@ -1826,6 +1827,67 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("new commit: {err:#}")),
                     }
                 }
+                Effect::ForkCommit(parent) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let created = history_graph
+                        .as_ref()
+                        .context("creating a fork requires a completed history graph")
+                        .and_then(|graph| {
+                            create_commit(
+                                terminal,
+                                &repository_path,
+                                repository_is_bare,
+                                graph,
+                                Some(parent),
+                                CreateMode::Fork,
+                                enhanced_keyboard,
+                            )
+                        });
+                    match created {
+                        Ok(Some(new_id)) => {
+                            let travel = open_repository(&repository_path, repository_is_bare, false)
+                                .context("could not reopen repository before travelling to fork")
+                                .and_then(|repository| edit::loaded_graph(&repository))
+                                .and_then(|graph| {
+                                    edit::time_travel::perform(
+                                        &repository_path,
+                                        repository_is_bare,
+                                        new_id,
+                                        &graph,
+                                        &revisions,
+                                        worktrees,
+                                    )
+                                });
+                            match travel {
+                                Ok(edit::time_travel::Perform::Complete(notice)) => {
+                                    app.leave_message(notice.map_or_else(
+                                        || format!("created fork {}", new_id.to_hex_with_len(7)),
+                                        |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
+                                    ));
+                                    app.select_commit_after_refresh(new_id);
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                                Ok(edit::time_travel::Perform::Conflict(conflict)) => {
+                                    let original = conflict.original();
+                                    app.arm_rebase_conflict(original);
+                                    app.select_commit(original);
+                                    pending_rebase_conflict = Some(conflict);
+                                }
+                                Err(err) => {
+                                    app.leave_message(format!(
+                                        "created fork {}, but checkout failed: {err:#}",
+                                        new_id.to_hex_with_len(7)
+                                    ));
+                                    refresh_pending = true;
+                                }
+                            }
+                        }
+                        Ok(None) => app.leave_message("no fork created: no input was provided"),
+                        Err(err) => app.leave_message(format!("fork: {err:#}")),
+                    }
+                }
                 Effect::Split(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -1993,6 +2055,8 @@ fn event_loop(
                                 &repository_path,
                                 repository_is_bare,
                                 conflict,
+                                &revisions,
+                                worktrees,
                             ) {
                                 Ok(conflict) => {
                                     let original = conflict.original();
@@ -3078,13 +3142,20 @@ fn rebase_history(
     edit::rebase::perform_plan(&repository, graph, plan).map(Some)
 }
 
-#[tracing::instrument(skip_all, fields(parent = ?parent))]
+#[derive(Clone, Copy)]
+enum CreateMode {
+    Insert,
+    Fork,
+}
+
+#[tracing::instrument(skip_all, fields(parent = ?parent, fork = matches!(mode, CreateMode::Fork)))]
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
     bare: bool,
     graph: &HistoryGraph,
     parent: Option<gix::ObjectId>,
+    mode: CreateMode,
     enhanced_keyboard: bool,
 ) -> Result<Option<gix::ObjectId>> {
     let mut repository =
@@ -3104,7 +3175,11 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    edit::create::apply(repository, graph, prepared, &edited).map(Some)
+    match mode {
+        CreateMode::Insert => edit::create::apply(repository, graph, prepared, &edited),
+        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited),
+    }
+    .map(Some)
 }
 
 #[tracing::instrument(skip_all)]
@@ -3851,6 +3926,9 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('c') => Some(Action::ToggleChanges),
         KeyCode::Char('p') if edit_expanded => Some(Action::Split),
         KeyCode::Char('b') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
+        KeyCode::Char('f') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+            Some(Action::ForkCommit)
+        }
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -4859,6 +4937,7 @@ mod tests {
             ('b', Action::Rebase),
             ('r', Action::Reword),
             ('n', Action::NewCommit),
+            ('f', Action::ForkCommit),
             ('a', Action::Amend),
             ('s', Action::Spill),
             ('p', Action::Split),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 5f0886d763f..76b69af9037 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -753,6 +753,9 @@ pub(crate) fn draw_with_worktree(
             if app.changes_focus.is_none() && app.can_create_commit() {
                 options.push(("new", 'n'));
             }
+            if app.can_fork_commit() {
+                options.push(("fork", 'f'));
+            }
             if app.can_amend() {
                 options.push(("amend", 'a'));
             }
@@ -2731,7 +2734,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
         assert!(
-            rendered_line(&terminal, 1).contains("edit (reword · new · d forget · return)"),
+            rendered_line(&terminal, 1).contains("edit (reword · new · fork · d forget · return)"),
             "the active edit prefix contains exactly its actionable commands"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
@@ -4562,9 +4565,12 @@ mod tests {
             rendered_line(&narrow, 1).ends_with(" ⇣2 "),
             "the terminal edge pushes the marker over clipped title text"
         );
+        let mut actions = Terminal::new(TestBackend::new(120, 3))?;
+        actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&narrow, 2).contains("edit (rebase)"),
-            "the selected hidden base offers only its rebase edit"
+            rendered_line(&actions, 2).contains("edit (rebase · fork)"),
+            "the selected hidden base offers independent edits: {:?}",
+            rendered_line(&actions, 2)
         );
         Ok(())
     }

From 6e3c4597546bd2df591c6fb47e0a71b3787ba1f3 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 06:47:40 +0200
Subject: [PATCH 078/282] fix: keep tix review tips private to their worktree

Store time-travel pins under the Git worktree-private refs namespace and include every valid private pin while HEAD is detached. This keeps sibling review forks visible without leaking pins between tix instances in other worktrees.

Leave legacy shared pins untouched and ignored, and teach reference watching and regression coverage about private pin isolation.
---
 gix-tix/spec.md                               | 23 +++---
 gix-tix/src/edit/create.rs                    | 60 +++++++++++++++
 ...sts__accepted-pending-rebase-conflict.snap |  2 +-
 gix-tix/src/edit/time_travel.rs               | 48 +++++-------
 gix-tix/src/history.rs                        | 77 ++++++++++++++-----
 gix-tix/src/lib.rs                            | 10 +++
 6 files changed, 163 insertions(+), 57 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index fcc3226585e..1ee7005356b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -189,17 +189,18 @@ The Enter key is written as `<enter>` throughout.
 - On a completed, focused history in a worktree repository, `t` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
 - Before every move, tix provisionally retains the previous `HEAD` with a
-  `refs/tix/pins/<suffix>` ref. After a successful checkout it removes that pin
+  `refs/worktree/tix/pins/<suffix>` ref. Git stores these refs privately for the
+  current worktree. After a successful checkout it removes that pin
   when the old `HEAD` remains reachable from another view tip, and retains it
   otherwise. Pins use at least four alphanumeric characters;
   generated pins start with eight hexadecimal characters from the saved commit.
 - A pin is symbolic when the previous `HEAD` named a local branch, so later branch
   advances move the pinned tip. An already detached `HEAD` receives a direct pin.
-- While `HEAD` is detached, applicable pins augment implicit and explicit revision
-  tips when their ancestry contains `HEAD`. Unrelated, dangling, malformed, and
-  non-commit pins do not enter the view or its decorations. Normal hidden-revision
-  exclusions still apply.
-- Applicable pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
+- While `HEAD` is detached, every valid pin from the current worktree augments
+  implicit and explicit revision tips. Pins from other worktrees, legacy shared
+  `refs/tix/pins/*` refs, dangling, malformed, and non-commit pins do not enter the
+  view or its decorations. Normal hidden-revision exclusions still apply.
+- Worktree pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
@@ -367,8 +368,8 @@ space first; changes blocks adapt within the remaining history width.
   because it rewrites none of them. It is unavailable for unborn history.
 - Fork preparation reuses the new-commit editor, candidate-tree, identity, and
   signing rules. Saving writes only the new commit and a temporary direct
-  `refs/tix/pins/*` ref; existing refs, descendants, indexes, and worktrees do not
-  move during creation.
+  `refs/worktree/tix/pins/*` ref; existing refs, descendants, indexes, and
+  worktrees do not move during creation.
 - Tix immediately time-travels to the new fork. A successful checkout consumes
   its temporary pin and reconciles the departed `HEAD` through the standard pin
   primitive. If checkout fails, the fork remains pinned and visible.
@@ -478,9 +479,9 @@ space first; changes blocks adapt within the remaining history width.
 - Mutable refs captured before the editor opened follow retained or dropped
   commits through one compare-and-swap transaction. Tags and remote-tracking refs
   remain untouched. Every resulting leaf without a surviving mutable ref gets a
-  direct `refs/tix/pins/*` ref, except the checked-out leaf. Concurrent ref edits
-  win by making the transaction fail; the editor result is not rebuilt against a
-  later graph snapshot. Leaving the document unchanged is a no-op.
+  direct `refs/worktree/tix/pins/*` ref, except the checked-out leaf. Concurrent
+  ref edits win by making the transaction fail; the editor result is not rebuilt
+  against a later graph snapshot. Leaving the document unchanged is a no-op.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 6cfcb902fb5..1b00d2d5257 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -459,6 +459,66 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn sibling_forks_remain_visible_as_private_pinned_tips() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        for args in [
+            ["reset", "--hard", "-q", "HEAD"].as_slice(),
+            ["clean", "-fdq"].as_slice(),
+        ] {
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(fixture.path())
+                    .args(args)
+                    .status()?
+                    .success(),
+                "the fork fixture is cleaned"
+            );
+        }
+        let repository = open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let base = repository.head_id()?.detach();
+        drop(repository);
+
+        let prepared = prepare(open(fixture.path())?, Some(base))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"first fork\n\nreason", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let first = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        super::super::time_travel::perform(&repository_path, false, first, &graph, &[], false)?.complete()?;
+
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        super::super::time_travel::perform(&repository_path, false, base, &graph, &[], false)?.complete()?;
+        let prepared = prepare(open(fixture.path())?, Some(base))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"second fork\n\nreason", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let second = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        super::super::time_travel::perform(&repository_path, false, second, &graph, &[], false)?.complete()?;
+
+        let repository = open(fixture.path())?;
+        let snapshot = crate::history::snapshot(&repository, &[], &[], false)?;
+        assert_eq!(repository.head_id()?.detach(), second);
+        assert!(
+            snapshot.view_tips.contains(&first),
+            "the first review fork remains visible"
+        );
+        assert!(
+            snapshot.view_tips.contains(&second),
+            "the current review fork remains visible"
+        );
+        assert_eq!(
+            crate::history::all_pins(&repository)?
+                .into_iter()
+                .map(|pin| pin.id)
+                .collect::<std::collections::HashSet<_>>(),
+            [first].into_iter().collect(),
+            "every non-current tip has one private pin"
+        );
+        Ok(())
+    }
+
     #[test]
     fn creates_an_empty_root_commit_for_an_unborn_head() -> gix_testtools::Result {
         let fixture = gix_testtools::tempfile::tempdir()?;
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index 30e04dfef37..f35a10a7708 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -6,7 +6,7 @@ HEAD detached C1
 
 [refs]
 refs/heads/main = C2
-refs/tix/pins/6a06a74d = -> refs/heads/main
+refs/worktree/tix/pins/6a06a74d = -> refs/heads/main
 
 [commits]
 C0
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index a42eb6b0a51..45cc3c3e65c 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -309,39 +309,33 @@ fn create_or_reuse_pin(repository: &gix::Repository, target: Target, id: ObjectI
         }
     };
     repository
-        .edit_references_as(
-            [RefEdit {
-                change: Change::Update {
-                    log: LogChange {
-                        mode: RefLog::AndReference,
-                        force_create_reflog: false,
-                        message: "tix time-travel".into(),
-                    },
-                    expected: PreviousValue::MustNotExist,
-                    new: target.clone(),
+        .edit_references([RefEdit {
+            change: Change::Update {
+                log: LogChange {
+                    mode: RefLog::AndReference,
+                    force_create_reflog: false,
+                    message: "tix time-travel".into(),
                 },
-                name: name.clone(),
-                deref: false,
-            }],
-            None,
-        )
+                expected: PreviousValue::MustNotExist,
+                new: target.clone(),
+            },
+            name: name.clone(),
+            deref: false,
+        }])
         .context("could not create tix pin")?;
     Ok((history::Pin { name, target, id }, true))
 }
 
 fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     repository
-        .edit_references_as(
-            [RefEdit {
-                change: Change::Delete {
-                    expected: PreviousValue::MustExistAndMatch(pin.target.clone()),
-                    log: RefLog::AndReference,
-                },
-                name: pin.name.clone(),
-                deref: false,
-            }],
-            None,
-        )
+        .edit_references([RefEdit {
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(pin.target.clone()),
+                log: RefLog::AndReference,
+            },
+            name: pin.name.clone(),
+            deref: false,
+        }])
         .context("could not remove tix pin")?;
     Ok(())
 }
@@ -579,7 +573,7 @@ mod tests {
             Command::new("git")
                 .arg("-C")
                 .arg(fixture.path())
-                .args(["update-ref", "refs/tix/pins/destination", &root.to_string()])
+                .args(["update-ref", "refs/worktree/tix/pins/destination", &root.to_string(),])
                 .status()?
                 .success()
         );
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 8e015885305..95165692270 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -41,7 +41,7 @@ pub(crate) enum DecorationKind {
 
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
-pub(crate) const PIN_PREFIX: &[u8] = b"refs/tix/pins/";
+pub(crate) const PIN_PREFIX: &[u8] = b"refs/worktree/tix/pins/";
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct Pin {
@@ -1291,21 +1291,10 @@ pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
     if !head.is_detached() {
         return Ok(Vec::new());
     }
-    let Some(head) = head.id().map(gix::Id::detach) else {
+    if head.id().is_none() {
         return Ok(Vec::new());
-    };
-    all_pins(repo)?
-        .into_iter()
-        .filter_map(|pin| match repo.merge_base(head, pin.id) {
-            Ok(base) => Some(Ok((base.as_ref() == head).then_some(pin))),
-            Err(gix::repository::merge_base::Error::NotFound { .. }) => None,
-            Err(err) => Some(Err(err).context("could not determine tix pin reachability")),
-        })
-        .filter_map(|result| match result {
-            Ok(pin) => pin.map(Ok),
-            Err(err) => Some(Err(err)),
-        })
-        .collect()
+    }
+    all_pins(repo)
 }
 
 fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {
@@ -2313,7 +2302,7 @@ mod tests {
 
     #[test]
     fn classifies_reference_kinds() {
-        assert_eq!(decoration_kind(b"refs/tix/pins/abcd"), DecorationKind::Pin);
+        assert_eq!(decoration_kind(b"refs/worktree/tix/pins/abcd"), DecorationKind::Pin);
         assert_eq!(decoration_kind(b"refs/heads/main"), DecorationKind::Local);
         assert_eq!(decoration_kind(b"refs/tags/v1"), DecorationKind::Tag);
         assert_eq!(decoration_kind(b"refs/remotes/origin/main"), DecorationKind::Remote);
@@ -2328,13 +2317,13 @@ mod tests {
         let head = repo.head_id()?.detach();
         let blob = repo.write_blob(b"not a commit")?.detach();
         repo.reference(
-            "refs/tix/pins/a",
+            "refs/worktree/tix/pins/a",
             head,
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test malformed pin",
         )?;
         repo.reference(
-            "refs/tix/pins/abcd",
+            "refs/worktree/tix/pins/abcd",
             blob,
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test non-commit pin",
@@ -2344,6 +2333,58 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pins_are_private_to_the_current_worktree_and_legacy_pins_are_ignored() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let linked = gix_testtools::tempfile::tempdir()?;
+        let linked_path = linked.path().join("linked");
+        assert!(
+            std::process::Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["worktree", "add", "-q", "--detach"])
+                .arg(&linked_path)
+                .arg("topic")
+                .status()?
+                .success(),
+            "the linked-worktree fixture is created"
+        );
+        let main = crate::open_test_repository(fixture.path())?;
+        let linked = crate::open_test_repository(&linked_path)?;
+        let main_id = main.head_id()?.detach();
+        let linked_id = linked.head_id()?.detach();
+        for (repo, id) in [(&main, main_id), (&linked, linked_id)] {
+            repo.reference(
+                "refs/worktree/tix/pins/abcd",
+                id,
+                gix::refs::transaction::PreviousValue::MustNotExist,
+                "test private pin",
+            )?;
+        }
+        main.reference(
+            "refs/tix/pins/legacy",
+            linked_id,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test legacy pin",
+        )?;
+
+        assert_eq!(
+            all_pins(&main)?.into_iter().map(|pin| pin.id).collect::<Vec<_>>(),
+            [main_id],
+            "the main worktree sees only its private pin"
+        );
+        assert_eq!(
+            all_pins(&linked)?.into_iter().map(|pin| pin.id).collect::<Vec<_>>(),
+            [linked_id],
+            "the linked worktree sees only its private pin"
+        );
+        assert!(
+            main.try_find_reference("refs/tix/pins/legacy")?.is_some(),
+            "the ignored shared pin remains untouched"
+        );
+        Ok(())
+    }
+
     #[test]
     fn interns_raw_author_identities() {
         let mut authors = Authors::default();
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index dd9333780f4..cf317f3754e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -5216,6 +5216,16 @@ mod tests {
             &current_linked,
             &worktrees
         ));
+        assert!(reference_event_is_relevant(
+            &modified(&current_linked.join("refs/worktree/tix/pins/abcd")),
+            &current_linked,
+            &worktrees
+        ));
+        assert!(!reference_event_is_relevant(
+            &modified(&linked.join("refs/worktree/tix/pins/abcd")),
+            &current_linked,
+            &worktrees
+        ));
         assert!(reference_watch_set_may_change(
             &modified(&worktrees.join("new-linked")),
             &worktrees

From 2e024e63b0593e2265d80368fd5caed7687705c3 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 08:54:46 +0200
Subject: [PATCH 079/282] feat: rebase tix history onto updated hidden branches

Offer rebase-update when a hidden local branch has advanced beyond the selected fork point. Seed the existing history rebase editor with that current branch tip while preserving the visible stacks, transaction rules, lazy replay, conflict handling, and the hidden reference itself.

Retain the hidden tip alongside the displayed behind count and label its otherwise unfamiliar fork heading with the title shown in history.
---
 gix-tix/spec.md            | 12 ++++-
 gix-tix/src/app.rs         | 57 +++++++++++++++++++---
 gix-tix/src/edit/rebase.rs | 54 +++++++++++++++++++++
 gix-tix/src/edit/todo.rs   | 98 +++++++++++++++++++++++++++++++++-----
 gix-tix/src/history.rs     | 22 ++++++---
 gix-tix/src/lib.rs         | 38 +++++++++++----
 gix-tix/src/ui.rs          | 27 ++++++++++-
 7 files changed, 270 insertions(+), 38 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1ee7005356b..4e9312e2833 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -76,7 +76,9 @@ without trading responsiveness for metadata that is not visible.
   `N` commits not reachable from the view. The terminal edge pushes the marker
   left over a clipped title when necessary. A blank margin remains on each side.
   The cached history graph supplies the base and count; unrelated refs and
-  zero-count relations add no marker.
+  zero-count relations add no marker. If multiple hidden branches share a base,
+  the largest count is shown and its tip is retained as the update target; equal
+  counts choose a deterministic object ID.
 
 ### Row content and visual states
 
@@ -463,6 +465,11 @@ space first; changes blocks adapt within the remaining history width.
   lists its commits oldest-to-newest as `` `pick <short-id>` <displayed metadata> ``.
   IDs are shortened through repository configuration; metadata repeats the
   information visible in history and always includes the subject.
+- When that boundary shows `⇣N`, `e u` opens the same editor with each base-level
+  stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
+  `## fork <id>` heading additionally includes the Markdown-escaped title exactly
+  as shown in history, including `[A]` and `[N]`; ordinary and internal fork
+  headings remain unchanged. The hidden branch itself is not moved.
 - Pick lines may be reordered or removed. Fork headings may target an earlier
   pick or any existing commit, so adding and removing headings creates and joins
   branches. `empty <title>` inserts an empty commit. Markdown code spans and
@@ -485,7 +492,8 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Editing shortcuts
 
-- `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base,
+- `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base and
+  `e u` rebases it onto the newer hidden branch tip when available,
   `e r` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   `e d d` confirms forgetting a top commit, and `e t` enters or returns from
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index e65d8553774..7995f124acb 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -300,6 +300,7 @@ pub(crate) enum Action {
     Split,
     Forget,
     Rebase,
+    RebaseUpdate,
     TimeTravel,
     VerifySignatures,
     Cancel,
@@ -329,6 +330,7 @@ pub(crate) enum Effect {
     Forget(ObjectId),
     Rebase {
         base: ObjectId,
+        onto: ObjectId,
         commits: Vec<ObjectId>,
         head: Option<ObjectId>,
     },
@@ -433,7 +435,7 @@ pub(crate) struct App {
     signature_verification_running: bool,
     pub(crate) manual_refresh: bool,
     pub(crate) selection_relation: Option<SelectionRelation>,
-    hidden_branch_behind: HashMap<ObjectId, usize>,
+    hidden_branch_updates: HashMap<ObjectId, (usize, ObjectId)>,
 }
 
 impl App {
@@ -518,7 +520,7 @@ impl App {
             signature_verification_running: false,
             manual_refresh: false,
             selection_relation: None,
-            hidden_branch_behind: HashMap::new(),
+            hidden_branch_updates: HashMap::new(),
         }
     }
 
@@ -770,6 +772,8 @@ impl App {
                 | Action::Spill
                 | Action::Split
                 | Action::Forget
+                | Action::Rebase
+                | Action::RebaseUpdate
                 | Action::TimeTravel
         ) {
             self.edit_expanded = false;
@@ -977,6 +981,16 @@ impl App {
                 let base = self.rows[self.selected.expect("rebase requires a selection")].id;
                 return vec![Effect::Rebase {
                     base,
+                    onto: base,
+                    commits: self.hidden_descendants(base),
+                    head: self.worktree_head,
+                }];
+            }
+            Action::RebaseUpdate if self.can_rebase_update() => {
+                let base = self.rows[self.selected.expect("rebase-update requires a selection")].id;
+                return vec![Effect::Rebase {
+                    base,
+                    onto: self.hidden_branch_updates[&base].1,
                     commits: self.hidden_descendants(base),
                     head: self.worktree_head,
                 }];
@@ -1074,12 +1088,16 @@ impl App {
         self.hidden_rows.clone()
     }
 
-    pub(crate) fn set_hidden_branch_behind(&mut self, markers: HashMap<ObjectId, usize>) {
-        self.hidden_branch_behind = markers;
+    pub(crate) fn set_hidden_branch_updates(&mut self, updates: HashMap<ObjectId, (usize, ObjectId)>) {
+        self.hidden_branch_updates = updates;
     }
 
     pub(crate) fn hidden_branch_behind(&self, id: ObjectId) -> Option<usize> {
-        self.hidden_branch_behind.get(&id).copied()
+        self.hidden_branch_updates.get(&id).map(|(behind, _)| *behind)
+    }
+
+    pub(crate) fn commit(&self, id: ObjectId) -> Option<&CommitRow> {
+        self.all_rows.get(&id).map(AsRef::as_ref)
     }
 
     pub(crate) fn selected_tree_diff_target(&self) -> Option<TreeDiffTarget> {
@@ -1286,7 +1304,7 @@ impl App {
         self.hidden_rows.clear();
         self.hidden_branch_targets.clear();
         self.hidden_rebase_bases.clear();
-        self.hidden_branch_behind.clear();
+        self.hidden_branch_updates.clear();
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
@@ -1596,6 +1614,14 @@ impl App {
                 .is_some_and(|row| self.hidden_rebase_bases.contains(&row.id))
     }
 
+    pub(crate) fn can_rebase_update(&self) -> bool {
+        self.can_rebase()
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| self.hidden_branch_updates.contains_key(&row.id))
+    }
+
     fn can_edit_head(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -2862,11 +2888,28 @@ mod tests {
             fork.update(Action::Rebase),
             vec![Effect::Rebase {
                 base: id(1),
+                onto: id(1),
                 commits: vec![id(3), id(2)],
                 head: None,
             }],
             "the todo receives all visible descendants"
         );
+        assert!(!fork.can_rebase_update(), "there is no newer hidden branch tip yet");
+        fork.set_hidden_branch_updates(HashMap::from([(id(1), (2, id(4)))]));
+        assert!(
+            fork.can_rebase_update(),
+            "a hidden branch ahead of the base can be used"
+        );
+        assert_eq!(
+            fork.update(Action::RebaseUpdate),
+            vec![Effect::Rebase {
+                base: id(1),
+                onto: id(4),
+                commits: vec![id(3), id(2)],
+                head: None,
+            }],
+            "rebase-update retains the editable scope but changes its root"
+        );
 
         let merged = eligible(vec![
             row_with_parents(4, &[3, 2]),
@@ -3076,6 +3119,8 @@ mod tests {
         app.update(Action::Reword);
         app.update(Action::NewCommit);
         app.update(Action::Forget);
+        app.update(Action::Rebase);
+        app.update(Action::RebaseUpdate);
         assert!(app.edit_expanded, "grouped edit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index f61b0b5ddc9..a8a704173dd 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1499,6 +1499,60 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_todo_rebase_can_update_onto_a_hidden_branch_without_moving_it() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let mut hidden = repo.find_commit(base)?.decode()?.into_owned()?;
+        hidden.parents = [base].into_iter().collect();
+        hidden.message = "updated hidden base".into();
+        let onto = repo.write_object(&hidden)?.detach();
+        repo.reference(
+            "refs/heads/hidden",
+            onto,
+            PreviousValue::MustNotExist,
+            "test hidden update target",
+        )?;
+
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base: onto,
+                scope: vec![middle, tip],
+                steps: vec![
+                    PlanStep {
+                        parent: PlanParent::Existing(onto),
+                        commit: PlanCommit::Pick(middle),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Pick(tip),
+                    },
+                ],
+                checkout: Some(1),
+                expected_refs: capture_refs(&repo, &[middle, tip])?,
+            },
+        )?
+        .complete()?;
+        let new_middle = outcome.map(middle).context("the middle commit is retained")?;
+        assert_eq!(
+            repo.find_commit(new_middle)?.parent_ids().next().map(gix::Id::detach),
+            Some(onto),
+            "the visible stack starts at the latest hidden branch tip"
+        );
+        assert_eq!(
+            repo.find_reference("refs/heads/hidden")?.id().detach(),
+            onto,
+            "the hidden branch itself remains untouched"
+        );
+        Ok(())
+    }
+
     #[test]
     fn a_todo_rebase_uses_the_reference_snapshot_from_before_editing() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 2227a1a740a..e793e268bad 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -30,12 +30,15 @@ struct Section {
 pub(crate) fn prepare(
     repo: &gix::Repository,
     base: ObjectId,
+    onto: ObjectId,
+    onto_title: Option<&str>,
     commits: &[Commit],
     head: Option<ObjectId>,
 ) -> Result<Prepared> {
     let editor = repo.editor().context("no Git editor is available")?;
     repo.find_commit(base)
         .context("could not find the selected rebase base")?;
+    repo.find_commit(onto).context("could not find the rebase target")?;
     let scope: Vec<_> = commits.iter().map(|commit| commit.id).collect();
     let scope_set: HashSet<_> = scope.iter().copied().collect();
     let marker_required = head.is_some_and(|head| scope_set.contains(&head));
@@ -57,7 +60,7 @@ pub(crate) fn prepare(
     let mut sections = Vec::new();
     for child in children.get(&base).into_iter().flatten().copied() {
         let mut section = Section {
-            parent: base,
+            parent: onto,
             commits: Vec::new(),
         };
         let mut branches = Vec::new();
@@ -66,16 +69,26 @@ pub(crate) fn prepare(
         sections.extend(branches);
     }
 
-    let mut document = format!(
-        "# Rebase from `{}`\n\n<!-- Reorder or delete pick lines. Add `## fork <id>` headings or `empty <title>` commits. Move `@` to choose the checkout. -->\n\n",
-        short(repo, base)?
-    )
+    let source = short(repo, base)?;
+    let mut document = if base == onto {
+        format!("# Rebase from `{source}`")
+    } else {
+        format!("# Rebase from `{source}` onto `{}`", short(repo, onto)?)
+    }
     .into_bytes();
+    document.extend_from_slice(
+        b"\n\n<!-- Reorder or delete pick lines. Add `## fork <id>` headings or `empty <title>` commits. Move `@` to choose the checkout. -->\n\n",
+    );
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
             document.push(b'\n');
         }
-        document.extend_from_slice(format!("## fork {}\n", short(repo, section.parent)?).as_bytes());
+        write_fork_heading(
+            &mut document,
+            repo,
+            section.parent,
+            (section.parent == onto && onto != base).then_some(onto_title).flatten(),
+        )?;
         for id in &section.commits {
             let commit = by_id[id];
             let verb = if Some(*id) == head { "@pick" } else { "pick" };
@@ -85,12 +98,17 @@ pub(crate) fn prepare(
         }
     }
     if sections.is_empty() {
-        document.extend_from_slice(format!("## fork {}\n", short(repo, base)?).as_bytes());
+        write_fork_heading(
+            &mut document,
+            repo,
+            onto,
+            (onto != base).then_some(onto_title).flatten(),
+        )?;
     }
     Ok(Prepared {
         editor,
         document,
-        base,
+        base: onto,
         scope,
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
@@ -98,6 +116,15 @@ pub(crate) fn prepare(
     })
 }
 
+fn write_fork_heading(out: &mut Vec<u8>, repo: &gix::Repository, id: ObjectId, title: Option<&str>) -> Result<()> {
+    out.extend_from_slice(format!("## fork {}", short(repo, id)?).as_bytes());
+    if let Some(title) = title {
+        out.extend_from_slice(format!(" {}", escape_markdown(title)).as_bytes());
+    }
+    out.push(b'\n');
+    Ok(())
+}
+
 fn walk(id: ObjectId, children: &HashMap<ObjectId, Vec<ObjectId>>, section: &mut Section, sections: &mut Vec<Section>) {
     section.commits.push(id);
     let Some(child_ids) = children.get(&id) else { return };
@@ -317,7 +344,7 @@ mod tests {
     fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.starts_with(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
         assert!(document.contains(&format!("## fork {}", base.to_hex_with_len(7))));
@@ -331,11 +358,56 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn update_todo_roots_the_stack_at_the_hidden_tip_and_labels_only_that_heading() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, _middle, tip, commits) = commits(&repo)?;
+        let mut commit = repo.find_commit(base)?.decode()?.into_owned()?;
+        commit.parents = [base].into_iter().collect();
+        commit.message = "updated hidden base".into();
+        let onto = repo.write_object(&commit)?.detach();
+
+        let prepared = prepare(
+            &repo,
+            base,
+            onto,
+            Some("[A] updated * hidden base"),
+            &commits,
+            Some(tip),
+        )?;
+        let document = String::from_utf8(prepared.document.clone())?;
+        assert!(
+            document.starts_with(&format!(
+                "# Rebase from `{}` onto `{}`",
+                base.to_hex_with_len(7),
+                onto.to_hex_with_len(7)
+            )),
+            "the update target is explicit in the document title"
+        );
+        assert!(
+            document.contains(&format!(
+                "## fork {} \\[A\\] updated \\* hidden base",
+                onto.to_hex_with_len(7)
+            )),
+            "the unfamiliar fork target carries its escaped UI title"
+        );
+        assert_eq!(
+            document.matches("updated \\* hidden base").count(),
+            1,
+            "only the new update target is labelled"
+        );
+
+        let plan = parse(&repo, prepared, document.as_bytes())?;
+        assert_eq!(plan.base, onto);
+        assert_eq!(plan.steps[0].parent, rebase::PlanParent::Existing(onto));
+        Ok(())
+    }
+
     #[test]
     fn parses_reordering_forks_empty_commits_and_a_moved_checkout() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
         let edited = format!(
             "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -346,7 +418,7 @@ mod tests {
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("two checkout markers are invalid");
         assert!(format!("{err:#}").contains("more than one @"));
 
-        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
         let edited = format!(
             "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -366,12 +438,12 @@ mod tests {
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
         let edited = format!("## fork {}\n", base.to_hex_with_len(7));
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
 
-        let prepared = prepare(&repo, base, &commits, None)?;
+        let prepared = prepare(&repo, base, base, None, &commits, None)?;
         let plan = parse(&repo, prepared, edited.as_bytes())?;
         assert!(
             plan.steps.is_empty(),
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 95165692270..f6d9b22b54c 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -407,13 +407,13 @@ impl HistoryGraph {
             .map(|(visible, _)| crate::app::SelectionRelation::Visible(visible))
     }
 
-    pub(crate) fn hidden_branch_behind(
+    pub(crate) fn hidden_branch_updates(
         &self,
         view_tips: &[ObjectId],
         hidden_tips: impl IntoIterator<Item = ObjectId>,
-    ) -> HashMap<ObjectId, usize> {
+    ) -> HashMap<ObjectId, (usize, ObjectId)> {
         let hidden_tips: HashSet<_> = hidden_tips.into_iter().collect();
-        let mut out: HashMap<ObjectId, usize> = HashMap::new();
+        let mut out: HashMap<ObjectId, (usize, ObjectId)> = HashMap::new();
         for tip in hidden_tips {
             let Some((ahead, _, bases)) = self.paint_with_bases(tip, view_tips) else {
                 continue;
@@ -423,8 +423,8 @@ impl HistoryGraph {
             }
             for base in bases {
                 out.entry(base)
-                    .and_modify(|previous| *previous = (*previous).max(ahead))
-                    .or_insert(ahead);
+                    .and_modify(|previous| *previous = (*previous).max((ahead, tip)))
+                    .or_insert((ahead, tip));
             }
         }
         out
@@ -1735,10 +1735,18 @@ mod tests {
         }
 
         assert_eq!(
-            graph.hidden_branch_behind(&[id(2), id(5)], [id(4)]),
-            HashMap::from([(id(1), 2)]),
+            graph.hidden_branch_updates(&[id(2), id(5)], [id(4)]),
+            HashMap::from([(id(1), (2, id(4)))]),
             "only the fork point in the hidden branch's past reports its missing commits"
         );
+
+        insert_commit(&mut graph, 7, &[1], 2);
+        insert_commit(&mut graph, 6, &[7], 3);
+        assert_eq!(
+            graph.hidden_branch_updates(&[id(2), id(5)], [id(4), id(6)]),
+            HashMap::from([(id(1), (2, id(6)))]),
+            "equal distances choose a deterministic hidden tip"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index cf317f3754e..b208f803567 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1243,7 +1243,7 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
-                    update_hidden_branch_behind(&mut app, history_graph.as_ref(), &ref_snapshot);
+                    update_hidden_branch_updates(&mut app, history_graph.as_ref(), &ref_snapshot);
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "lane-computation-completed");
                     filesystem_responses.queue_frame(&response_ids, "lane-computation-completed");
@@ -1434,7 +1434,7 @@ fn event_loop(
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     history_graph = Some(graph);
-                    update_hidden_branch_behind(&mut app, history_graph.as_ref(), &ref_snapshot);
+                    update_hidden_branch_updates(&mut app, history_graph.as_ref(), &ref_snapshot);
                     selection_relation = None;
                     app.selection_relation = None;
                 }
@@ -1988,7 +1988,12 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("forget: {err:#}")),
                     }
                 }
-                Effect::Rebase { base, commits, head } => {
+                Effect::Rebase {
+                    base,
+                    onto,
+                    commits,
+                    head,
+                } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let todo_commits = commits
@@ -2010,12 +2015,23 @@ fn event_loop(
                         .as_ref()
                         .context("rebasing requires a completed history graph")
                         .and_then(|graph| {
+                            let onto_title = if onto == base {
+                                None
+                            } else {
+                                Some(ui::todo_title(
+                                    &app,
+                                    app.commit(onto)
+                                        .context("the hidden rebase target disappeared from the view")?,
+                                ))
+                            };
                             rebase_history(
                                 terminal,
                                 &repository_path,
                                 repository_is_bare,
                                 graph,
                                 base,
+                                onto,
+                                onto_title,
                                 todo_commits?,
                                 head,
                                 enhanced_keyboard,
@@ -2387,9 +2403,9 @@ fn decoration_successor(selected: gix::ObjectId, current: &Decorations, next: &D
     matches.all(|candidate| candidate == successor).then_some(successor)
 }
 
-fn update_hidden_branch_behind(app: &mut App, graph: Option<&HistoryGraph>, refs: &history::RefSnapshot) {
-    let markers = graph.map_or_else(HashMap::new, |graph| {
-        graph.hidden_branch_behind(
+fn update_hidden_branch_updates(app: &mut App, graph: Option<&HistoryGraph>, refs: &history::RefSnapshot) {
+    let updates = graph.map_or_else(HashMap::new, |graph| {
+        graph.hidden_branch_updates(
             &refs.view_tips,
             refs.hidden
                 .iter()
@@ -2397,7 +2413,7 @@ fn update_hidden_branch_behind(app: &mut App, graph: Option<&HistoryGraph>, refs
                 .filter_map(|(_, target)| target.try_id().map(ToOwned::to_owned)),
         )
     });
-    app.set_hidden_branch_behind(markers);
+    app.set_hidden_branch_updates(updates);
 }
 
 fn restore_change_selection(view: &mut app::ChangesView, changes: &Changes, remembered: Option<(BString, usize)>) {
@@ -3115,6 +3131,8 @@ fn rebase_history(
     bare: bool,
     graph: &HistoryGraph,
     base: gix::ObjectId,
+    onto: gix::ObjectId,
+    onto_title: Option<String>,
     commits: Vec<edit::todo::Commit>,
     head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
@@ -3123,7 +3141,7 @@ fn rebase_history(
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;
         repository.object_cache_size(None);
-        edit::todo::prepare(&repository, base, &commits, head)?
+        edit::todo::prepare(&repository, base, onto, onto_title.as_deref(), &commits, head)?
     };
     let Some(edited) = edit::edit_document(
         terminal,
@@ -3926,6 +3944,9 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('c') => Some(Action::ToggleChanges),
         KeyCode::Char('p') if edit_expanded => Some(Action::Split),
         KeyCode::Char('b') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
+        KeyCode::Char('u') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+            Some(Action::RebaseUpdate)
+        }
         KeyCode::Char('f') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::ForkCommit)
         }
@@ -4935,6 +4956,7 @@ mod tests {
         );
         for (key, expected) in [
             ('b', Action::Rebase),
+            ('u', Action::RebaseUpdate),
             ('r', Action::Reword),
             ('n', Action::NewCommit),
             ('f', Action::ForkCommit),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 76b69af9037..9d0a3f00cb0 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -747,6 +747,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_rebase() {
                 options.push(("rebase", 'b'));
             }
+            if app.can_rebase_update() {
+                options.push(("rebase-update", 'u'));
+            }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'r'));
             }
@@ -1777,6 +1780,18 @@ pub(crate) fn todo_metadata(
     out
 }
 
+pub(crate) fn todo_title(app: &App, row: &CommitRow) -> String {
+    let mut out = String::new();
+    if row.has_agent_marker {
+        out.push_str("[A] ");
+    }
+    if !app.notes(row.id).is_empty() {
+        out.push_str("[N] ");
+    }
+    out.push_str(&app.title(row).to_str_lossy());
+    out
+}
+
 fn author_label(
     author: &crate::app::Author,
     mailmap: &gix::mailmap::Snapshot,
@@ -4322,6 +4337,11 @@ mod tests {
             row.contains("[A] [N] subject"),
             "agent and note markers precede the title"
         );
+        assert_eq!(
+            todo_title(&app, &app.rows[0]),
+            "[A] [N] subject",
+            "rebase headings reuse the title exactly as shown in history"
+        );
         assert_eq!(history.backend().buffer()[(agent_x, 0)].fg, Color::LightMagenta);
         assert_eq!(history.backend().buffer()[(note_x, 0)].fg, Color::LightMagenta);
 
@@ -4471,7 +4491,10 @@ mod tests {
         app.extend_hidden_commits(vec![commit(2)]);
         complete(&mut app);
         app.select_commit(gix::ObjectId::Sha1([2; 20]));
-        app.set_hidden_branch_behind(std::collections::HashMap::from([(gix::ObjectId::Sha1([2; 20]), 2)]));
+        app.set_hidden_branch_updates(std::collections::HashMap::from([(
+            gix::ObjectId::Sha1([2; 20]),
+            (2, gix::ObjectId::Sha1([3; 20])),
+        )]));
         app.set_lane(0, "● ");
         app.set_lane(1, "● ");
         let changes = Changes {
@@ -4568,7 +4591,7 @@ mod tests {
         let mut actions = Terminal::new(TestBackend::new(120, 3))?;
         actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&actions, 2).contains("edit (rebase · fork)"),
+            rendered_line(&actions, 2).contains("edit (rebase · rebase-update · fork)"),
             "the selected hidden base offers independent edits: {:?}",
             rendered_line(&actions, 2)
         );

From 6715fbad20cba00090da9c9d027a4f0f540783aa Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 09:29:00 +0200
Subject: [PATCH 080/282] feat: create explicit empty commits in tix

Distinguish commits created from tracked index or worktree changes from deliberately empty commits. Advertise both choices from cached worktree status without opening a repository merely to expand the edit menu, while retaining authoritative validation when no cache is available.

Keep untracked paths out of implicit new commits, preserve the complete index and worktree when creating an explicit empty commit, and reject either operation while the index is conflicted. Document the resulting edit semantics in the tix specification.
---
 gix-tix/spec.md            |  23 +++++---
 gix-tix/src/app.rs         | 106 +++++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/create.rs |  98 ++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/rebase.rs |  41 +++++++++-----
 gix-tix/src/lib.rs         |  51 ++++++++++++++----
 gix-tix/src/ui.rs          |  11 +++-
 6 files changed, 289 insertions(+), 41 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 4e9312e2833..f71f0b73fdc 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -339,19 +339,28 @@ space first; changes blocks adapt within the remaining history width.
 
 ### New commits
 
-- `e`, then `n`, creates a child of the selected commit, or a root commit for an
-  unborn `HEAD`. It is available only with a live worktree, after history
-  completion, and when the selected parent has no known merge descendant.
+- `e n` creates a child of the selected commit from tracked changes, or a root
+  commit for an unborn `HEAD`. A changed index wins; otherwise, tracked worktree
+  changes are used. Untracked files never enter an implicit new commit and remain
+  untracked. It is available only with a live worktree, after history completion,
+  and when the selected parent has no known merge descendant.
+- `e m` creates an explicit empty commit which reuses the selected parent's tree,
+  or the empty tree for an unborn history. Existing index and worktree state is
+  preserved exactly. Both forms reject unresolved index conflicts.
+- A current worktree-changes cache controls which actions are advertised without
+  opening a repository: tracked changes offer both `new` and `new-empty`, while a
+  clean or untracked-only worktree offers only `new-empty`. If no current cache is
+  available, both are shown and `new` validates its candidate before opening the
+  editor, directing an empty candidate to `new-empty`.
 - Before launching the editor, tix resolves identities, signing configuration,
   index conflicts, filters,
   candidate tree, per-path diffstat, and a provisional commit entirely through an
   in-memory object database. Cancellation and preflight failure write no object,
   reference, index, or worktree state.
 - A changed index supplies the complete commit tree and wins over unstaged
-  changes. Otherwise, when the worktree `HEAD` is the selected parent, worktree
-  changes are filtered into a tree. With no applicable changes—or when the
-  selected parent is not the worktree base—the parent tree is reused; an unborn
-  repository starts from the empty tree.
+  changes. Otherwise, when the worktree `HEAD` is the selected parent, tracked
+  worktree changes are filtered into a tree. A normal `new` rejects a tree equal
+  to its parent; `new-empty` deliberately reuses it.
 - The Markdown editor buffer contains editable identities and dates, a `what`
   title, a `why` body, optional attribution trailers, and a commented Git-style
   per-path diffstat with signed net line counts. Commit hooks are not run.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7995f124acb..e6279aa5a63 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -142,6 +142,7 @@ pub(crate) struct Changes {
     pub diffs: Vec<crate::FileChange>,
     pub lines_added: u64,
     pub lines_removed: u64,
+    pub has_tracked_changes: bool,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -294,6 +295,7 @@ pub(crate) enum Action {
     OpenDiff,
     Reword,
     NewCommit,
+    NewEmptyCommit,
     ForkCommit,
     Amend,
     Spill,
@@ -322,7 +324,10 @@ pub(crate) enum Effect {
     OpenDiff(ChangePane, usize),
     OpenCommitDiff(TreeDiffTarget),
     Reword(ObjectId),
-    NewCommit(Option<ObjectId>),
+    NewCommit {
+        parent: Option<ObjectId>,
+        empty: bool,
+    },
     ForkCommit(ObjectId),
     Amend(ObjectId),
     Spill(ObjectId),
@@ -428,6 +433,8 @@ pub(crate) struct App {
     amend_available: bool,
     spill_available: bool,
     split_available: bool,
+    new_commit_available: bool,
+    new_empty_commit_available: bool,
     known_descendants: HashSet<ObjectId>,
     known_merge_descendants: HashSet<ObjectId>,
     select_top_after_refresh: bool,
@@ -513,6 +520,8 @@ impl App {
             amend_available: false,
             spill_available: false,
             split_available: false,
+            new_commit_available: true,
+            new_empty_commit_available: true,
             known_descendants: HashSet::new(),
             known_merge_descendants: HashSet::new(),
             select_top_after_refresh: false,
@@ -767,6 +776,7 @@ impl App {
             Action::ToggleEdit
                 | Action::Reword
                 | Action::NewCommit
+                | Action::NewEmptyCommit
                 | Action::ForkCommit
                 | Action::Amend
                 | Action::Spill
@@ -945,9 +955,16 @@ impl App {
                 )];
             }
             Action::NewCommit if self.can_create_commit() => {
-                return vec![Effect::NewCommit(
-                    self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
-                )];
+                return vec![Effect::NewCommit {
+                    parent: self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
+                    empty: false,
+                }];
+            }
+            Action::NewEmptyCommit if self.can_create_empty_commit() => {
+                return vec![Effect::NewCommit {
+                    parent: self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id),
+                    empty: true,
+                }];
             }
             Action::ForkCommit if self.can_fork_commit() => {
                 return vec![Effect::ForkCommit(
@@ -1573,6 +1590,14 @@ impl App {
     }
 
     pub(crate) fn can_create_commit(&self) -> bool {
+        self.new_commit_available && self.can_create_any_commit()
+    }
+
+    pub(crate) fn can_create_empty_commit(&self) -> bool {
+        self.new_empty_commit_available && self.can_create_any_commit()
+    }
+
+    fn can_create_any_commit(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
             && self.changes_focus.is_none()
@@ -1583,6 +1608,26 @@ impl App {
             }
     }
 
+    pub(crate) fn set_new_commit_availability(&mut self, changes: Option<&Changes>) {
+        let selected_is_head =
+            self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) == self.worktree_head;
+        let selected_is_head = selected_is_head || (self.selected.is_none() && self.worktree_head_unborn);
+        match changes {
+            Some(changes) if changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged) => {
+                self.new_commit_available = false;
+                self.new_empty_commit_available = false;
+            }
+            Some(changes) => {
+                self.new_commit_available = selected_is_head && changes.has_tracked_changes;
+                self.new_empty_commit_available = true;
+            }
+            None => {
+                self.new_commit_available = true;
+                self.new_empty_commit_available = true;
+            }
+        }
+    }
+
     pub(crate) fn can_fork_commit(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -2477,10 +2522,61 @@ mod tests {
             unborn.can_create_commit(),
             "an unborn worktree can create its root commit"
         );
-        assert_eq!(unborn.update(Action::NewCommit), vec![Effect::NewCommit(None)]);
+        assert_eq!(
+            unborn.update(Action::NewCommit),
+            vec![Effect::NewCommit {
+                parent: None,
+                empty: false,
+            }]
+        );
         assert!(!unborn.can_fork_commit(), "a fork requires a selected parent");
     }
 
+    #[test]
+    fn cached_worktree_changes_choose_new_or_new_empty_without_io() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row(1)]);
+        app.set_worktree_head(Some(id(1)), false);
+        complete(&mut app);
+
+        app.set_new_commit_availability(Some(&Changes::default()));
+        assert!(
+            !app.can_create_commit(),
+            "a known-clean worktree cannot create an implicit empty commit"
+        );
+        assert!(
+            app.can_create_empty_commit(),
+            "an explicit empty commit remains available"
+        );
+
+        let tracked = Changes {
+            has_tracked_changes: true,
+            ..Changes::default()
+        };
+        app.set_new_commit_availability(Some(&tracked));
+        assert!(app.can_create_commit());
+        assert!(app.can_create_empty_commit());
+
+        let conflicted = Changes {
+            paths: vec![PathChange {
+                kind: ChangeKind::Unmerged,
+                group: ChangeGroup::Unstaged,
+                source: None,
+                path: "conflict".into(),
+                lines: None,
+            }],
+            has_tracked_changes: true,
+            ..Changes::default()
+        };
+        app.set_new_commit_availability(Some(&conflicted));
+        assert!(!app.can_create_commit());
+        assert!(!app.can_create_empty_commit());
+
+        app.set_new_commit_availability(None);
+        assert!(app.can_create_commit(), "an absent cache leaves both choices available");
+        assert!(app.can_create_empty_commit());
+    }
+
     #[test]
     fn time_travel_requires_completed_history_and_a_worktree() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 1b00d2d5257..1fa7334b1b8 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -16,10 +16,21 @@ pub(crate) struct Prepared {
     pub(super) parent: Option<ObjectId>,
     pub(super) tree: ObjectId,
     pub(super) objects: gix::odb::memory::Storage,
+    pub(crate) is_empty: bool,
+    pub(super) reset_index: bool,
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
-pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
+pub(crate) fn prepare(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
+    prepare_inner(repo, parent, false)
+}
+
+#[tracing::instrument(skip_all, fields(parent = ?parent))]
+pub(crate) fn prepare_empty(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
+    prepare_inner(repo, parent, true)
+}
+
+fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: bool) -> Result<Prepared> {
     repo.workdir().context("creating a commit requires a worktree")?;
     let head = repo.head().context("could not read HEAD before creating a commit")?;
     let head_id = head.id().map(gix::Id::detach);
@@ -58,6 +69,7 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
             .context("could not load the parent tree")?,
         None => repo.empty_tree(),
     };
+    let baseline_id = baseline.id;
     let index = repo.index_or_empty().context("could not load the index")?;
     if index
         .entries()
@@ -68,10 +80,12 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
     }
     let index_tree = index_tree(&repo, &index)?;
     let based_on_parent = head_id == parent;
-    let tree = if based_on_parent && index_tree != baseline.id {
+    let tree = if empty {
+        baseline.id
+    } else if based_on_parent && index_tree != baseline.id {
         index_tree
     } else if based_on_parent {
-        worktree_tree(&repo, &baseline)?
+        worktree_tree_tracked(&repo, &baseline, &index)?
     } else {
         baseline.id
     };
@@ -118,6 +132,8 @@ pub(crate) fn prepare(mut repo: gix::Repository, parent: Option<ObjectId>) -> Re
         parent,
         tree,
         objects,
+        is_empty: tree == baseline_id,
+        reset_index: !empty,
     })
 }
 
@@ -140,13 +156,31 @@ pub(super) fn index_tree(repo: &gix::Repository, index: &gix::index::File) -> Re
 
 pub(super) fn worktree_tree(repo: &gix::Repository, baseline: &gix::Tree<'_>) -> Result<ObjectId> {
     let changes = load_worktree_changes_without_lines(repo)?;
-    worktree_tree_with_changes(repo, baseline, &changes)
+    worktree_tree_with_changes_inner(repo, baseline, &changes, None)
+}
+
+fn worktree_tree_tracked(
+    repo: &gix::Repository,
+    baseline: &gix::Tree<'_>,
+    index: &gix::index::File,
+) -> Result<ObjectId> {
+    let changes = load_worktree_changes_without_lines(repo)?;
+    worktree_tree_with_changes_inner(repo, baseline, &changes, Some(index))
 }
 
 pub(super) fn worktree_tree_with_changes(
     repo: &gix::Repository,
     baseline: &gix::Tree<'_>,
     changes: &crate::Changes,
+) -> Result<ObjectId> {
+    worktree_tree_with_changes_inner(repo, baseline, changes, None)
+}
+
+fn worktree_tree_with_changes_inner(
+    repo: &gix::Repository,
+    baseline: &gix::Tree<'_>,
+    changes: &crate::Changes,
+    tracked_by: Option<&gix::index::File>,
 ) -> Result<ObjectId> {
     if changes.paths.is_empty() {
         return Ok(baseline.id);
@@ -160,6 +194,15 @@ pub(super) fn worktree_tree_with_changes(
         .iter()
         .filter(|change| change.group == ChangeGroup::Unstaged)
     {
+        if tracked_by.is_some_and(|index| {
+            index.entry_by_path(change.path.as_bstr()).is_none()
+                && change
+                    .source
+                    .as_ref()
+                    .is_none_or(|source| index.entry_by_path(source.as_bstr()).is_none())
+        }) {
+            continue;
+        }
         if let Some(source) = &change.source {
             editor
                 .remove(source)
@@ -205,6 +248,7 @@ pub(crate) fn apply(
         rebase::Edit::Insert {
             anchor: prepared.parent,
             commit,
+            reset_index: prepared.reset_index,
         },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
@@ -531,7 +575,7 @@ mod tests {
                 .success()
         );
         let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let prepared = prepare(open(fixture.path())?, None)?;
+        let prepared = prepare_empty(open(fixture.path())?, None)?;
         assert_eq!(
             gix_testtools::repository::snapshot(fixture.path())?,
             before,
@@ -556,6 +600,50 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn explicit_empty_commit_preserves_index_and_worktree_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let parent = open(fixture.path())?.head_id()?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare_empty(open(fixture.path())?, Some(parent))?;
+        assert!(prepared.is_empty, "the explicit commit reuses its parent's tree");
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"empty\n\nreason", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
+        let repository = open(fixture.path())?;
+        let commit = repository.find_commit(new_id)?;
+        assert_eq!(
+            commit.tree_id()?.detach(),
+            repository.find_commit(parent)?.tree_id()?.detach(),
+            "the explicit empty commit keeps the parent tree"
+        );
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(after.index, before.index, "staged changes remain staged");
+        assert_eq!(
+            after.worktree, before.worktree,
+            "worktree changes remain byte-identical"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn implicit_new_commit_ignores_untracked_files() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["reset", "--hard", "-q", "HEAD"])
+                .status()?
+                .success(),
+            "tracked files are restored while the untracked fixture remains"
+        );
+        let parent = open(fixture.path())?.head_id()?.detach();
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        assert!(prepared.is_empty, "untracked files do not enter an implicit new commit");
+        Ok(())
+    }
+
     #[test]
     fn an_unrelated_worktree_head_is_not_checked_out_or_moved() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index a8a704173dd..e8aa0e79645 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -43,6 +43,7 @@ pub(crate) enum Edit {
     Insert {
         anchor: Option<ObjectId>,
         commit: gix::objs::Commit,
+        reset_index: bool,
     },
     Fork {
         anchor: ObjectId,
@@ -174,8 +175,7 @@ impl PersistedConflict {
 struct Prepared {
     repo: gix::Repository,
     root: Option<ObjectId>,
-    inserted: bool,
-    marked: bool,
+    reset_index: bool,
     skip_worktree_transitions: bool,
     selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
@@ -232,13 +232,26 @@ pub(crate) fn perform(
     mut tree_mode: Tree,
 ) -> Result<Perform> {
     let mut repo = repo.clone();
-    let (root, replacement, inserted, forked, removed, repeat, mut split_upper) = match edit {
-        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, None),
-        Edit::Insert { anchor, commit } => (anchor, Some(commit), true, false, false, false, None),
-        Edit::Fork { anchor, commit } => (Some(anchor), Some(commit), false, true, false, false, None),
-        Edit::Remove { target } => (Some(target), None, false, false, true, false, None),
-        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, false, Some(upper)),
-        Edit::Repeat { base } => (Some(base), None, false, false, false, true, None),
+    let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, false, None),
+        Edit::Insert {
+            anchor,
+            commit,
+            reset_index,
+        } => (anchor, Some(commit), true, reset_index, false, false, false, None),
+        Edit::Fork { anchor, commit } => (Some(anchor), Some(commit), false, false, true, false, false, None),
+        Edit::Remove { target } => (Some(target), None, false, false, false, true, false, None),
+        Edit::Split { target, source, upper } => (
+            Some(target),
+            Some(source),
+            false,
+            false,
+            false,
+            false,
+            false,
+            Some(upper),
+        ),
+        Edit::Repeat { base } => (Some(base), None, false, false, false, false, true, None),
     };
     if repeat {
         tree_mode = Tree::CherryPick;
@@ -382,11 +395,11 @@ pub(crate) fn perform(
         }
     }
 
+    let marked = (!forked && tree_mode == Tree::LeaveAsIsAndMark) || conflict.is_some();
     let mut prepared = Prepared {
         repo,
         root,
-        inserted,
-        marked: (!forked && tree_mode == Tree::LeaveAsIsAndMark) || conflict.is_some(),
+        reset_index: if inserted { reset_index } else { marked },
         skip_worktree_transitions: inserted || forked || (tree_mode == Tree::LeaveAsIsAndMark && !removed),
         selected,
         rewritten,
@@ -572,11 +585,11 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         }
     }
     let selected = plan.checkout.map(|index| produced[index]);
+    let marked = plan.steps.iter().enumerate().any(|(index, _)| !eager.contains(&index)) || conflict.is_some();
     let mut prepared = Prepared {
         repo,
         root: Some(plan.base),
-        inserted: false,
-        marked: plan.steps.iter().enumerate().any(|(index, _)| !eager.contains(&index)) || conflict.is_some(),
+        reset_index: marked,
         skip_worktree_transitions: false,
         selected,
         rewritten,
@@ -610,7 +623,7 @@ impl Prepared {
         }
 
         let transitions = worktree_transitions(&self.repo, &self.rewritten, self.skip_worktree_transitions)?;
-        let index_reset_from = if self.inserted || self.marked { self.root } else { None };
+        let index_reset_from = if self.reset_index { self.root } else { None };
         let index_resets = index_reset_from
             .map(|old| index_resets(&self.repo, &self.rewritten, old))
             .transpose()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b208f803567..f67627869f5 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1802,7 +1802,7 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("reword: {err:#}")),
                     }
                 }
-                Effect::NewCommit(parent) => {
+                Effect::NewCommit { parent, empty } => {
                     let result = history_graph
                         .as_ref()
                         .context("creating a commit requires a completed history graph")
@@ -1813,7 +1813,11 @@ fn event_loop(
                                 repository_is_bare,
                                 graph,
                                 parent,
-                                CreateMode::Insert,
+                                if empty {
+                                    CreateMode::InsertEmpty
+                                } else {
+                                    CreateMode::Insert
+                                },
                                 enhanced_keyboard,
                             )
                         });
@@ -3163,6 +3167,7 @@ fn rebase_history(
 #[derive(Clone, Copy)]
 enum CreateMode {
     Insert,
+    InsertEmpty,
     Fork,
 }
 
@@ -3179,7 +3184,14 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before creating commit")?;
     repository.object_cache_size(None);
-    let prepared = edit::create::prepare(repository, parent)?;
+    let prepared = if matches!(mode, CreateMode::InsertEmpty) {
+        edit::create::prepare_empty(repository, parent)?
+    } else {
+        edit::create::prepare(repository, parent)?
+    };
+    if matches!(mode, CreateMode::Insert) && prepared.is_empty {
+        anyhow::bail!("the new commit would be empty; use new-empty instead");
+    }
     let Some(edited) = edit::edit_document(
         terminal,
         &prepared.editor,
@@ -3194,7 +3206,7 @@ fn create_commit(
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
     match mode {
-        CreateMode::Insert => edit::create::apply(repository, graph, prepared, &edited),
+        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited),
         CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited),
     }
     .map(Some)
@@ -3690,11 +3702,11 @@ fn worktree_resource(entry: &gix::index::Entry, path: &gix::bstr::BStr) -> Resul
 fn unstaged_change(
     item: gix::status::index_worktree::Item,
     object_hash: gix::hash::Kind,
-) -> Result<Option<(PathChange, FileChange)>> {
+) -> Result<Option<(PathChange, FileChange, bool)>> {
     use gix::status::index_worktree::Item;
     use gix::status::plumbing::index_as_worktree::{Change, EntryStatus};
 
-    let (kind, source, path, diff) = match item {
+    let (kind, source, path, diff, tracked) = match item {
         Item::Modification {
             entry,
             rela_path,
@@ -3708,6 +3720,7 @@ fn unstaged_change(
                     None,
                     rela_path,
                     FileChange::Unavailable("an unmerged path has no single file diff"),
+                    true,
                 ),
                 EntryStatus::IntentToAdd => (
                     ChangeKind::Added,
@@ -3721,6 +3734,7 @@ fn unstaged_change(
                             path: rela_path,
                         }),
                     },
+                    true,
                 ),
                 EntryStatus::NeedsUpdate(_) => return Ok(None),
                 EntryStatus::Change(Change::Removed) => (
@@ -3731,6 +3745,7 @@ fn unstaged_change(
                         old: Some(old),
                         new: None,
                     },
+                    true,
                 ),
                 EntryStatus::Change(Change::Type { worktree_mode }) => {
                     let new_mode = entry_mode(worktree_mode)?;
@@ -3746,6 +3761,7 @@ fn unstaged_change(
                                 path: rela_path,
                             }),
                         },
+                        true,
                     )
                 }
                 EntryStatus::Change(Change::Modification {
@@ -3773,6 +3789,7 @@ fn unstaged_change(
                                 path: rela_path,
                             }),
                         },
+                        true,
                     )
                 }
                 EntryStatus::Change(Change::SubmoduleModification(_)) => (
@@ -3780,6 +3797,7 @@ fn unstaged_change(
                     None,
                     rela_path,
                     FileChange::Unavailable("submodule changes don't have a file diff"),
+                    true,
                 ),
             }
         }
@@ -3802,6 +3820,7 @@ fn unstaged_change(
                         path,
                     }),
                 },
+                false,
             )
         }
         Item::Rewrite {
@@ -3817,6 +3836,7 @@ fn unstaged_change(
                 Some(source),
                 path,
                 FileChange::Unavailable("unstaged rewrite diffs aren't available"),
+                true,
             )
         }
     };
@@ -3829,6 +3849,7 @@ fn unstaged_change(
             lines: None,
         },
         diff,
+        tracked,
     )))
 }
 
@@ -3844,12 +3865,17 @@ fn load_worktree_changes_without_lines(repository: &gix::Repository) -> Result<C
         .context("could not start worktree status")?;
     let mut staged = Vec::new();
     let mut unstaged = Vec::new();
+    let mut has_tracked_changes = false;
     for item in status.by_ref() {
         match item.context("could not obtain worktree status")? {
-            gix::status::Item::TreeIndex(change) => staged.push(staged_change(change)?),
+            gix::status::Item::TreeIndex(change) => {
+                has_tracked_changes = true;
+                staged.push(staged_change(change)?);
+            }
             gix::status::Item::IndexWorktree(item) => {
-                if let Some(change) = unstaged_change(item, repository.object_hash())? {
-                    unstaged.push(change);
+                if let Some((path, diff, tracked)) = unstaged_change(item, repository.object_hash())? {
+                    has_tracked_changes |= tracked;
+                    unstaged.push((path, diff));
                 }
             }
         }
@@ -3863,6 +3889,7 @@ fn load_worktree_changes_without_lines(repository: &gix::Repository) -> Result<C
     Ok(Changes {
         paths,
         diffs,
+        has_tracked_changes,
         ..Changes::default()
     })
 }
@@ -3977,6 +4004,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
         KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
         KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
+        KeyCode::Char('m') if edit_expanded => Some(Action::NewEmptyCommit),
         KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
@@ -4803,6 +4831,10 @@ mod tests {
             "status is partitioned, path-sorted, includes conflicts and untracked files, and excludes ignored files"
         );
         assert!(changes.lines_added > 0, "available file diffs contribute line counts");
+        assert!(
+            changes.has_tracked_changes,
+            "staged and tracked worktree changes are classified once"
+        );
         for (path, diff) in changes.paths.iter().zip(&changes.diffs) {
             if path.kind != ChangeKind::Unmerged {
                 prepare_file_diff_with_repository(&repository, diff, path)
@@ -4959,6 +4991,7 @@ mod tests {
             ('u', Action::RebaseUpdate),
             ('r', Action::Reword),
             ('n', Action::NewCommit),
+            ('m', Action::NewEmptyCommit),
             ('f', Action::ForkCommit),
             ('a', Action::Amend),
             ('s', Action::Spill),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 9d0a3f00cb0..e3f881eccc0 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -246,6 +246,11 @@ pub(crate) fn draw_with_worktree(
     if let Some(changes) = worktree_changes {
         app.set_worktree_conflicted(changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
     }
+    app.set_new_commit_availability(
+        (app.changes_mode == Some(ChangesMode::Both))
+            .then_some(worktree_changes)
+            .flatten(),
+    );
     let selected_is_head = app.selected.and_then(|index| app.rows.get(index)).is_some_and(|row| {
         decorations
             .get(&row.id)
@@ -756,6 +761,9 @@ pub(crate) fn draw_with_worktree(
             if app.changes_focus.is_none() && app.can_create_commit() {
                 options.push(("new", 'n'));
             }
+            if app.changes_focus.is_none() && app.can_create_empty_commit() {
+                options.push(("new-empty", 'm'));
+            }
             if app.can_fork_commit() {
                 options.push(("fork", 'f'));
             }
@@ -2749,7 +2757,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
         assert!(
-            rendered_line(&terminal, 1).contains("edit (reword · new · fork · d forget · return)"),
+            rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return)"),
             "the active edit prefix contains exactly its actionable commands"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
@@ -3658,6 +3666,7 @@ mod tests {
             diffs: Vec::new(),
             lines_added: 42,
             lines_removed: 17,
+            has_tracked_changes: false,
         };
         let mut terminal = Terminal::new(TestBackend::new(120, 16))?;
 

From 2fb3f0ab2e60064f56a1d150d5c7ed9ce291b686 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 09:32:10 +0200
Subject: [PATCH 081/282] feat: make tix rebase todos self-documenting

Put a brief help pointer on the first line of every history-rebase todo and move complete editing guidance below the plan. Keep every instruction inside Markdown comments so help remains visible to editors without participating in parsing.

Document picking, dropping, reordering, forking, joining, empty commits, checkout selection, lazy replay, reference updates, pins, and conflict behavior alongside the editable plan.
---
 gix-tix/spec.md          |  3 +++
 gix-tix/src/edit/todo.rs | 39 +++++++++++++++++++++++++++++++--------
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index f71f0b73fdc..4746b61368e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -484,6 +484,9 @@ space first; changes blocks adapt within the remaining history width.
   branches. `empty <title>` inserts an empty commit. Markdown code spans and
   equivalent plain commands are accepted; display text after a pick ID is
   informational.
+- The first line points to complete self-documenting help at the bottom. All
+  instructions are enclosed in Markdown comments so only headings and command
+  lines participate in the editable plan.
 - `@pick` or `@empty` chooses the post-rebase checkout. When the current worktree
   `HEAD` is in the editable region, exactly one generated `@` must remain; without
   one, zero or one may be added. A checkout marker is invalid without a worktree.
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index e793e268bad..2dbb7fea395 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -5,6 +5,23 @@ use gix::{ObjectId, bstr::BString, prelude::ObjectIdExt};
 
 use super::rebase;
 
+const HELP: &[u8] = br#"
+
+<!--
+# Rebase todo help
+
+- Each fork section lists a stack from its oldest commit to its newest. Blank lines are ignored.
+- `pick <id>` keeps a commit. Delete its line to drop it, or move the line to reorder it. Each listed commit may be picked only once.
+- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
+- `empty <title>` creates an empty commit with the text after the command as its title.
+- Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
+- Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
+- Saving an unchanged document is a no-op. Otherwise, the ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
+- Mutable refs follow rewritten and dropped commits, except tags and remote-tracking refs. New unreferenced leaves are pinned.
+- A checkout conflict uses tix's standard suspended-conflict flow; concurrent ref changes abort the update.
+-->
+"#;
+
 pub(crate) struct Commit {
     pub id: ObjectId,
     pub parents: Vec<ObjectId>,
@@ -70,15 +87,14 @@ pub(crate) fn prepare(
     }
 
     let source = short(repo, base)?;
-    let mut document = if base == onto {
+    let title = if base == onto {
         format!("# Rebase from `{source}`")
     } else {
         format!("# Rebase from `{source}` onto `{}`", short(repo, onto)?)
-    }
-    .into_bytes();
-    document.extend_from_slice(
-        b"\n\n<!-- Reorder or delete pick lines. Add `## fork <id>` headings or `empty <title>` commits. Move `@` to choose the checkout. -->\n\n",
-    );
+    };
+    let mut document = b"<!-- Rebase help is at the bottom of this file. -->\n\n".to_vec();
+    document.extend_from_slice(title.as_bytes());
+    document.extend_from_slice(b"\n\n");
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
             document.push(b'\n');
@@ -105,6 +121,7 @@ pub(crate) fn prepare(
             (onto != base).then_some(onto_title).flatten(),
         )?;
     }
+    document.extend_from_slice(HELP);
     Ok(Prepared {
         editor,
         document,
@@ -346,7 +363,8 @@ mod tests {
         let (base, _middle, tip, commits) = commits(&repo)?;
         let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.starts_with(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
+        assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
+        assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
         assert!(document.contains(&format!("## fork {}", base.to_hex_with_len(7))));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
@@ -355,6 +373,11 @@ mod tests {
             document.contains("middle \\* markdown"),
             "metadata is escaped for Markdown"
         );
+        assert!(
+            document.find("# Rebase todo help").expect("help is present") > tip,
+            "complete instructions follow the editable todo"
+        );
+        assert!(document.ends_with("-->\n"), "all trailing help is one Markdown comment");
         Ok(())
     }
 
@@ -377,7 +400,7 @@ mod tests {
         )?;
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(
-            document.starts_with(&format!(
+            document.contains(&format!(
                 "# Rebase from `{}` onto `{}`",
                 base.to_hex_with_len(7),
                 onto.to_hex_with_len(7)

From 5bc17767de597ab98d151f5b8b495f1b51dd0fe3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 11:31:52 +0200
Subject: [PATCH 082/282] feat: add tix review workflows

Let a review expose the difference between a selected commit and an ancestor as worktree changes backed by an ordinary review commit and a worktree-local refs/worktree/tix/review/N reference.

Offer ancestor selection through the edit prefix, preserve hidden fork points as selectable review bases, mark review commits with a stable star, and show review decorations independently of ordinary ref visibility. Review commits amend staged changes only and can finish only from a clean worktree.

Finish reviews by moving the reviewed tree onto its original tip, preserving exact trees for review-side descendants, and lazily reparenting natural descendants without unnecessary cherry-picks. Keep fork topology intact and delete review references atomically when finishing, forgetting, or dropping review commits from a rebase todo.

Document the lifecycle and cover start, finish, navigation, rendering, and resource cleanup.
---
 gix-tix/spec.md            |  32 +++
 gix-tix/src/app.rs         | 152 +++++++++++++-
 gix-tix/src/edit/forget.rs |  35 +++-
 gix-tix/src/edit/head.rs   |  15 +-
 gix-tix/src/edit/mod.rs    |   1 +
 gix-tix/src/edit/rebase.rs | 258 +++++++++++++++++++++++-
 gix-tix/src/edit/review.rs | 398 +++++++++++++++++++++++++++++++++++++
 gix-tix/src/history.rs     |  71 ++++++-
 gix-tix/src/lib.rs         |  44 ++++
 gix-tix/src/ui.rs          |  87 +++++++-
 10 files changed, 1047 insertions(+), 46 deletions(-)
 create mode 100644 gix-tix/src/edit/review.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 4746b61368e..4a0dc577f16 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -422,6 +422,38 @@ space first; changes blocks adapt within the remaining history width.
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
 
+### Reviews
+
+- `e v` starts a review from any non-boundary commit without merge descendants.
+  It limits navigation to the selected commit's ancestry; the connected hidden
+  base remains selectable, `<enter>` confirms it, and Escape cancels before any
+  repository change.
+- Starting requires a completely clean index and worktree, including no untracked
+  files, and non-pending reviewed-tip and base commits. Only after confirmation,
+  tix creates the first unused `refs/worktree/tix/review/N` ref at the reviewed
+  tip and an unsigned ordinary `review` commit at the base with
+  `tix-rebase: onto refs/worktree/tix/review/N`. HEAD is detached at that commit,
+  its base tree fills the index, and the reviewed tip tree remains in the worktree
+  as unstaged changes.
+- Review refs are always traversal tips and remain visible in every ref mode. One
+  active ref is shown as `review`; multiple refs are shown as `review:N`. Review
+  commits replace the signature disc with a star while retaining independent
+  signature state. Ordinary edits preserve the review header and otherwise keep
+  their normal signing and lazy-rebase behavior.
+- At a checked-out review commit, amend is offered only for staged changes and
+  consumes only the index tree. It leaves worktree bytes and the review header
+  intact, removes signatures, and marks only affected descendants for lazy replay.
+- `e v` finishes a checked-out review only when status is completely clean. The
+  review commit is inserted after its reviewed tip with its exact tree, review
+  header removed, updated committer, and configured signature. Review-side
+  descendants retain exact trees and are signed without pending markers. With one
+  review-side leaf, the reviewed tip's prior descendants are lazily reparented
+  after it; with multiple leaves they branch directly after the finished review.
+  The review ref is deleted in the same atomic ref/worktree transaction.
+- Forget is unavailable for a review commit with descendants. Forgetting a review
+  leaf, or dropping a review commit through a rebase todo, also deletes its review
+  ref atomically; reordering or rewriting it preserves the header and resource.
+
 ### Forget commits
 
 - `e`, then `d`, is available after history completion for a selected non-merge
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index e6279aa5a63..ed7a0b5c3d1 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -21,6 +21,7 @@ pub(crate) struct Commit<T> {
     pub title: T,
     pub metadata_loaded: bool,
     pub has_agent_marker: bool,
+    pub is_review: bool,
     pub signature: SignatureState,
 }
 
@@ -31,6 +32,7 @@ pub(crate) struct Metadata<T> {
     pub attributions: Range<usize>,
     pub title: T,
     pub has_agent_marker: bool,
+    pub is_review: bool,
     pub signature: SignatureState,
 }
 
@@ -303,6 +305,7 @@ pub(crate) enum Action {
     Forget,
     Rebase,
     RebaseUpdate,
+    Review,
     TimeTravel,
     VerifySignatures,
     Cancel,
@@ -339,6 +342,11 @@ pub(crate) enum Effect {
         commits: Vec<ObjectId>,
         head: Option<ObjectId>,
     },
+    StartReview {
+        tip: ObjectId,
+        base: ObjectId,
+    },
+    FinishReview(ObjectId),
     TimeTravel(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
@@ -408,6 +416,7 @@ pub(crate) struct App {
     pub(crate) show_selection_tail: bool,
     pub preview_author_copy: bool,
     reachability_anchor: Option<ObjectId>,
+    review_tip: Option<ObjectId>,
     junction_parent: Option<usize>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
@@ -431,6 +440,7 @@ pub(crate) struct App {
     pending_rebase_conflict: Option<ObjectId>,
     worktree_conflicted: bool,
     amend_available: bool,
+    finish_review_available: bool,
     spill_available: bool,
     split_available: bool,
     new_commit_available: bool,
@@ -495,6 +505,7 @@ impl App {
             show_selection_tail: true,
             preview_author_copy: false,
             reachability_anchor: None,
+            review_tip: None,
             junction_parent: None,
             reachable_rows: None,
             copy_feedback: None,
@@ -518,6 +529,7 @@ impl App {
             pending_rebase_conflict: None,
             worktree_conflicted: false,
             amend_available: false,
+            finish_review_available: false,
             spill_available: false,
             split_available: false,
             new_commit_available: true,
@@ -662,6 +674,7 @@ impl App {
                     title: start..self.titles.len(),
                     metadata_loaded: row.metadata_loaded,
                     has_agent_marker: row.has_agent_marker,
+                    is_review: row.is_review,
                     signature: row.signature,
                 };
                 let row = Arc::new(row);
@@ -702,6 +715,7 @@ impl App {
             attributions,
             title,
             has_agent_marker,
+            is_review,
             signature,
         } = metadata;
         let title_start = self.titles.len();
@@ -714,6 +728,7 @@ impl App {
         row.title = title_start..self.titles.len();
         row.metadata_loaded = true;
         row.has_agent_marker = has_agent_marker;
+        row.is_review = is_review;
         row.signature = signature;
         self.all_rows.insert(row.id, Arc::clone(&self.rows[index]));
     }
@@ -784,6 +799,7 @@ impl App {
                 | Action::Forget
                 | Action::Rebase
                 | Action::RebaseUpdate
+                | Action::Review
                 | Action::TimeTravel
         ) {
             self.edit_expanded = false;
@@ -944,6 +960,16 @@ impl App {
                 changes.error = None;
                 return vec![Effect::OpenDiff(pane, changes.selected)];
             }
+            Action::OpenDiff if self.review_tip.is_some() => {
+                let tip = self.review_tip.expect("review selection has a tip");
+                let Some(base) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) else {
+                    return Vec::new();
+                };
+                if base != tip && self.selected.is_some_and(|index| self.is_row_reachable(index)) {
+                    self.clear_review_selection();
+                    return vec![Effect::StartReview { tip, base }];
+                }
+            }
             Action::OpenDiff => {
                 if let Some(target) = self.selected_tree_diff_target() {
                     return vec![Effect::OpenCommitDiff(target)];
@@ -1012,6 +1038,19 @@ impl App {
                     head: self.worktree_head,
                 }];
             }
+            Action::Review if self.can_finish_review() => {
+                return vec![Effect::FinishReview(
+                    self.rows[self.selected.expect("finishing review requires a selection")].id,
+                )];
+            }
+            Action::Review if self.can_review() => {
+                let tip = self.rows[self.selected.expect("review requires a selection")].id;
+                self.review_tip = Some(tip);
+                self.reachability_anchor = Some(tip);
+                self.junction_parent = None;
+                self.compute_reachable_rows();
+                self.leave_message("review base · j/k select ancestor · <enter> start · Esc cancel");
+            }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
@@ -1038,8 +1077,9 @@ impl App {
                 }
             }
             Action::ForceQuit => return vec![Effect::Quit],
+            Action::Cancel if self.review_tip.is_some() => self.clear_review_selection(),
             Action::Cancel | Action::Quit if self.changes_focus.is_some() => self.focus_history(),
-            Action::PreviewAuthorCopy(_) if self.changes_focus.is_some() => {}
+            Action::PreviewAuthorCopy(_) if self.review_tip.is_some() || self.changes_focus.is_some() => {}
             Action::PreviewAuthorCopy(value) => {
                 if value && !self.preview_author_copy {
                     self.reachability_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
@@ -1273,6 +1313,7 @@ impl App {
                             attributions: row.attributions.clone(),
                             title: row.title.clone(),
                             has_agent_marker: row.has_agent_marker,
+                            is_review: row.is_review,
                             signature: row.signature,
                         },
                     )
@@ -1386,6 +1427,13 @@ impl App {
         self.reachable_rows = None;
     }
 
+    fn clear_review_selection(&mut self) {
+        self.review_tip = None;
+        self.reachability_anchor = None;
+        self.junction_parent = None;
+        self.reachable_rows = None;
+    }
+
     pub(crate) fn focus_history(&mut self) {
         self.changes_focus = None;
         self.focus_feedback = None;
@@ -1456,12 +1504,12 @@ impl App {
         let distance = distance.max(1);
         let next = if down {
             (selected + 1..self.rows.len())
-                .filter(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .filter(|index| self.reachable_row_selectable(*index) && reachable.get(*index) == Some(&true))
                 .nth(distance - 1)
         } else {
             (0..selected)
                 .rev()
-                .filter(|index| !self.is_row_hidden(*index) && reachable.get(*index) == Some(&true))
+                .filter(|index| self.reachable_row_selectable(*index) && reachable.get(*index) == Some(&true))
                 .nth(distance - 1)
         };
         if let Some(next) = next {
@@ -1470,7 +1518,7 @@ impl App {
     }
 
     fn cycle_junction_parent(&mut self, forward: bool) -> bool {
-        if self.state != State::Complete {
+        if self.state != State::Complete || self.review_tip.is_some() {
             return false;
         }
         let Some(parent_count) = self
@@ -1505,7 +1553,10 @@ impl App {
             return;
         };
         let parent_count = self.rows[anchor_index].parent_ids.len();
-        let start = if parent_count > 1 {
+        let start = if self.review_tip.is_some() {
+            self.junction_parent = None;
+            anchor
+        } else if parent_count > 1 {
             let parent = self.junction_parent.get_or_insert(1);
             if *parent >= parent_count {
                 *parent = 1;
@@ -1552,6 +1603,15 @@ impl App {
             .is_none_or(|reachable| reachable.get(index).copied().unwrap_or(false))
     }
 
+    fn reachable_row_selectable(&self, index: usize) -> bool {
+        !self.is_row_hidden(index)
+            || (self.review_tip.is_some()
+                && self
+                    .rows
+                    .get(index)
+                    .is_some_and(|row| self.hidden_rebase_bases.contains(&row.id)))
+    }
+
     fn select(&mut self, selected: usize) {
         self.pending_initial_selection = None;
         if !self.rows.is_empty() {
@@ -1646,6 +1706,7 @@ impl App {
                 !self.hidden_rows.contains(&row.id)
                     && row.parent_ids.len() <= 1
                     && !self.known_merge_descendants.contains(&row.id)
+                    && (!row.is_review || !self.has_known_descendant(row.id))
             })
     }
 
@@ -1667,6 +1728,36 @@ impl App {
                 .is_some_and(|row| self.hidden_branch_updates.contains_key(&row.id))
     }
 
+    pub(crate) fn can_review(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && !self.worktree_conflicted
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
+                !self.hidden_rows.contains(&row.id)
+                    && !row.parent_ids.is_empty()
+                    && !self.known_merge_descendants.contains(&row.id)
+                    && !row.is_review
+            })
+    }
+
+    pub(crate) fn can_finish_review(&self) -> bool {
+        self.state == State::Complete
+            && self.finish_review_available
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| row.is_review && Some(row.id) == self.worktree_head)
+    }
+
+    pub(crate) fn review_selection_active(&self) -> bool {
+        self.review_tip.is_some()
+    }
+
     fn can_edit_head(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -1690,8 +1781,9 @@ impl App {
         self.can_edit_head() && self.changes_focus.is_none() && self.split_available
     }
 
-    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, spill: bool, split: bool) {
+    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, finish_review: bool, spill: bool, split: bool) {
         self.amend_available = amend;
+        self.finish_review_available = finish_review;
         self.spill_available = spill;
         self.split_available = split;
     }
@@ -2189,6 +2281,7 @@ mod tests {
             title: format!("commit {n}").into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }
     }
@@ -2446,7 +2539,7 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_head_edit_availability(true, true, false);
+        app.set_head_edit_availability(true, false, true, false);
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
         assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
@@ -2454,7 +2547,7 @@ mod tests {
             app.update(Action::Split).is_empty(),
             "split needs both kinds of changes"
         );
-        app.set_head_edit_availability(true, true, true);
+        app.set_head_edit_availability(true, false, true, true);
         assert_eq!(app.update(Action::Split), vec![Effect::Split(id(2))]);
         app.changes_focus = Some(ChangePane::Tree);
         assert!(!app.can_amend(), "a tree path cannot be amended");
@@ -2649,6 +2742,7 @@ mod tests {
                 attributions: 0..0,
                 title: "loaded".into(),
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             },
             Vec::new(),
@@ -2773,6 +2867,48 @@ mod tests {
         assert_eq!(app.rows[app.selected.expect("normal navigation is restored")].id, id(2));
     }
 
+    #[test]
+    fn review_selects_only_a_strict_ancestor_before_starting() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(5));
+        app.hidden_rows.insert(id(1));
+        app.hidden_rebase_bases.insert(id(1));
+
+        assert!(app.can_review());
+        assert!(app.update(Action::Review).is_empty());
+        let tip_index = app.rows.iter().position(|row| row.id == id(5)).expect("tip is present");
+        let unrelated = app
+            .rows
+            .iter()
+            .position(|row| row.id == id(4))
+            .expect("unrelated row is present");
+        assert!(app.is_row_reachable(tip_index));
+        assert!(!app.is_row_reachable(unrelated));
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(3)));
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::StartReview {
+                tip: id(5),
+                base: id(1),
+            }]
+        );
+        assert!(
+            app.is_row_reachable(unrelated),
+            "confirming restores ordinary navigation"
+        );
+    }
+
     #[test]
     fn changes_focus_clears_and_ignores_shift() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index b5cc4f77df8..ceacef84da2 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -11,17 +11,30 @@ pub(crate) fn perform(
     graph: &crate::history::HistoryGraph,
     id: ObjectId,
 ) -> Result<Option<ObjectId>> {
-    let commit = repo.find_commit(id).context("could not find the commit to forget")?;
-    drop(commit);
-    Ok(rebase::perform(
-        &repo,
-        graph,
-        rebase::Edit::Remove { target: id },
-        rebase::Signature::RedoIfNeeded,
-        rebase::Tree::LeaveAsIsAndMark,
-    )?
-    .complete()?
-    .selected)
+    let commit = repo
+        .find_commit(id)
+        .context("could not find the commit to forget")?
+        .decode()?
+        .into_owned()?;
+    let deletion = super::review::deletion(&repo, &commit)?;
+    let result = match deletion {
+        Some(deletion) => rebase::perform_deleting_ref(
+            &repo,
+            graph,
+            rebase::Edit::Remove { target: id },
+            rebase::Signature::RedoIfNeeded,
+            rebase::Tree::LeaveAsIsAndMark,
+            deletion,
+        ),
+        None => rebase::perform(
+            &repo,
+            graph,
+            rebase::Edit::Remove { target: id },
+            rebase::Signature::RedoIfNeeded,
+            rebase::Tree::LeaveAsIsAndMark,
+        ),
+    }?;
+    Ok(result.complete()?.selected)
 }
 
 pub(super) fn preflight_tree_transition(
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 2630258722e..480f322e03c 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -33,6 +33,7 @@ pub fn perform(
         .context("could not resolve commit signing configuration")?;
     repo = repo.with_object_memory();
     let old_tree = commit.tree;
+    let review = super::review::is_review(&commit);
     let parent_tree = match commit.parents.first().copied() {
         Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
         None => repo.empty_tree().id,
@@ -57,6 +58,8 @@ pub fn perform(
             drop(index);
             if index_tree != old_tree {
                 index_tree
+            } else if review {
+                return Ok(None);
             } else {
                 let baseline = repo.find_tree(old_tree)?;
                 create::worktree_tree(&repo, &baseline)?
@@ -71,8 +74,16 @@ pub fn perform(
         &repo,
         graph,
         rebase::Edit::Replace { target: head, commit },
-        rebase::Signature::InvalidateExisting,
-        rebase::Tree::LeaveAsIsAndMark,
+        if review {
+            rebase::Signature::Remove
+        } else {
+            rebase::Signature::InvalidateExisting
+        },
+        if review {
+            rebase::Tree::LeaveAsIsAndMarkDescendants
+        } else {
+            rebase::Tree::LeaveAsIsAndMark
+        },
     )?
     .complete()?
     .selected)
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 85d0e06fdb6..b7a45e40026 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -55,6 +55,7 @@ pub(crate) mod create;
 pub(crate) mod forget;
 pub(crate) mod head;
 pub(crate) mod rebase;
+pub(crate) mod review;
 pub(crate) mod reword;
 pub(crate) mod split;
 pub(crate) mod time_travel;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index e8aa0e79645..dde43a7b91a 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -25,6 +25,7 @@ const PENDING: &[u8] = b"pending";
 pub(crate) enum Signature {
     InvalidateExisting,
     RedoIfNeeded,
+    Remove,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -32,6 +33,7 @@ pub(crate) enum Tree {
     #[cfg_attr(not(test), allow(dead_code))]
     LeaveAsIs,
     LeaveAsIsAndMark,
+    LeaveAsIsAndMarkDescendants,
     CherryPick,
 }
 
@@ -182,6 +184,7 @@ struct Prepared {
     committer: gix::actor::Signature,
     expected_refs: Option<Vec<ExpectedRef>>,
     pins: Vec<ObjectId>,
+    delete_refs: Vec<(gix::refs::FullName, Target)>,
 }
 
 pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result<Vec<ExpectedRef>> {
@@ -225,11 +228,33 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result
 
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
 pub(crate) fn perform(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+) -> Result<Perform> {
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new())
+}
+
+pub(super) fn perform_deleting_ref(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    deletion: (gix::refs::FullName, Target),
+) -> Result<Perform> {
+    perform_inner(repo, graph, edit, signature, tree_mode, vec![deletion])
+}
+
+fn perform_inner(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     mut tree_mode: Tree,
+    delete_refs: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Perform> {
     let mut repo = repo.clone();
     let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
@@ -361,7 +386,9 @@ pub(crate) fn perform(
             }
         };
         commit.parents = new_parents.into_iter().collect();
-        let pending = tree_mode == Tree::LeaveAsIsAndMark || conflict.is_some();
+        let pending = tree_mode == Tree::LeaveAsIsAndMark
+            || (tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
+            || conflict.is_some();
         marker(
             &mut commit,
             pending,
@@ -395,12 +422,15 @@ pub(crate) fn perform(
         }
     }
 
-    let marked = (!forked && tree_mode == Tree::LeaveAsIsAndMark) || conflict.is_some();
+    let marked = (!forked && matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants))
+        || conflict.is_some();
     let mut prepared = Prepared {
         repo,
         root,
         reset_index: if inserted { reset_index } else { marked },
-        skip_worktree_transitions: inserted || forked || (tree_mode == Tree::LeaveAsIsAndMark && !removed),
+        skip_worktree_transitions: inserted
+            || forked
+            || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
         selected,
         rewritten,
         committer,
@@ -410,6 +440,7 @@ pub(crate) fn perform(
         } else {
             Vec::new()
         },
+        delete_refs,
     };
     match conflict {
         Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
@@ -423,6 +454,128 @@ pub(crate) fn perform(
     }
 }
 
+#[tracing::instrument(skip_all, fields(%review, %tip))]
+pub(super) fn finish_review(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    review: ObjectId,
+    tip: ObjectId,
+    review_ref: gix::refs::FullName,
+    review_target: Target,
+) -> Result<Outcome> {
+    let mut repo = repo.clone();
+    let signing = repo
+        .commit_signing_options_if_enabled()
+        .context("could not resolve commit signing configuration")?;
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()?;
+    repo = repo.with_object_memory();
+
+    let review_ids = graph
+        .descendants_in_parent_order(review)
+        .context("the review commit is not in the loaded history")?;
+    let review_set: HashSet<_> = review_ids.iter().copied().collect();
+    let natural_ids: Vec<_> = graph
+        .descendants_in_parent_order(tip)
+        .context("the reviewed commit is not in the loaded history")?
+        .into_iter()
+        .filter(|id| *id != tip && !review_set.contains(id))
+        .collect();
+    for id in review_ids.iter().chain(&natural_ids) {
+        if graph
+            .parents_of(*id)
+            .context("a review descendant is incomplete")?
+            .len()
+            > 1
+        {
+            anyhow::bail!("review finish cannot rewrite merge descendants");
+        }
+    }
+
+    let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut finished_review = None;
+    for old in &review_ids {
+        let old_parents = graph.parents_of(*old).context("a review descendant is incomplete")?;
+        let mut commit = repo.find_commit(*old)?.decode()?.into_owned()?;
+        let new_parents = if *old == review {
+            vec![tip]
+        } else {
+            old_parents
+                .iter()
+                .filter_map(|parent| rewritten.get(parent).copied().unwrap_or(Some(*parent)))
+                .collect()
+        };
+        commit.parents = new_parents.into_iter().collect();
+        commit.committer = committer.clone();
+        if *old == review {
+            commit.extra_headers.retain(|(name, value)| {
+                !(name.as_slice() == MARKER
+                    && value.as_slice().strip_prefix(b"onto ") == Some(review_ref.as_bstr().as_ref()))
+            });
+        }
+        marker(&mut commit, false, None);
+        let new = write_commit(&repo, commit, Signature::RedoIfNeeded, signing.clone())?;
+        rewritten.insert(*old, Some(new));
+        if *old == review {
+            finished_review = Some(new);
+        }
+    }
+    let finished_review = finished_review.context("the review commit was not rewritten")?;
+    let non_leaves: HashSet<_> = review_ids
+        .iter()
+        .flat_map(|id| graph.parents_of(*id).unwrap_or_default())
+        .filter(|parent| review_set.contains(parent))
+        .collect();
+    let leaves: Vec<_> = review_ids
+        .iter()
+        .filter(|id| !non_leaves.contains(*id))
+        .copied()
+        .collect();
+    let insertion = if leaves.len() == 1 {
+        rewritten[&leaves[0]].context("the review leaf disappeared")?
+    } else {
+        finished_review
+    };
+
+    rewritten.insert(tip, Some(finished_review));
+    for old in natural_ids {
+        let old_parents = graph.parents_of(old).context("a reviewed descendant is incomplete")?;
+        let mut commit = repo.find_commit(old)?.decode()?.into_owned()?;
+        let new_parents: Vec<_> = old_parents
+            .iter()
+            .filter_map(|parent| {
+                if *parent == tip {
+                    Some(insertion)
+                } else {
+                    rewritten.get(parent).copied().unwrap_or(Some(*parent))
+                }
+            })
+            .collect();
+        commit.parents = new_parents.into_iter().collect();
+        commit.committer = committer.clone();
+        marker(&mut commit, true, old_parents.first().copied());
+        let new = write_commit(&repo, commit, Signature::InvalidateExisting, signing.clone())?;
+        rewritten.insert(old, Some(new));
+    }
+
+    let mut prepared = Prepared {
+        repo,
+        root: Some(review),
+        reset_index: false,
+        skip_worktree_transitions: false,
+        selected: Some(finished_review),
+        rewritten,
+        committer,
+        expected_refs: None,
+        pins: Vec::new(),
+        delete_refs: vec![(review_ref, review_target)],
+    };
+    prepared.finish()
+}
+
 #[tracing::instrument(skip_all, fields(base = %plan.base, steps = plan.steps.len()))]
 pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: Plan) -> Result<Perform> {
     let mut repo = repo.clone();
@@ -540,7 +693,15 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         }
     }
 
-    for dropped in plan.scope.iter().copied().filter(|id| !picked.contains(id)) {
+    let dropped: Vec<_> = plan.scope.iter().copied().filter(|id| !picked.contains(id)).collect();
+    let mut delete_refs = Vec::new();
+    for id in &dropped {
+        let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
+        if let Some(deletion) = super::review::deletion(&repo, &commit)? {
+            delete_refs.push(deletion);
+        }
+    }
+    for dropped in dropped {
         let mut ancestor = graph
             .parents_of(dropped)
             .context("a dropped commit is incomplete")?
@@ -596,6 +757,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         committer,
         expected_refs: Some(plan.expected_refs),
         pins,
+        delete_refs,
     };
     match conflict {
         Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
@@ -642,7 +804,7 @@ impl Prepared {
             self.selected,
             &self.committer,
             self.expected_refs.take(),
-            &self.pins,
+            (&self.pins, &self.delete_refs),
         )?;
         for (transitioned, transition) in transitions.iter().enumerate() {
             if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
@@ -881,9 +1043,9 @@ fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<Objec
 }
 
 fn marker(commit: &mut gix::objs::Commit, add: bool, original_parent: Option<ObjectId>) {
-    commit
-        .extra_headers
-        .retain(|(name, _)| name.as_slice() != MARKER && name.as_slice() != ORIGINAL_PARENT);
+    commit.extra_headers.retain(|(name, value)| {
+        !(name.as_slice() == MARKER && value.as_slice() == PENDING) && name.as_slice() != ORIGINAL_PARENT
+    });
     if add {
         commit.extra_headers.push((MARKER.into(), PENDING.into()));
         if let Some(parent) = original_parent {
@@ -925,6 +1087,7 @@ fn write_commit(
             commit.extra_headers.push((field.into(), BString::default()));
             commit
         }
+        (Signature::Remove, _) => commit,
         _ => commit,
     };
     Ok(repo
@@ -1012,12 +1175,16 @@ fn update_refs(
     inserted: Option<ObjectId>,
     committer: &gix::actor::Signature,
     expected_refs: Option<Vec<ExpectedRef>>,
-    pins: &[ObjectId],
+    resources: (&[ObjectId], &[(gix::refs::FullName, Target)]),
 ) -> Result<Vec<RefEdit>> {
+    let (pins, delete_refs) = resources;
     let mut edits = Vec::new();
     let mut rollback = Vec::new();
     if let Some(expected_refs) = expected_refs {
         for ExpectedRef { name, old } in expected_refs {
+            if delete_refs.iter().any(|(delete, _)| delete == &name) {
+                continue;
+            }
             let Some(new) = rewritten.get(&old) else { continue };
             edits.push(ref_edit(name.clone(), old, *new));
             rollback.push(reverse_ref_edit(name, old, *new));
@@ -1040,6 +1207,9 @@ fn update_refs(
             };
             let Some(new) = rewritten.get(&old) else { continue };
             let name = reference.name().to_owned();
+            if delete_refs.iter().any(|(delete, _)| delete == &name) {
+                continue;
+            }
             edits.push(ref_edit(name.clone(), old, *new));
             rollback.push(reverse_ref_edit(name, old, *new));
         }
@@ -1099,6 +1269,25 @@ fn update_refs(
             },
         });
     }
+    for (name, target) in delete_refs {
+        edits.push(RefEdit {
+            name: name.clone(),
+            deref: false,
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(target.clone()),
+                log: RefLog::AndReference,
+            },
+        });
+        rollback.push(RefEdit {
+            name: name.clone(),
+            deref: false,
+            change: Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustNotExist,
+                new: target.clone(),
+            },
+        });
+    }
     if edits.is_empty() {
         anyhow::bail!("no mutable reference points to an affected commit");
     }
@@ -1652,4 +1841,55 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn dropping_a_review_commit_removes_its_review_reference() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let old_middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+        let mut middle = repo.find_commit(old_middle)?.decode()?.into_owned()?;
+        middle
+            .extra_headers
+            .push(("tix-rebase".into(), "onto refs/worktree/tix/review/1".into()));
+        let middle = repo.write_object(&middle)?.detach();
+        let mut tip = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        tip.parents = [middle].into_iter().collect();
+        let tip = repo.write_object(&tip)?.detach();
+        repo.reference(
+            "refs/worktree/tix/review/1",
+            old_middle,
+            PreviousValue::MustNotExist,
+            "test review resource",
+        )?;
+        repo.reference(
+            "refs/heads/main",
+            tip,
+            PreviousValue::ExistingMustMatch(Target::Object(old_tip)),
+            "prepare review history",
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                }],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip])?,
+            },
+        )?
+        .complete()?;
+        assert!(
+            repo.try_find_reference("refs/worktree/tix/review/1")?.is_none(),
+            "dropping the review commit removes its associated resource"
+        );
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
new file mode 100644
index 00000000000..99b21223fc0
--- /dev/null
+++ b/gix-tix/src/edit/review.rs
@@ -0,0 +1,398 @@
+use std::{path::Path, process::Command};
+
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::{BString, ByteSlice},
+};
+
+use crate::{history, open_repository};
+
+const HEADER: &[u8] = b"tix-rebase";
+const ONTO: &[u8] = b"onto ";
+
+#[derive(Debug)]
+pub(crate) struct Started {
+    pub commit: ObjectId,
+    pub reference: gix::refs::FullName,
+}
+
+pub(crate) fn reference(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
+    commit
+        .extra_headers
+        .iter()
+        .find_map(|(name, value)| {
+            (name.as_slice() == HEADER)
+                .then(|| value.as_slice().strip_prefix(ONTO))
+                .flatten()
+        })
+        .map(|name| {
+            if !name.starts_with(history::REVIEW_PREFIX) {
+                anyhow::bail!("review commit names an invalid review reference");
+            }
+            BString::from(name)
+                .try_into()
+                .context("review commit names an invalid reference")
+        })
+        .transpose()
+}
+
+pub(crate) fn is_review(commit: &gix::objs::Commit) -> bool {
+    reference(commit).ok().flatten().is_some()
+}
+
+pub(super) fn deletion(
+    repo: &gix::Repository,
+    commit: &gix::objs::Commit,
+) -> Result<Option<(gix::refs::FullName, gix::refs::Target)>> {
+    let Some(name) = reference(commit)? else {
+        return Ok(None);
+    };
+    let Some(reference) = repo.try_find_reference(name.as_ref())? else {
+        return Ok(None);
+    };
+    let target = reference.target().into_owned();
+    Ok(Some((name, target)))
+}
+
+#[tracing::instrument(skip_all, fields(%tip, %base))]
+pub(crate) fn start(
+    repository_path: &Path,
+    bare: bool,
+    graph: &history::HistoryGraph,
+    tip: ObjectId,
+    base: ObjectId,
+) -> Result<Started> {
+    let repo = open_repository(repository_path, bare, false).context("could not open repository to start review")?;
+    let workdir = repo.workdir().context("review requires a worktree")?.to_owned();
+    let head = repo.head().context("could not read HEAD before review")?;
+    let restore = (
+        head.referent_name().map(|name| name.as_bstr().to_owned()),
+        head.id().map(gix::Id::detach),
+    );
+    if tip == base || !graph.is_ancestor(base, tip) {
+        anyhow::bail!("the review base must be an ancestor of the reviewed commit");
+    }
+    for (label, id) in [("reviewed commit", tip), ("review base", base)] {
+        let commit = repo
+            .find_commit(id)
+            .with_context(|| format!("could not find {label}"))?
+            .decode()?
+            .into_owned()?;
+        if super::rebase::has_marker(&commit) {
+            anyhow::bail!("{label} has a pending rebase");
+        }
+    }
+    ensure_clean(&workdir)?;
+
+    let name = next_reference(&repo)?;
+    let mut commit = gix::objs::Commit {
+        tree: repo.find_commit(base)?.tree_id()?.detach(),
+        parents: [base].into_iter().collect(),
+        author: repo
+            .author()
+            .context("no Git author is configured")?
+            .context("could not resolve the Git author")?
+            .to_owned()?,
+        committer: repo
+            .committer()
+            .context("no Git committer is configured")?
+            .context("could not resolve the Git committer")?
+            .to_owned()?,
+        encoding: None,
+        message: "review".into(),
+        extra_headers: Vec::new(),
+    };
+    commit
+        .extra_headers
+        .push((HEADER.into(), format!("onto {name}").into()));
+    let id = repo
+        .write_object(&commit)
+        .context("could not write review commit")?
+        .detach();
+    drop(repo);
+
+    git(&workdir, ["checkout", "--quiet", "--detach", &tip.to_string()])
+        .context("could not check out the reviewed commit")?;
+    if let Err(err) = git(
+        &workdir,
+        ["update-ref", name.as_bstr().to_str_lossy().as_ref(), &tip.to_string()],
+    ) {
+        restore_checkout(&workdir, &restore)?;
+        return Err(err.context("could not create review reference"));
+    }
+    if let Err(err) = git(
+        &workdir,
+        ["update-ref", "--no-deref", "HEAD", &id.to_string(), &tip.to_string()],
+    ) {
+        let _ = git(&workdir, ["update-ref", "-d", name.as_bstr().to_str_lossy().as_ref()]);
+        restore_checkout(&workdir, &restore)?;
+        return Err(err.context("could not attach the worktree to the review commit"));
+    }
+    if let Err(err) = git(&workdir, ["read-tree", &id.to_string()]) {
+        let _ = git(
+            &workdir,
+            ["update-ref", "--no-deref", "HEAD", &tip.to_string(), &id.to_string()],
+        );
+        let _ = git(&workdir, ["update-ref", "-d", name.as_bstr().to_str_lossy().as_ref()]);
+        restore_checkout(&workdir, &restore)?;
+        return Err(err.context("could not reset the index to the review base"));
+    }
+    Ok(Started {
+        commit: id,
+        reference: name,
+    })
+}
+
+#[tracing::instrument(skip_all, fields(%review))]
+pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, review: ObjectId) -> Result<ObjectId> {
+    let workdir = repo.workdir().context("finishing review requires a worktree")?;
+    if repo.head_id()?.detach() != review {
+        anyhow::bail!("the review commit must be checked out before it can be finished");
+    }
+    ensure_clean(workdir)?;
+    let commit = repo.find_commit(review)?.decode()?.into_owned()?;
+    let review_ref = reference(&commit)?.context("the selected commit is not an active review")?;
+    let base = commit
+        .parents
+        .first()
+        .copied()
+        .context("a review commit must have a base")?;
+    let mut reference = repo
+        .find_reference(review_ref.as_ref())
+        .context("the review reference is missing")?;
+    let target = reference.target().into_owned();
+    let tip = reference
+        .peel_to_id()
+        .context("the review reference does not resolve")?
+        .detach();
+    for (label, id) in [("reviewed commit", tip), ("review base", base)] {
+        let endpoint = repo.find_commit(id)?.decode()?.into_owned()?;
+        if super::rebase::has_marker(&endpoint) {
+            anyhow::bail!("{label} has a pending rebase");
+        }
+    }
+    super::rebase::finish_review(&repo, graph, review, tip, review_ref, target)?
+        .selected
+        .context("finishing review did not produce a commit")
+}
+
+pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["status", "--porcelain=v1", "--untracked-files=all"])
+        .output()
+        .context("could not inspect worktree status")?;
+    if !output.status.success() {
+        anyhow::bail!("{}", String::from_utf8_lossy(&output.stderr).trim());
+    }
+    if !output.stdout.is_empty() {
+        anyhow::bail!("review requires a clean index and worktree");
+    }
+    Ok(())
+}
+
+fn next_reference(repo: &gix::Repository) -> Result<gix::refs::FullName> {
+    for number in 1_u64.. {
+        let name: gix::refs::FullName = format!("{}{number}", String::from_utf8_lossy(history::REVIEW_PREFIX))
+            .try_into()
+            .context("generated an invalid review reference")?;
+        if repo.try_find_reference(name.as_ref())?.is_none() {
+            return Ok(name);
+        }
+    }
+    unreachable!("u64 review numbers cannot be exhausted")
+}
+
+fn git<const N: usize>(workdir: &Path, args: [&str; N]) -> Result<()> {
+    let output = Command::new("git").arg("-C").arg(workdir).args(args).output()?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!("{}", String::from_utf8_lossy(&output.stderr).trim())
+    }
+}
+
+fn restore_checkout(workdir: &Path, restore: &(Option<BString>, Option<ObjectId>)) -> Result<()> {
+    let mut command = Command::new("git");
+    command.arg("-C").arg(workdir).args(["checkout", "--quiet", "--force"]);
+    match restore {
+        (Some(name), _) => {
+            let name = gix::path::from_bstr(name);
+            command.arg(name.as_ref());
+        }
+        (None, Some(id)) => {
+            command.args(["--detach", &id.to_string()]);
+        }
+        (None, None) => anyhow::bail!("cannot restore an unborn checkout after review setup failed"),
+    }
+    let output = command
+        .output()
+        .context("could not restore checkout after review setup failed")?;
+    if output.status.success() {
+        Ok(())
+    } else {
+        anyhow::bail!("{}", String::from_utf8_lossy(&output.stderr).trim())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn run(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn starts_review_with_base_index_and_tip_worktree() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        run(fixture.path(), &["init", "-q", "-b", "main"])?;
+        run(fixture.path(), &["config", "user.name", "reviewer"])?;
+        run(fixture.path(), &["config", "user.email", "reviewer@example.com"])?;
+        std::fs::write(fixture.path().join("file"), "base\n")?;
+        run(fixture.path(), &["add", "file"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "base"],
+        )?;
+        let base = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("file"), "tip\n")?;
+        run(fixture.path(), &["-c", "commit.gpgSign=false", "commit", "-qam", "tip"])?;
+        let tip = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("natural"), "natural\n")?;
+        run(fixture.path(), &["add", "natural"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "natural descendant"],
+        )?;
+
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "user.name=reviewer".to_owned(),
+                "user.email=reviewer@example.com".to_owned(),
+            ]),
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+        drop(repo);
+        let started = start(fixture.path(), false, &graph, tip, base)?;
+
+        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        assert_eq!(
+            repo.head_id()?.detach(),
+            started.commit,
+            "HEAD selects the review commit"
+        );
+        assert_eq!(
+            repo.find_commit(started.commit)?.tree_id()?,
+            repo.find_commit(base)?.tree_id()?
+        );
+        assert_eq!(
+            repo.find_reference(started.reference.as_ref())?.id().detach(),
+            tip,
+            "the review resource retains the reviewed tip"
+        );
+        let commit = repo.find_commit(started.commit)?.decode()?.into_owned()?;
+        assert_eq!(reference(&commit)?, Some(started.reference.clone()));
+        assert_eq!(
+            std::fs::read(fixture.path().join("file"))?,
+            b"tip\n",
+            "reviewed content stays in worktree"
+        );
+        assert_eq!(
+            run(fixture.path(), &["diff", "--name-only"])?,
+            b"file\n",
+            "the reviewed change is unstaged"
+        );
+        assert!(run(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty());
+
+        run(fixture.path(), &["add", "file"])?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "user.name=reviewer".to_owned(),
+                "user.email=reviewer@example.com".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let amended = super::super::head::perform(repo, &graph, super::super::head::Kind::Amend, None)?
+            .expect("staging the reviewed delta amends it into the review commit");
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "user.name=reviewer".to_owned(),
+                "user.email=reviewer@example.com".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?;
+        assert!(is_review(&repo.find_commit(amended)?.decode()?.into_owned()?));
+        assert!(run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty());
+        let child = run(
+            fixture.path(),
+            &[
+                "-c",
+                "commit.gpgSign=false",
+                "commit-tree",
+                &format!("{amended}^{{tree}}"),
+                "-p",
+                &amended.to_string(),
+                "-m",
+                "review child",
+            ],
+        )?;
+        let child = ObjectId::from_hex(child.trim())?;
+        run(
+            fixture.path(),
+            &["update-ref", "refs/heads/review-child", &child.to_string()],
+        )?;
+        drop(repo);
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "user.name=reviewer".to_owned(),
+                "user.email=reviewer@example.com".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let finished = finish(repo, &graph, amended)?;
+        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        assert_eq!(repo.head_id()?.detach(), finished);
+        assert_eq!(
+            repo.find_commit(finished)?.parent_ids().next().map(gix::Id::detach),
+            Some(tip)
+        );
+        assert!(!is_review(&repo.find_commit(finished)?.decode()?.into_owned()?));
+        let child = repo.find_reference("refs/heads/review-child")?.id().detach();
+        assert_eq!(
+            repo.find_commit(child)?.parent_ids().next().map(gix::Id::detach),
+            Some(finished)
+        );
+        let natural = repo.find_reference("refs/heads/main")?.id().detach();
+        assert_eq!(
+            repo.find_commit(natural)?.parent_ids().next().map(gix::Id::detach),
+            Some(child),
+            "the natural descendants follow the review side's single leaf"
+        );
+        assert!(super::super::rebase::has_marker(
+            &repo.find_commit(natural)?.decode()?.into_owned()?
+        ));
+        assert!(
+            repo.try_find_reference(started.reference.as_ref())?.is_none(),
+            "finishing removes the review resource"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index f6d9b22b54c..599e41d403f 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -30,6 +30,7 @@ pub(crate) struct Decoration {
 pub(crate) enum DecorationKind {
     Head,
     Pin,
+    Review,
     WorktreeBranch,
     WorktreeDetached,
     Local,
@@ -42,6 +43,7 @@ pub(crate) enum DecorationKind {
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
 pub(crate) const PIN_PREFIX: &[u8] = b"refs/worktree/tix/pins/";
+pub(crate) const REVIEW_PREFIX: &[u8] = b"refs/worktree/tix/review/";
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct Pin {
@@ -655,6 +657,7 @@ impl HistoryGraph {
                     attributions: row_attributions,
                     title,
                     has_agent_marker,
+                    is_review,
                     signature,
                 } = metadata.unwrap_or_else(|| Metadata {
                     committer_time: Default::default(),
@@ -662,6 +665,7 @@ impl HistoryGraph {
                     attributions: 0..0,
                     title: BString::default(),
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 });
                 rows.push(Commit {
@@ -673,6 +677,7 @@ impl HistoryGraph {
                     title,
                     metadata_loaded,
                     has_agent_marker,
+                    is_review,
                     signature,
                 });
                 self.commits[index.as_usize()].state |= NODE_STORED;
@@ -1002,6 +1007,7 @@ pub(crate) fn load(
                 attributions: row_attributions,
                 title,
                 has_agent_marker,
+                is_review,
                 signature,
             } = metadata.unwrap_or_else(|| Metadata {
                 committer_time: Default::default(),
@@ -1009,6 +1015,7 @@ pub(crate) fn load(
                 attributions: 0..0,
                 title: BString::default(),
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             });
             if !hidden_revisions.is_empty() {
@@ -1023,6 +1030,7 @@ pub(crate) fn load(
                 title,
                 metadata_loaded,
                 has_agent_marker,
+                is_review,
                 signature,
             });
             graph.commits[index.as_usize()].state |= NODE_STORED;
@@ -1084,6 +1092,7 @@ pub(crate) fn load(
                 attributions: row_attributions,
                 title,
                 has_agent_marker,
+                is_review,
                 signature,
             } = decode_metadata(object.iter(), &mut authors, &mut attributions)?;
             rows.push(Commit {
@@ -1095,6 +1104,7 @@ pub(crate) fn load(
                 title,
                 metadata_loaded: true,
                 has_agent_marker,
+                is_review,
                 signature,
             });
             let index = graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, id, &mut buf)?;
@@ -1133,13 +1143,18 @@ pub(crate) fn snapshot_ignoring_pin(
         .into_iter()
         .filter(|pin| ignored_pin != Some(pin.name.as_bstr()))
         .collect::<Vec<_>>();
+    let reviews = all_reviews(repo)?;
     let worktrees = worktree_checkouts(repo);
     let mut view = referenced_refs(repo, revisions)?;
     for pin in &pins {
         insert_ref_chain(repo, pin.name.as_bstr(), &mut view)?;
     }
+    for review in &reviews {
+        insert_ref_chain(repo, review.name.as_bstr(), &mut view)?;
+    }
     let mut view_tips = resolve_tips(repo, revisions)?.unwrap_or_default();
     view_tips.extend(pins.iter().map(|pin| pin.id));
+    view_tips.extend(reviews.iter().map(|review| review.id));
     if include_worktrees {
         view_tips.extend(worktrees.iter().map(|worktree| worktree.id));
     }
@@ -1244,20 +1259,33 @@ fn worktree_basename(path: &std::path::Path) -> Option<BString> {
 }
 
 pub(crate) fn all_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
+    refs_with_commit_targets(repo, PIN_PREFIX, "pin")
+}
+
+pub(crate) fn all_reviews(repo: &gix::Repository) -> Result<Vec<Pin>> {
+    refs_with_commit_targets(repo, REVIEW_PREFIX, "review")
+}
+
+fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str) -> Result<Vec<Pin>> {
     let mut out = Vec::new();
     let references = repo.references().context("could not open references")?;
     for reference in references
-        .prefixed(PIN_PREFIX.as_bstr())
-        .context("could not iterate tix pins")?
+        .prefixed(prefix.as_bstr())
+        .with_context(|| format!("could not iterate tix {label}s"))?
     {
         let mut reference = match reference {
             Ok(reference) => reference,
             Err(err) if is_missing_ref(&*err) => continue,
-            Err(err) => return Err(anyhow::anyhow!("could not read tix pin: {err}")),
+            Err(err) => return Err(anyhow::anyhow!("could not read tix {label}: {err}")),
+        };
+        let suffix = reference.name().as_bstr().strip_prefix(prefix).unwrap_or_default();
+        let valid_suffix = if prefix == REVIEW_PREFIX {
+            suffix.first().is_some_and(|digit| matches!(digit, b'1'..=b'9')) && suffix.iter().all(u8::is_ascii_digit)
+        } else {
+            suffix.len() >= 4 && suffix.iter().all(u8::is_ascii_alphanumeric)
         };
-        let suffix = reference.name().as_bstr().strip_prefix(PIN_PREFIX).unwrap_or_default();
-        if suffix.len() < 4 || !suffix.iter().all(u8::is_ascii_alphanumeric) {
-            tracing::warn!(name = %reference.name(), "ignoring malformed tix pin");
+        if !valid_suffix {
+            tracing::warn!(name = %reference.name(), %label, "ignoring malformed tix reference");
             continue;
         }
         let name = reference.name().to_owned();
@@ -1265,18 +1293,18 @@ pub(crate) fn all_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
         let id = match reference.peel_to_id() {
             Ok(id) => id.detach(),
             Err(err) => {
-                tracing::warn!(name = %name, error = %err, "ignoring unresolved tix pin");
+                tracing::warn!(name = %name, error = %err, %label, "ignoring unresolved tix reference");
                 continue;
             }
         };
         match repo.find_header(id) {
             Ok(header) if header.kind() == gix::object::Kind::Commit => {}
             Ok(_) => {
-                tracing::warn!(name = %name, "ignoring tix pin that does not resolve to a commit");
+                tracing::warn!(name = %name, %label, "ignoring tix reference that does not resolve to a commit");
                 continue;
             }
             Err(err) => {
-                tracing::warn!(name = %name, error = %err, "ignoring unreadable tix pin target");
+                tracing::warn!(name = %name, error = %err, %label, "ignoring unreadable tix reference target");
                 continue;
             }
         }
@@ -1362,6 +1390,7 @@ fn decode_metadata<'a>(
     let attribution_start = attributions.len();
     let mut title = None;
     let mut has_agent_marker = false;
+    let mut is_review = false;
     let mut signature = SignatureState::Unsigned;
     for token in tokens {
         match token.context("could not decode commit")? {
@@ -1402,6 +1431,11 @@ fn decode_metadata<'a>(
             Token::ExtraHeader((name, value)) if name == "tix-rebase" && value.as_ref() == b"pending" => {
                 signature = SignatureState::PendingRebase;
             }
+            Token::ExtraHeader((name, value))
+                if name == "tix-rebase" && value.as_ref().starts_with(b"onto refs/worktree/tix/review/") =>
+            {
+                is_review = true;
+            }
             Token::ExtraHeader((name, _))
                 if (name == "gpgsig" || name == "gpgsig-sha256") && signature != SignatureState::PendingRebase =>
             {
@@ -1416,6 +1450,7 @@ fn decode_metadata<'a>(
         attributions: attribution_start..attributions.len(),
         title: title.context("commit has no message")?,
         has_agent_marker,
+        is_review,
         signature,
     })
 }
@@ -1526,6 +1561,7 @@ impl Authors {
 pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[WorktreeCheckout]) -> Result<Decorations> {
     let mut out = Decorations::new();
     let pins: HashSet<_> = pins.iter().map(|pin| pin.name.as_bstr()).collect();
+    let review_count = all_reviews(repo)?.len();
     for reference in repo
         .references()
         .context("could not open references")?
@@ -1539,6 +1575,7 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         };
         let full_name = reference.name().to_owned();
         let pin_suffix = full_name.as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
+        let review_suffix = full_name.as_bstr().strip_prefix(REVIEW_PREFIX).map(BString::from);
         if pin_suffix.is_some() && !pins.contains(full_name.as_bstr()) {
             continue;
         }
@@ -1562,7 +1599,18 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             kind = DecorationKind::WorktreeBranch;
         }
         let mut name = pin_suffix.map_or_else(
-            || full_name.shorten().to_owned(),
+            || {
+                review_suffix.as_ref().map_or_else(
+                    || full_name.shorten().to_owned(),
+                    |suffix| {
+                        if review_count == 1 {
+                            "review".into()
+                        } else {
+                            format!("review:{}", suffix.to_str_lossy()).into()
+                        }
+                    },
+                )
+            },
             |suffix| format!("pin:{}", suffix.to_str_lossy()).into(),
         );
         if matches!(kind, DecorationKind::Tag | DecorationKind::AnnotatedTag) {
@@ -1617,6 +1665,8 @@ fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
 fn decoration_kind(name: &[u8]) -> DecorationKind {
     if name.starts_with(PIN_PREFIX) {
         DecorationKind::Pin
+    } else if name.starts_with(REVIEW_PREFIX) {
+        DecorationKind::Review
     } else if name.starts_with(b"refs/heads/") {
         DecorationKind::Local
     } else if name.starts_with(b"refs/tags/") {
@@ -2311,6 +2361,7 @@ mod tests {
     #[test]
     fn classifies_reference_kinds() {
         assert_eq!(decoration_kind(b"refs/worktree/tix/pins/abcd"), DecorationKind::Pin);
+        assert_eq!(decoration_kind(b"refs/worktree/tix/review/1"), DecorationKind::Review);
         assert_eq!(decoration_kind(b"refs/heads/main"), DecorationKind::Local);
         assert_eq!(decoration_kind(b"refs/tags/v1"), DecorationKind::Tag);
         assert_eq!(decoration_kind(b"refs/remotes/origin/main"), DecorationKind::Remote);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index f67627869f5..172272fc478 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2091,6 +2091,49 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("rebase: {err:#}")),
                     }
                 }
+                Effect::StartReview { tip, base } => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = history_graph
+                        .as_ref()
+                        .context("review requires a completed history graph")
+                        .and_then(|graph| edit::review::start(&repository_path, repository_is_bare, graph, tip, base));
+                    match result {
+                        Ok(started) => {
+                            app.leave_message(format!(
+                                "started review {} at {}",
+                                started.reference.shorten(),
+                                started.commit.to_hex_with_len(7)
+                            ));
+                            app.select_commit_after_refresh(started.commit);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_message(format!("review: {err:#}")),
+                    }
+                }
+                Effect::FinishReview(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = history_graph
+                        .as_ref()
+                        .context("finishing review requires a completed history graph")
+                        .and_then(|graph| {
+                            let mut repo = open_repository(&repository_path, repository_is_bare, false)
+                                .context("could not open repository to finish review")?;
+                            repo.object_cache_size(None);
+                            edit::review::finish(repo, graph, id)
+                        });
+                    match result {
+                        Ok(new_id) => {
+                            app.leave_message(format!("finished review as {}", new_id.to_hex_with_len(7)));
+                            app.select_commit_after_refresh(new_id);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_message(format!("finish review: {err:#}")),
+                    }
+                }
                 Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -4009,6 +4052,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
+        KeyCode::Char('v') if edit_expanded => Some(Action::Review),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index e3f881eccc0..766838e1598 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -256,8 +256,20 @@ pub(crate) fn draw_with_worktree(
             .get(&row.id)
             .is_some_and(|refs| refs.iter().any(|r| r.kind == DecorationKind::Head))
     });
+    let selected_is_review = app
+        .selected
+        .and_then(|index| app.rows.get(index))
+        .is_some_and(|row| row.is_review);
     app.set_head_edit_availability(
-        selected_is_head && worktree_changes.is_some_and(|changes| !changes.paths.is_empty()),
+        selected_is_head
+            && worktree_changes.is_some_and(|changes| {
+                if selected_is_review {
+                    changes.paths.iter().any(|change| change.group == ChangeGroup::Staged)
+                } else {
+                    !changes.paths.is_empty()
+                }
+            }),
+        selected_is_head && selected_is_review && worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
         selected_is_head
             && worktree_changes.is_some_and(|changes| {
@@ -470,7 +482,7 @@ pub(crate) fn draw_with_worktree(
                 lane,
                 graph_offset,
                 highlight,
-                visible_rows[index].signature,
+                (visible_rows[index].signature, visible_rows[index].is_review),
                 head_state,
             );
             let aligned = Rect::new(
@@ -495,7 +507,7 @@ pub(crate) fn draw_with_worktree(
                 lane,
                 horizontal_offset,
                 highlight,
-                visible_rows[index].signature,
+                (visible_rows[index].signature, visible_rows[index].is_review),
                 head_state,
             );
         }
@@ -717,6 +729,12 @@ pub(crate) fn draw_with_worktree(
         State::Cancelled => " · cancelled",
     };
     let mut footer_spans = vec![Span::raw(status)];
+    if app.review_selection_active() {
+        footer_spans.push(Span::styled(
+            " · review base (<enter> start · Esc cancel)",
+            Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
+        ));
+    }
     let mut edit_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) {
         let time_travel = if app.time_travel_shortcut_visible()
@@ -755,6 +773,11 @@ pub(crate) fn draw_with_worktree(
             if app.can_rebase_update() {
                 options.push(("rebase-update", 'u'));
             }
+            if app.can_finish_review() {
+                options.push(("finish-review", 'v'));
+            } else if app.can_review() {
+                options.push(("review", 'v'));
+            }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'r'));
             }
@@ -1612,6 +1635,7 @@ fn metadata_line<'a>(
         .iter()
         .filter(|decoration| match ref_mode {
             _ if decoration.kind == DecorationKind::Head => false,
+            _ if decoration.kind == DecorationKind::Review => true,
             RefMode::All => true,
             RefMode::Default => decoration.kind != DecorationKind::Special,
             RefMode::None => {
@@ -1828,6 +1852,7 @@ fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
+        DecorationKind::Review => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => Style::default().fg(Color::LightBlue),
         DecorationKind::Local => Style::default().fg(Color::Cyan),
         DecorationKind::Remote => Style::default().fg(Color::Yellow),
@@ -1847,9 +1872,10 @@ fn color_graph(
     graph: &str,
     offset: usize,
     highlight: Option<Color>,
-    signature: SignatureState,
+    marker: (SignatureState, bool),
     head: Option<bool>,
 ) {
+    let (signature, review) = marker;
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
             continue;
@@ -1865,7 +1891,9 @@ fn color_graph(
             style = style.add_modifier(Modifier::BOLD);
         }
         let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
-        if head.is_some() && symbol == '●' {
+        if review && symbol == '●' {
+            cell.set_symbol("★");
+        } else if head.is_some() && symbol == '●' {
             cell.set_symbol("@");
         }
         cell.set_style(style);
@@ -1952,6 +1980,7 @@ mod tests {
                     title: "subject".into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -1984,6 +2013,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
@@ -2032,6 +2062,7 @@ mod tests {
             title: "a subject which is deliberately too long".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
@@ -2160,6 +2191,7 @@ mod tests {
             title: 0..0,
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         };
         let mailmap =
@@ -2272,6 +2304,7 @@ mod tests {
                 title: "subject".into(),
                 metadata_loaded: true,
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             }],
             attributions: vec![
@@ -2400,6 +2433,7 @@ mod tests {
             title: "unique comment".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         app.selected = None;
@@ -2430,6 +2464,7 @@ mod tests {
                 title: "subject".into(),
                 metadata_loaded: true,
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             }],
             attributions: vec![Attribution {
@@ -2468,6 +2503,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
@@ -2733,6 +2769,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
@@ -2817,6 +2854,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         app.set_worktree_head(Some(id), false);
@@ -2874,6 +2912,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         };
         let mut app = App::new(2);
@@ -2935,6 +2974,7 @@ mod tests {
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -3016,7 +3056,7 @@ mod tests {
                         "●─",
                         0,
                         Some(signature_color(*state)),
-                        *state,
+                        (*state, false),
                         head.then_some(false),
                     );
                 }
@@ -3035,6 +3075,26 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn review_commit_uses_a_star_instead_of_the_signature_disc() -> Result<(), Box<dyn std::error::Error>> {
+        let mut terminal = Terminal::new(TestBackend::new(2, 1))?;
+        terminal.draw(|frame| {
+            frame.render_widget(Paragraph::new("●─"), Rect::new(0, 0, 2, 1));
+            color_graph(
+                frame,
+                Rect::new(0, 0, 2, 1),
+                "●─",
+                0,
+                None,
+                (SignatureState::Unsigned, true),
+                Some(true),
+            );
+        })?;
+        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "★");
+        assert_eq!(terminal.backend().buffer()[(1, 0)].symbol(), "─");
+        Ok(())
+    }
+
     #[test]
     fn underlines_an_unselected_non_tip_head_and_bolds_its_marker() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);
@@ -3048,6 +3108,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         };
         let mut app = App::new(2);
@@ -3137,6 +3198,7 @@ mod tests {
                     title: "subject".into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -3276,6 +3338,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unverified,
         }]);
         complete(&mut app);
@@ -3321,6 +3384,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
@@ -3438,6 +3502,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         app.update(Action::ToggleCommit);
@@ -3518,6 +3583,7 @@ mod tests {
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -3601,6 +3667,7 @@ mod tests {
                 title: "merge".into(),
                 metadata_loaded: true,
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             },
             Commit {
@@ -3612,6 +3679,7 @@ mod tests {
                 title: "parent".into(),
                 metadata_loaded: true,
                 has_agent_marker: false,
+                is_review: false,
                 signature: SignatureState::Unsigned,
             },
         ]);
@@ -4333,6 +4401,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: true,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         app.set_notes(id, vec!["review note".into()]);
@@ -4395,6 +4464,7 @@ mod tests {
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -4461,6 +4531,7 @@ mod tests {
                     title: format!("subject {n}").into(),
                     metadata_loaded: true,
                     has_agent_marker: false,
+                    is_review: false,
                     signature: SignatureState::Unsigned,
                 })
                 .collect::<Vec<_>>(),
@@ -4492,6 +4563,7 @@ mod tests {
             title: format!("subject {n}").into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unverified,
         };
         let mut app = App::new(2);
@@ -4621,6 +4693,7 @@ mod tests {
             title: format!("subject {n}").into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         };
         let mut app = App::new(4);
@@ -4667,6 +4740,7 @@ mod tests {
             title: "subject".into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         };
         let decorations = Decorations::from([(
@@ -4773,6 +4847,7 @@ mod tests {
             title: format!("{} subject-tail", "a".repeat(50)).into(),
             metadata_loaded: true,
             has_agent_marker: false,
+            is_review: false,
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);

From 2331d9204558bc81992af0770f0d9739ba5bade7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 12:58:29 +0200
Subject: [PATCH 083/282] feat: preserve review changes across time travel

Treat each active review commit and its descendants as one review tree. Keep
ordinary checkout behavior while moving inside that tree, but use Git's stash
machinery when time travel crosses its boundary so staged, unstaged, and
untracked review work can safely follow the reviewer back to the review.

Store the stash under a review-specific companion ref without disturbing an
existing refs/stash entry. Restore the index with the worktree, consume the
companion ref after Git returns even when applying reports conflicts, and let
the existing conflict workflow present any unresolved index.

Keep saved review state internal to history traversal and decorations. Remove
it together with the review ref when a review finishes, is forgotten, or is
dropped by a rebase todo.

Document the review-tree boundary behavior and cover same-tree travel,
boundary crossings, nested reviews, pre-existing stashes, apply conflicts,
fatal apply results, history visibility, and resource cleanup.
---
 gix-tix/spec.md                 |  15 +-
 gix-tix/src/edit/create.rs      |   8 +-
 gix-tix/src/edit/forget.rs      |  15 +-
 gix-tix/src/edit/rebase.rs      |  26 +-
 gix-tix/src/edit/review.rs      |  70 +++--
 gix-tix/src/edit/time_travel.rs | 493 ++++++++++++++++++++++++++++++--
 gix-tix/src/history.rs          |  45 ++-
 gix-tix/src/lib.rs              |  11 +-
 8 files changed, 625 insertions(+), 58 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 4a0dc577f16..87d41ab30a7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -212,6 +212,15 @@ The Enter key is written as `<enter>` throughout.
   descendant, and sideways moves. Conflict acceptance, history-rebase checkout,
   and automatic fork travel use this same primitive. Successful travel preserves
   the selected row, refreshes history directly, and invalidates worktree status.
+- Active review commits define review trees containing all of their descendants.
+  Time travel within one review tree keeps ordinary checkout behavior and never
+  creates or restores a stash. Crossing out of a dirty review tree saves tracked,
+  staged, unstaged, and untracked state with Git under
+  `refs/worktree/tix/review/stashes/N`; ignored files remain untouched. Crossing
+  into any commit in that review tree restores the state with `git stash apply
+  --index` and always removes the companion ref after Git returns. Apply conflicts
+  remain in the ordinary index/worktree conflict workflow. Nested trees use the
+  nearest review-root ancestor.
 
 ### Held Shift ancestry mode
 
@@ -451,8 +460,10 @@ space first; changes blocks adapt within the remaining history width.
   after it; with multiple leaves they branch directly after the finished review.
   The review ref is deleted in the same atomic ref/worktree transaction.
 - Forget is unavailable for a review commit with descendants. Forgetting a review
-  leaf, or dropping a review commit through a rebase todo, also deletes its review
-  ref atomically; reordering or rewriting it preserves the header and resource.
+  leaf, finishing a review, or dropping a review commit through a rebase todo also
+  deletes its review ref and optional saved-worktree ref atomically; reordering or
+  rewriting it preserves the header and resources. Review stash refs are internal:
+  they are neither traversal tips nor decorations.
 
 ### Forget commits
 
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 1fa7334b1b8..3682cfdd239 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -492,7 +492,7 @@ mod tests {
         let repository_path = repository.git_dir().to_owned();
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
-        super::super::time_travel::perform(&repository_path, false, fork, &graph, &[], false)?.complete()?;
+        super::super::time_travel::perform(&repository_path, false, fork, &graph, &[], &[], false)?.complete()?;
         let repository = open(fixture.path())?;
         assert!(repository.head()?.is_detached(), "automatic fork travel detaches HEAD");
         assert_eq!(repository.head_id()?.detach(), fork);
@@ -530,16 +530,16 @@ mod tests {
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
         let first = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, first, &graph, &[], false)?.complete()?;
+        super::super::time_travel::perform(&repository_path, false, first, &graph, &[], &[], false)?.complete()?;
 
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, base, &graph, &[], false)?.complete()?;
+        super::super::time_travel::perform(&repository_path, false, base, &graph, &[], &[], false)?.complete()?;
         let prepared = prepare(open(fixture.path())?, Some(base))?;
         let edited = prepared.document.replacen(b"what\n\nwhy", b"second fork\n\nreason", 1);
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
         let second = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, second, &graph, &[], false)?.complete()?;
+        super::super::time_travel::perform(&repository_path, false, second, &graph, &[], &[], false)?.complete()?;
 
         let repository = open(fixture.path())?;
         let snapshot = crate::history::snapshot(&repository, &[], &[], false)?;
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index ceacef84da2..75e743a35f0 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -16,23 +16,24 @@ pub(crate) fn perform(
         .context("could not find the commit to forget")?
         .decode()?
         .into_owned()?;
-    let deletion = super::review::deletion(&repo, &commit)?;
-    let result = match deletion {
-        Some(deletion) => rebase::perform_deleting_ref(
+    let deletions = super::review::deletions(&repo, &commit)?;
+    let result = if deletions.is_empty() {
+        rebase::perform(
             &repo,
             graph,
             rebase::Edit::Remove { target: id },
             rebase::Signature::RedoIfNeeded,
             rebase::Tree::LeaveAsIsAndMark,
-            deletion,
-        ),
-        None => rebase::perform(
+        )
+    } else {
+        rebase::perform_deleting_refs(
             &repo,
             graph,
             rebase::Edit::Remove { target: id },
             rebase::Signature::RedoIfNeeded,
             rebase::Tree::LeaveAsIsAndMark,
-        ),
+            deletions,
+        )
     }?;
     Ok(result.complete()?.selected)
 }
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index dde43a7b91a..320c71ddf37 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -237,15 +237,15 @@ pub(crate) fn perform(
     perform_inner(repo, graph, edit, signature, tree_mode, Vec::new())
 }
 
-pub(super) fn perform_deleting_ref(
+pub(super) fn perform_deleting_refs(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
-    deletion: (gix::refs::FullName, Target),
+    deletions: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, vec![deletion])
+    perform_inner(repo, graph, edit, signature, tree_mode, deletions)
 }
 
 fn perform_inner(
@@ -461,7 +461,7 @@ pub(super) fn finish_review(
     review: ObjectId,
     tip: ObjectId,
     review_ref: gix::refs::FullName,
-    review_target: Target,
+    delete_refs: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Outcome> {
     let mut repo = repo.clone();
     let signing = repo
@@ -571,7 +571,7 @@ pub(super) fn finish_review(
         committer,
         expected_refs: None,
         pins: Vec::new(),
-        delete_refs: vec![(review_ref, review_target)],
+        delete_refs,
     };
     prepared.finish()
 }
@@ -697,9 +697,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
     let mut delete_refs = Vec::new();
     for id in &dropped {
         let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
-        if let Some(deletion) = super::review::deletion(&repo, &commit)? {
-            delete_refs.push(deletion);
-        }
+        delete_refs.extend(super::review::deletions(&repo, &commit)?);
     }
     for dropped in dropped {
         let mut ancestor = graph
@@ -1843,7 +1841,7 @@ mod tests {
     }
 
     #[test]
-    fn dropping_a_review_commit_removes_its_review_reference() -> gix_testtools::Result {
+    fn dropping_a_review_commit_removes_all_review_resources() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let base = repo.rev_parse_single("HEAD~2")?.detach();
@@ -1863,6 +1861,12 @@ mod tests {
             PreviousValue::MustNotExist,
             "test review resource",
         )?;
+        repo.reference(
+            "refs/worktree/tix/review/stashes/1",
+            old_tip,
+            PreviousValue::MustNotExist,
+            "test review stash resource",
+        )?;
         repo.reference(
             "refs/heads/main",
             tip,
@@ -1890,6 +1894,10 @@ mod tests {
             repo.try_find_reference("refs/worktree/tix/review/1")?.is_none(),
             "dropping the review commit removes its associated resource"
         );
+        assert!(
+            repo.try_find_reference("refs/worktree/tix/review/stashes/1")?.is_none(),
+            "dropping the review commit also removes its saved worktree state"
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 99b21223fc0..ff4c06d7585 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -3,7 +3,7 @@ use std::{path::Path, process::Command};
 use anyhow::{Context, Result};
 use gix::{
     ObjectId,
-    bstr::{BString, ByteSlice},
+    bstr::{BStr, BString, ByteSlice},
 };
 
 use crate::{history, open_repository};
@@ -27,7 +27,7 @@ pub(crate) fn reference(commit: &gix::objs::Commit) -> Result<Option<gix::refs::
                 .flatten()
         })
         .map(|name| {
-            if !name.starts_with(history::REVIEW_PREFIX) {
+            if history::review_number(name.as_bstr()).is_none() {
                 anyhow::bail!("review commit names an invalid review reference");
             }
             BString::from(name)
@@ -41,18 +41,39 @@ pub(crate) fn is_review(commit: &gix::objs::Commit) -> bool {
     reference(commit).ok().flatten().is_some()
 }
 
-pub(super) fn deletion(
+pub(super) fn deletions(
     repo: &gix::Repository,
     commit: &gix::objs::Commit,
-) -> Result<Option<(gix::refs::FullName, gix::refs::Target)>> {
+) -> Result<Vec<(gix::refs::FullName, gix::refs::Target)>> {
     let Some(name) = reference(commit)? else {
-        return Ok(None);
+        return Ok(Vec::new());
     };
-    let Some(reference) = repo.try_find_reference(name.as_ref())? else {
-        return Ok(None);
-    };
-    let target = reference.target().into_owned();
-    Ok(Some((name, target)))
+    resources(repo, name)
+}
+
+pub(super) fn resources(
+    repo: &gix::Repository,
+    name: gix::refs::FullName,
+) -> Result<Vec<(gix::refs::FullName, gix::refs::Target)>> {
+    let stash = stash_reference(name.as_bstr())?;
+    let mut out = Vec::new();
+    for name in [name, stash] {
+        if let Some(reference) = repo.try_find_reference(name.as_ref())? {
+            out.push((name, reference.target().into_owned()));
+        }
+    }
+    Ok(out)
+}
+
+pub(super) fn stash_reference(review: &BStr) -> Result<gix::refs::FullName> {
+    let number = history::review_number(review).context("review reference has no numeric identity")?;
+    format!(
+        "{}{}",
+        String::from_utf8_lossy(history::REVIEW_STASH_PREFIX),
+        number.to_str_lossy()
+    )
+    .try_into()
+    .context("generated an invalid review stash reference")
 }
 
 #[tracing::instrument(skip_all, fields(%tip, %base))]
@@ -161,23 +182,30 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
     let mut reference = repo
         .find_reference(review_ref.as_ref())
         .context("the review reference is missing")?;
-    let target = reference.target().into_owned();
     let tip = reference
         .peel_to_id()
         .context("the review reference does not resolve")?
         .detach();
+    let delete_refs = resources(&repo, review_ref.clone())?;
     for (label, id) in [("reviewed commit", tip), ("review base", base)] {
         let endpoint = repo.find_commit(id)?.decode()?.into_owned()?;
         if super::rebase::has_marker(&endpoint) {
             anyhow::bail!("{label} has a pending rebase");
         }
     }
-    super::rebase::finish_review(&repo, graph, review, tip, review_ref, target)?
+    super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs)?
         .selected
         .context("finishing review did not produce a commit")
 }
 
 pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
+    if is_dirty(workdir)? {
+        anyhow::bail!("review requires a clean index and worktree");
+    }
+    Ok(())
+}
+
+pub(super) fn is_dirty(workdir: &Path) -> Result<bool> {
     let output = Command::new("git")
         .arg("-C")
         .arg(workdir)
@@ -187,10 +215,7 @@ pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
     if !output.status.success() {
         anyhow::bail!("{}", String::from_utf8_lossy(&output.stderr).trim());
     }
-    if !output.stdout.is_empty() {
-        anyhow::bail!("review requires a clean index and worktree");
-    }
-    Ok(())
+    Ok(!output.stdout.is_empty())
 }
 
 fn next_reference(repo: &gix::Repository) -> Result<gix::refs::FullName> {
@@ -357,6 +382,15 @@ mod tests {
             fixture.path(),
             &["update-ref", "refs/heads/review-child", &child.to_string()],
         )?;
+        let stash_ref = stash_reference(started.reference.as_bstr())?;
+        run(
+            fixture.path(),
+            &[
+                "update-ref",
+                stash_ref.as_bstr().to_str_lossy().as_ref(),
+                &tip.to_string(),
+            ],
+        )?;
         drop(repo);
         let repo = gix::open_opts(
             fixture.path(),
@@ -393,6 +427,10 @@ mod tests {
             repo.try_find_reference(started.reference.as_ref())?.is_none(),
             "finishing removes the review resource"
         );
+        assert!(
+            repo.try_find_reference(stash_ref.as_ref())?.is_none(),
+            "finishing also removes saved review worktree state"
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 45cc3c3e65c..035f02d0784 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -1,5 +1,6 @@
 use std::{
     ffi::OsString,
+    fmt::Write as _,
     path::{Path, PathBuf},
     process::Command,
 };
@@ -174,6 +175,7 @@ pub(crate) fn perform(
     bare: bool,
     mut selected: ObjectId,
     graph: &history::HistoryGraph,
+    review_roots: &[ObjectId],
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Perform> {
@@ -195,6 +197,7 @@ pub(crate) fn perform(
         anyhow::bail!("cannot time-travel with unresolved index conflicts");
     }
     let mut completed_graph = None;
+    let mut review_roots = review_roots.to_vec();
     while let Some(base) = pending_base(&repository, head_id, selected)? {
         let outcome = super::rebase::perform(
             &repository,
@@ -221,18 +224,248 @@ pub(crate) fn perform(
         head_id = outcome
             .map(head_id)
             .context("HEAD disappeared while completing its rebase")?;
+        review_roots = review_roots.into_iter().filter_map(|id| outcome.map(id)).collect();
         repository = open_repository(repository_path, bare, false)
             .context("could not reopen repository after completing a pending rebase")?;
         completed_graph = Some(super::loaded_graph(&repository)?);
     }
+    let graph = completed_graph.as_ref().unwrap_or(graph);
+    let source_review = review_tree(&repository, graph, &review_roots, head_id)?;
+    let destination_review = review_tree(&repository, graph, &review_roots, selected)?;
+    let crosses_review_boundary =
+        source_review.as_ref().map(|review| review.root) != destination_review.as_ref().map(|review| review.root);
+    let workdir = repository
+        .workdir()
+        .context("time-travel requires a worktree")?
+        .to_owned();
     drop(repository);
-    Ok(Perform::Complete(move_head(
-        repository_path,
-        bare,
-        selected,
-        revisions,
-        include_worktrees,
-    )?))
+
+    let saved = if crosses_review_boundary {
+        source_review
+            .as_ref()
+            .map(|review| save_review_stash(repository_path, bare, &workdir, review))
+            .transpose()?
+            .flatten()
+    } else {
+        None
+    };
+    let moved = move_head(repository_path, bare, selected, revisions, include_worktrees);
+    let mut notice = match moved {
+        Ok(notice) => notice,
+        Err(err) => {
+            let err = match saved {
+                Some(stash) => match apply_review_stash(repository_path, bare, &workdir, stash) {
+                    Ok(notice) => err.context(format!("source review stash restoration: {notice}")),
+                    Err(restore) => err.context(format!("source review stash could not be restored: {restore:#}")),
+                },
+                None => err,
+            };
+            return Err(err);
+        }
+    };
+    if let Some(saved) = saved
+        && let Some(warning) = saved.warning
+    {
+        append_notice(&mut notice, warning);
+    }
+    if crosses_review_boundary
+        && let Some(review) = destination_review
+        && let Some(stash) = find_review_stash(repository_path, bare, &review)?
+    {
+        append_notice(&mut notice, apply_review_stash(repository_path, bare, &workdir, stash)?);
+    }
+    Ok(Perform::Complete(notice))
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct ReviewTree {
+    root: ObjectId,
+    reference: gix::refs::FullName,
+}
+
+fn review_tree(
+    repo: &gix::Repository,
+    graph: &history::HistoryGraph,
+    roots: &[ObjectId],
+    commit: ObjectId,
+) -> Result<Option<ReviewTree>> {
+    let mut nearest = None;
+    for root in roots.iter().copied().filter(|root| graph.is_ancestor(*root, commit)) {
+        nearest = match nearest {
+            None => Some(root),
+            Some(current) if graph.is_ancestor(current, root) => Some(root),
+            Some(current) if graph.is_ancestor(root, current) => Some(current),
+            Some(_) => anyhow::bail!("commit belongs to multiple unrelated review trees"),
+        };
+    }
+    let Some(root) = nearest else { return Ok(None) };
+    let commit = repo.find_commit(root)?.decode()?.into_owned()?;
+    let reference = super::review::reference(&commit)?.context("review root lost its review identity")?;
+    Ok(Some(ReviewTree { root, reference }))
+}
+
+#[derive(Clone)]
+struct SavedStash {
+    name: gix::refs::FullName,
+    target: Target,
+    warning: Option<String>,
+}
+
+#[tracing::instrument(skip_all, fields(review = %review.reference))]
+fn save_review_stash(
+    repository_path: &Path,
+    bare: bool,
+    workdir: &Path,
+    review: &ReviewTree,
+) -> Result<Option<SavedStash>> {
+    if !super::review::is_dirty(workdir)? {
+        return Ok(None);
+    }
+    let name = super::review::stash_reference(review.reference.as_bstr())?;
+    let repo =
+        open_repository(repository_path, bare, false).context("could not open repository to save review state")?;
+    if repo.try_find_reference(name.as_ref())?.is_some() {
+        anyhow::bail!("review {} already has saved worktree state", review.reference.shorten());
+    }
+    let previous = repo
+        .try_find_reference("refs/stash")?
+        .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach));
+    drop(repo);
+
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["stash", "push", "--include-untracked", "--quiet", "--message"])
+        .arg(format!("tix review {}", review.reference.shorten()))
+        .output()
+        .context("could not launch git stash push")?;
+    if !output.status.success() {
+        anyhow::bail!("git stash push failed: {}", output.stderr.trim().to_str_lossy());
+    }
+
+    let repo = open_repository(repository_path, bare, false).context("could not reopen repository after stashing")?;
+    let mut stash = repo
+        .try_find_reference("refs/stash")?
+        .context("git stash push did not create refs/stash")?;
+    let id = stash.peel_to_id()?.detach();
+    if previous == Some(id) {
+        anyhow::bail!("git stash push did not create a new stash");
+    }
+    let target = Target::Object(id);
+    if let Err(err) = repo.edit_references([RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: "tix review auto-stash".into(),
+            },
+            expected: PreviousValue::MustNotExist,
+            new: target.clone(),
+        },
+        name: name.clone(),
+        deref: false,
+    }]) {
+        drop(repo);
+        let restore = Command::new("git")
+            .arg("-C")
+            .arg(workdir)
+            .args(["stash", "pop", "--index", "--quiet"])
+            .output();
+        return Err(anyhow::anyhow!(err)).context(match restore {
+            Ok(output) if output.status.success() => {
+                "could not retain review stash; original state was restored".to_owned()
+            }
+            Ok(output) => format!(
+                "could not retain review stash and git stash pop failed: {}",
+                output.stderr.trim().to_str_lossy()
+            ),
+            Err(restore) => format!("could not retain review stash and could not launch git stash pop: {restore}"),
+        });
+    }
+    drop(repo);
+
+    let warning = match current_stash(repository_path, bare)? {
+        Some(current) if current == id => {
+            let output = Command::new("git")
+                .arg("-C")
+                .arg(workdir)
+                .args(["stash", "drop", "--quiet", "stash@{0}"])
+                .output()
+                .context("could not launch git stash drop")?;
+            (!output.status.success()).then(|| {
+                format!(
+                    "review state was saved, but its ordinary stash entry remains: {}",
+                    output.stderr.trim().to_str_lossy()
+                )
+            })
+        }
+        _ => Some("review state was saved, but refs/stash changed before its entry could be dropped".to_owned()),
+    };
+    tracing::info!(review = %review.reference, stash = %name, %id, "saved review worktree state");
+    Ok(Some(SavedStash { name, target, warning }))
+}
+
+fn current_stash(repository_path: &Path, bare: bool) -> Result<Option<ObjectId>> {
+    let repo = open_repository(repository_path, bare, false).context("could not inspect refs/stash")?;
+    let Some(mut reference) = repo.try_find_reference("refs/stash")? else {
+        return Ok(None);
+    };
+    Ok(Some(reference.peel_to_id()?.detach()))
+}
+
+fn find_review_stash(repository_path: &Path, bare: bool, review: &ReviewTree) -> Result<Option<SavedStash>> {
+    let repo = open_repository(repository_path, bare, false).context("could not inspect saved review state")?;
+    let name = super::review::stash_reference(review.reference.as_bstr())?;
+    let Some(reference) = repo.try_find_reference(name.as_ref())? else {
+        return Ok(None);
+    };
+    Ok(Some(SavedStash {
+        name,
+        target: reference.target().into_owned(),
+        warning: None,
+    }))
+}
+
+#[tracing::instrument(skip_all, fields(stash = %stash.name))]
+fn apply_review_stash(repository_path: &Path, bare: bool, workdir: &Path, stash: SavedStash) -> Result<String> {
+    let repo =
+        open_repository(repository_path, bare, false).context("could not open repository before applying stash")?;
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["stash", "apply", "--index", "--quiet"])
+        .arg(stash.name.as_bstr().to_str_lossy().as_ref())
+        .output()
+        .context("could not launch git stash apply")?;
+    let deletion = repo.edit_references([RefEdit {
+        change: Change::Delete {
+            expected: PreviousValue::MustExistAndMatch(stash.target),
+            log: RefLog::AndReference,
+        },
+        name: stash.name.clone(),
+        deref: false,
+    }]);
+    let mut notice = if output.status.success() {
+        format!("restored {}", stash.name.shorten())
+    } else {
+        format!(
+            "{} restore needs attention: {}",
+            stash.name.shorten(),
+            output.stderr.trim().to_str_lossy()
+        )
+    };
+    if let Err(err) = deletion {
+        write!(notice, "; stash reference remains: {err}").expect("writing to a string cannot fail");
+    }
+    tracing::info!(stash = %stash.name, success = output.status.success(), "applied review worktree state");
+    Ok(notice)
+}
+
+fn append_notice(notice: &mut Option<String>, addition: String) {
+    match notice {
+        Some(notice) => write!(notice, "; {addition}").expect("writing to a string cannot fail"),
+        None => *notice = Some(addition),
+    }
 }
 
 fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId) -> Result<Option<ObjectId>> {
@@ -408,6 +641,47 @@ mod tests {
 
     use super::*;
 
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!("git {} failed: {}", args.join(" "), output.stderr.trim().to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    fn review_stash_fixture() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, PathBuf, SavedStash)> {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        git(fixture.path(), &["init", "-q", "-b", "main"])?;
+        git(fixture.path(), &["config", "user.name", "reviewer"])?;
+        git(fixture.path(), &["config", "user.email", "reviewer@example.com"])?;
+        std::fs::write(fixture.path().join("file"), "base\n")?;
+        git(fixture.path(), &["add", "file"])?;
+        git(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "base"],
+        )?;
+        std::fs::write(fixture.path().join("file"), "stashed\n")?;
+        git(fixture.path(), &["stash", "push", "-q", "-m", "review"])?;
+        let name: gix::refs::FullName = "refs/worktree/tix/review/stashes/1".try_into()?;
+        git(
+            fixture.path(),
+            &["update-ref", name.as_bstr().to_str_lossy().as_ref(), "refs/stash"],
+        )?;
+        git(fixture.path(), &["stash", "drop", "-q", "stash@{0}"])?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let repository_path = repo.git_dir().to_owned();
+        let target = repo.find_reference(name.as_ref())?.target().into_owned();
+        Ok((
+            fixture,
+            repository_path,
+            SavedStash {
+                name,
+                target,
+                warning: None,
+            },
+        ))
+    }
+
     fn loaded_graph(repository: &gix::Repository, revisions: &[OsString]) -> Result<history::HistoryGraph> {
         let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
             history::Authors::default(),
@@ -430,6 +704,191 @@ mod tests {
         graph.context("history traversal did not produce a graph")
     }
 
+    #[test]
+    fn review_state_is_stashed_only_when_crossing_its_tree_boundary() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        git(fixture.path(), &["init", "-q", "-b", "main"])?;
+        git(fixture.path(), &["config", "user.name", "reviewer"])?;
+        git(fixture.path(), &["config", "user.email", "reviewer@example.com"])?;
+        for (name, contents) in [("staged", "base\n"), ("unstaged", "base\n")] {
+            std::fs::write(fixture.path().join(name), contents)?;
+        }
+        git(fixture.path(), &["add", "."])?;
+        git(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "base"],
+        )?;
+        let base = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        for name in ["staged", "unstaged"] {
+            std::fs::write(fixture.path().join(name), "tip\n")?;
+        }
+        git(fixture.path(), &["-c", "commit.gpgSign=false", "commit", "-qam", "tip"])?;
+        let tip = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+
+        std::fs::write(fixture.path().join("existing"), "user stash\n")?;
+        git(
+            fixture.path(),
+            &["stash", "push", "--include-untracked", "-q", "-m", "existing"],
+        )?;
+        let existing_stash = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "refs/stash"])?.trim())?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let graph = loaded_graph(&repo, &[])?;
+        drop(repo);
+        let started = super::super::review::start(fixture.path(), false, &graph, tip, base)?;
+
+        git(fixture.path(), &["add", "staged"])?;
+        std::fs::write(fixture.path().join("untracked"), "new\n")?;
+        let before = git(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?;
+        let child = ObjectId::from_hex(
+            git(
+                fixture.path(),
+                &[
+                    "-c",
+                    "commit.gpgSign=false",
+                    "commit-tree",
+                    &format!("{}^{{tree}}", started.commit),
+                    "-p",
+                    &started.commit.to_string(),
+                    "-m",
+                    "review child",
+                ],
+            )?
+            .trim(),
+        )?;
+        git(
+            fixture.path(),
+            &["update-ref", "refs/worktree/tix/pins/child", &child.to_string()],
+        )?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let repository_path = repo.git_dir().to_owned();
+        let graph = loaded_graph(&repo, &[])?;
+        assert_eq!(
+            review_tree(&repo, &graph, &[started.commit], started.commit)?.map(|tree| tree.root),
+            Some(started.commit)
+        );
+        assert_eq!(
+            review_tree(&repo, &graph, &[started.commit], child)?.map(|tree| tree.root),
+            Some(started.commit)
+        );
+        drop(repo);
+
+        perform(&repository_path, false, child, &graph, &[started.commit], &[], false)?.complete()?;
+        assert_eq!(
+            git(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?,
+            before,
+            "moving within one review tree leaves index and worktree handling to checkout"
+        );
+        let stash_name = super::super::review::stash_reference(started.reference.as_bstr())?;
+        assert!(
+            crate::open_test_repository(fixture.path())?
+                .try_find_reference(stash_name.as_ref())?
+                .is_none(),
+            "no stash is created inside the review tree"
+        );
+
+        perform(&repository_path, false, tip, &graph, &[started.commit], &[], false)?.complete()?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        assert!(repo.try_find_reference(stash_name.as_ref())?.is_some());
+        assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
+        assert!(
+            git(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty(),
+            "crossing out leaves the destination clean"
+        );
+        drop(repo);
+
+        perform(&repository_path, false, child, &graph, &[started.commit], &[], false)?.complete()?;
+        assert_eq!(
+            git(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?,
+            before,
+            "returning through any review descendant restores exact review state"
+        );
+        let repo = crate::open_test_repository(fixture.path())?;
+        assert!(repo.try_find_reference(stash_name.as_ref())?.is_none());
+        assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
+        Ok(())
+    }
+
+    #[test]
+    fn review_stash_references_are_consumed_after_any_git_apply_result() -> gix_testtools::Result {
+        let (fixture, repository_path, stash) = review_stash_fixture()?;
+        std::fs::write(fixture.path().join("file"), "destination\n")?;
+        git(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-qam", "destination"],
+        )?;
+        let notice = apply_review_stash(&repository_path, false, fixture.path(), stash.clone())?;
+        assert!(notice.contains("needs attention"), "the conflict is reported: {notice}");
+        let repo = crate::open_test_repository(fixture.path())?;
+        assert!(repo.try_find_reference(stash.name.as_ref())?.is_none());
+        assert!(
+            repo.index_or_empty()?
+                .entries()
+                .iter()
+                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted),
+            "Git's ordinary stash conflict remains in the index"
+        );
+
+        let (fixture, repository_path, stash) = review_stash_fixture()?;
+        std::fs::write(fixture.path().join(".git/index.lock"), "locked")?;
+        let notice = apply_review_stash(&repository_path, false, fixture.path(), stash.clone())?;
+        assert!(
+            notice.contains("needs attention"),
+            "the fatal apply failure is reported: {notice}"
+        );
+        assert!(
+            crate::open_test_repository(fixture.path())?
+                .try_find_reference(stash.name.as_ref())?
+                .is_none(),
+            "the review stash ref is consumed even when Git cannot apply it"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn nested_review_trees_use_the_nearest_review_root() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let original = repo.head_id()?.detach();
+        let mut commit = repo.find_commit(original)?.decode()?.into_owned()?;
+        commit.parents = [original].into_iter().collect();
+        commit.message = "outer review".into();
+        commit
+            .extra_headers
+            .push(("tix-rebase".into(), "onto refs/worktree/tix/review/1".into()));
+        let outer = repo.write_object(&commit)?.detach();
+        commit.parents = [outer].into_iter().collect();
+        commit.message = "middle".into();
+        commit.extra_headers.clear();
+        let middle = repo.write_object(&commit)?.detach();
+        commit.parents = [middle].into_iter().collect();
+        commit.message = "inner review".into();
+        commit
+            .extra_headers
+            .push(("tix-rebase".into(), "onto refs/worktree/tix/review/2".into()));
+        let inner = repo.write_object(&commit)?.detach();
+        commit.parents = [inner].into_iter().collect();
+        commit.message = "tip".into();
+        commit.extra_headers.clear();
+        let tip = repo.write_object(&commit)?.detach();
+        repo.reference(
+            "refs/heads/main",
+            tip,
+            PreviousValue::ExistingMustMatch(Target::Object(original)),
+            "prepare nested reviews",
+        )?;
+        let graph = loaded_graph(&repo, &[])?;
+
+        assert_eq!(
+            review_tree(&repo, &graph, &[outer, inner], middle)?.map(|tree| tree.root),
+            Some(outer)
+        );
+        assert_eq!(
+            review_tree(&repo, &graph, &[outer, inner], tip)?.map(|tree| tree.root),
+            Some(inner)
+        );
+        Ok(())
+    }
+
     #[test]
     fn travels_with_symbolic_and_direct_pins_and_returns() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -448,7 +907,7 @@ mod tests {
         assert!(!contains(&repository, main, root));
         drop(repository);
 
-        let notice = perform(&repository_path, false, root, &graph, &[], false)?
+        let notice = perform(&repository_path, false, root, &graph, &[], &[], false)?
             .complete()?
             .context("time-travel changed HEAD")?;
         assert!(notice.contains("saved pin:"), "{notice}");
@@ -475,7 +934,7 @@ mod tests {
         assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
         drop(repository);
 
-        perform(&repository_path, false, topic, &graph, &[], false)?.complete()?;
+        perform(&repository_path, false, topic, &graph, &[], &[], false)?.complete()?;
         let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -491,12 +950,12 @@ mod tests {
             .status()?;
         assert!(detach.success());
         let graph = loaded_graph(&crate::open_test_repository(fixture.path())?, &[])?;
-        perform(&repository_path, false, root, &graph, &[], false)?.complete()?;
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
         let pin = history::all_pins(&crate::open_test_repository(fixture.path())?)?
             .pop()
             .context("direct pin is present")?;
         assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
-        perform(&repository_path, false, main, &graph, &[], false)?.complete()?;
+        perform(&repository_path, false, main, &graph, &[], &[], false)?.complete()?;
         let repository = crate::open_test_repository(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
@@ -533,7 +992,7 @@ mod tests {
                 .success()
         );
 
-        perform(&repository_path, false, topic, &graph, &[], false)?.complete()?;
+        perform(&repository_path, false, topic, &graph, &[], &[], false)?.complete()?;
         let repository = crate::open_test_repository(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), topic);
         let pins = history::all_pins(&repository)?;
@@ -557,7 +1016,7 @@ mod tests {
         let graph = loaded_graph(&repository, &revisions)?;
         drop(repository);
 
-        perform(&repository_path, false, root, &graph, &revisions, false)?.complete()?;
+        perform(&repository_path, false, root, &graph, &[], &revisions, false)?.complete()?;
         assert!(
             history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty(),
             "an explicit tip already retains the former HEAD"
@@ -578,7 +1037,7 @@ mod tests {
                 .success()
         );
         std::fs::write(fixture.path().join("main"), "dirty\n")?;
-        let err = perform(&repository_path, false, root, &graph, &[], false)
+        let err = perform(&repository_path, false, root, &graph, &[], &[], false)
             .and_then(Perform::complete)
             .expect_err("Git rejects a conflicting checkout");
         assert!(format!("{err:#}").contains("git checkout failed"));
@@ -636,7 +1095,7 @@ mod tests {
         let root = repository.rev_parse_single("HEAD~2")?.detach();
         let before = gix_testtools::repository::snapshot(fixture.path())?;
 
-        let Perform::Conflict(conflict) = perform(&repository_path, false, root, &graph, &[], false)? else {
+        let Perform::Conflict(conflict) = perform(&repository_path, false, root, &graph, &[], &[], false)? else {
             return Err("the pending rebase should suspend at its conflicting cherry-pick".into());
         };
         assert_eq!(
@@ -682,7 +1141,7 @@ mod tests {
                 .to_string()
                 .replace("\n  \n", "\n\n")
         );
-        let err = perform(&repository_path, false, root, &graph, &[], false)
+        let err = perform(&repository_path, false, root, &graph, &[], &[], false)
             .and_then(Perform::complete)
             .expect_err("time-travel is disabled until the index conflict is resolved");
         assert!(format!("{err:#}").contains("unresolved index conflicts"));
@@ -706,7 +1165,7 @@ mod tests {
             super::super::rebase::Tree::LeaveAsIsAndMark,
         )?;
         let graph = loaded_graph(&repository, &[])?;
-        perform(&repository_path, false, root, &graph, &[], false)?.complete()?;
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
 
         let repository = crate::open_test_repository(fixture.path())?;
         let mut current = Some(repository.find_reference("refs/heads/main")?.id().detach());
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 599e41d403f..1092401104f 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -44,6 +44,7 @@ pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
 pub(crate) const PIN_PREFIX: &[u8] = b"refs/worktree/tix/pins/";
 pub(crate) const REVIEW_PREFIX: &[u8] = b"refs/worktree/tix/review/";
+pub(crate) const REVIEW_STASH_PREFIX: &[u8] = b"refs/worktree/tix/review/stashes/";
 
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct Pin {
@@ -1266,6 +1267,12 @@ pub(crate) fn all_reviews(repo: &gix::Repository) -> Result<Vec<Pin>> {
     refs_with_commit_targets(repo, REVIEW_PREFIX, "review")
 }
 
+pub(crate) fn review_number(name: &BStr) -> Option<&BStr> {
+    let suffix = name.strip_prefix(REVIEW_PREFIX)?;
+    (suffix.first().is_some_and(|digit| matches!(digit, b'1'..=b'9')) && suffix.iter().all(u8::is_ascii_digit))
+        .then_some(suffix.as_bstr())
+}
+
 fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str) -> Result<Vec<Pin>> {
     let mut out = Vec::new();
     let references = repo.references().context("could not open references")?;
@@ -1280,7 +1287,7 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
         };
         let suffix = reference.name().as_bstr().strip_prefix(prefix).unwrap_or_default();
         let valid_suffix = if prefix == REVIEW_PREFIX {
-            suffix.first().is_some_and(|digit| matches!(digit, b'1'..=b'9')) && suffix.iter().all(u8::is_ascii_digit)
+            review_number(reference.name().as_bstr()).is_some()
         } else {
             suffix.len() >= 4 && suffix.iter().all(u8::is_ascii_alphanumeric)
         };
@@ -1574,8 +1581,11 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let full_name = reference.name().to_owned();
+        if full_name.as_bstr().starts_with(REVIEW_STASH_PREFIX) {
+            continue;
+        }
         let pin_suffix = full_name.as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
-        let review_suffix = full_name.as_bstr().strip_prefix(REVIEW_PREFIX).map(BString::from);
+        let review_suffix = review_number(full_name.as_bstr()).map(BString::from);
         if pin_suffix.is_some() && !pins.contains(full_name.as_bstr()) {
             continue;
         }
@@ -2392,6 +2402,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn review_stashes_are_not_history_tips_or_decorations() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let head = repo.head_id()?.detach();
+        let stash = repo.rev_parse_single("topic")?.detach();
+        repo.reference(
+            "refs/worktree/tix/review/1",
+            head,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test review",
+        )?;
+        repo.reference(
+            "refs/worktree/tix/review/stashes/1",
+            stash,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test review stash",
+        )?;
+
+        assert_eq!(all_reviews(&repo)?.len(), 1);
+        assert!(!snapshot(&repo, &[], &[], false)?.view_tips.contains(&stash));
+        assert!(
+            decorations(&repo, &[], &worktree_checkouts(&repo))?
+                .values()
+                .flatten()
+                .all(|decoration| !decoration.name.contains_str("stashes")),
+            "saved review state is an internal resource"
+        );
+        Ok(())
+    }
+
     #[test]
     fn pins_are_private_to_the_current_worktree_and_legacy_pins_are_ignored() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 172272fc478..13559f61c1d 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1850,6 +1850,8 @@ fn event_loop(
                         });
                     match created {
                         Ok(Some(new_id)) => {
+                            let review_roots: Vec<_> =
+                                app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
                             let travel = open_repository(&repository_path, repository_is_bare, false)
                                 .context("could not reopen repository before travelling to fork")
                                 .and_then(|repository| edit::loaded_graph(&repository))
@@ -1859,6 +1861,7 @@ fn event_loop(
                                         repository_is_bare,
                                         new_id,
                                         &graph,
+                                        &review_roots,
                                         &revisions,
                                         worktrees,
                                     )
@@ -2137,6 +2140,7 @@ fn event_loop(
                 Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
+                    let review_roots: Vec<_> = app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
                     let result = history_graph
                         .as_ref()
                         .context("time-travel requires a completed history graph")
@@ -2146,6 +2150,7 @@ fn event_loop(
                                 repository_is_bare,
                                 id,
                                 graph,
+                                &review_roots,
                                 &revisions,
                                 worktrees,
                             )
@@ -2169,7 +2174,11 @@ fn event_loop(
                             app.select_commit(original);
                             pending_rebase_conflict = Some(conflict);
                         }
-                        Err(err) => app.leave_message(format!("time-travel: {err:#}")),
+                        Err(err) => {
+                            app.leave_message(format!("time-travel: {err:#}"));
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
                     }
                 }
                 Effect::VerifySignatures(ids) => {

From 49f4828cc49230b780a3e1c6755010663ebaed3c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 13:18:09 +0200
Subject: [PATCH 084/282] fix: preserve and expose suspended tix conflicts

Enhanced keyboard reporting emits a release event after the key press that
starts time travel. A pending lazy rebase can suspend on a cherry-pick
conflict, but the release was treated as the next user action and immediately
discarded that state. The red conflict marker and its checkout instruction
therefore disappeared before the user could respond.

Distinguish actionable key presses and repeats from key releases so conflicts
remain visible until Enter accepts them or another key explicitly cancels.
Emit a prominent warning when a rebase suspends and record acceptance,
cancellation, or checkout failure to make the conflict lifecycle clear in
diagnostic logs.

Document the input and diagnostic boundary and cover press, repeat, and release
events.
---
 gix-tix/spec.md    |  4 +++-
 gix-tix/src/app.rs |  4 ++++
 gix-tix/src/lib.rs | 24 +++++++++++++++++++++---
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 87d41ab30a7..db11306b6f6 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -426,7 +426,9 @@ space first; changes blocks adapt within the remaining history width.
   objects without changing the repository. The conflicting row shows a blinking
   red `C`; `<enter>` persists the prepared rebase, leaves later descendants lazy,
   and checks out the conflict tree with an unmerged index. Any other key discards
-  the suspended operation.
+  the suspended operation; key-release events are not actions and leave it armed.
+  Diagnostics warn when a conflict suspends the rebase and record whether it is
+  accepted, discarded, or fails during checkout.
 - A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ed7a0b5c3d1..cfc2a663f3c 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -574,6 +574,10 @@ impl App {
     }
 
     pub(crate) fn arm_rebase_conflict(&mut self, id: ObjectId) {
+        tracing::warn!(
+            commit_id = %id,
+            "rebase suspended on conflict; press <enter> to checkout for resolution"
+        );
         self.pending_rebase_conflict = Some(id);
         self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 13559f61c1d..e02ceefa059 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -869,6 +869,10 @@ fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keybo
     execute!(backend, DisableMouseCapture, DisableFocusChange)
 }
 
+fn is_key_press(event: &TerminalEvent) -> bool {
+    matches!(event, TerminalEvent::Key(key) if key.kind != KeyEventKind::Release)
+}
+
 fn event_loop(
     terminal: &mut ratatui::DefaultTerminal,
     mut repository: gix::ThreadSafeRepository,
@@ -1502,7 +1506,7 @@ fn event_loop(
         let Some(terminal_event) = terminal_event else {
             continue;
         };
-        let is_key_event = matches!(&terminal_event, TerminalEvent::Key(_));
+        let key_pressed = is_key_press(&terminal_event);
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
                 let action = action_with_shortcut_groups(key, app.history_display_expanded, app.edit_expanded);
@@ -1605,18 +1609,21 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
-        if is_key_event && pending_rebase_conflict.is_some() {
+        if key_pressed && pending_rebase_conflict.is_some() {
             if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
                 let conflict = pending_rebase_conflict
                     .take()
                     .expect("a pending conflict was checked before accepting it");
+                let original = conflict.original();
                 match conflict.accept() {
                     Ok((notice, id)) => {
+                        tracing::info!(commit_id = %original, rewritten_id = %id, "accepted suspended rebase conflict");
                         app.begin_conflict_resolution();
                         app.leave_message(notice);
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
+                        tracing::warn!(commit_id = %original, error = %err, "suspended rebase conflict checkout failed");
                         app.clear_rebase_conflict();
                         app.leave_message(format!("conflict checkout: {err:#}"));
                     }
@@ -1644,7 +1651,10 @@ fn event_loop(
                 urgent = true;
                 continue;
             }
-            pending_rebase_conflict = None;
+            let conflict = pending_rebase_conflict
+                .take()
+                .expect("a pending conflict was checked before discarding it");
+            tracing::info!(commit_id = %conflict.original(), ?action, "discarded suspended rebase conflict");
             app.clear_rebase_conflict();
             dirty = true;
             urgent = true;
@@ -5150,6 +5160,14 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn key_releases_do_not_cancel_suspended_operations() {
+        let key = |kind| TerminalEvent::Key(KeyEvent::new_with_kind(KeyCode::Char('t'), KeyModifiers::NONE, kind));
+        assert!(is_key_press(&key(KeyEventKind::Press)));
+        assert!(is_key_press(&key(KeyEventKind::Repeat)));
+        assert!(!is_key_press(&key(KeyEventKind::Release)));
+    }
+
     #[test]
     fn maps_continuous_mouse_scrolling_to_navigation() {
         assert_eq!(

From e90ff37dc9627f5d4941850236c60073588bb9d9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 14:29:31 +0200
Subject: [PATCH 085/282] fix: replay pending commits from unchanged tix rebase
 todos

Saving an unchanged rebase todo previously returned before planning, even when
the listed commits carried deferred tree work. This left pending rebases in
place despite an explicit request to replay the stack.

Treat an unchanged todo as actionable when its scope contains pending commits,
then run it through the ordinary todo plan so only the checked-out ancestry is
eagerly cherry-picked and other forks remain lazy.

Use tix-rebase-parent as the sole pending marker, including a hash-kind-specific
null object ID for roots, and preserve the originally recorded parent across
additional lazy rewrites so later replay applies the intended delta.

Document and test unchanged replay, pending roots, marker-driven display, and
the resulting conflict snapshot.
---
 gix-tix/spec.md                               | 17 +++--
 gix-tix/src/edit/rebase.rs                    | 76 +++++++++++++------
 ...sts__accepted-pending-rebase-conflict.snap |  5 +-
 gix-tix/src/edit/todo.rs                      | 66 +++++++++++++++-
 gix-tix/src/history.rs                        |  2 +-
 gix-tix/src/lib.rs                            | 10 ++-
 6 files changed, 137 insertions(+), 39 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index db11306b6f6..608ea10e04f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -340,7 +340,7 @@ space first; changes blocks adapt within the remaining history width.
 - An unchanged editor document is a no-op. Otherwise tix recreates the commit,
   signs it when commit-signing configuration is enabled, and rewrites every
   linear descendant with unchanged trees and corrected parentage. The rewritten
-  region is marked `tix-rebase: pending` for cherry-pick replay during time travel.
+  region is marked with `tix-rebase-parent` for cherry-pick replay during time travel.
   Mutable refs follow every rewritten commit; tags and remote-tracking refs remain
   unchanged.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
@@ -415,7 +415,7 @@ space first; changes blocks adapt within the remaining history width.
   same lazy signature-aware rebase used by amend and spill.
 - All three operations leave worktree files untouched, reset the affected worktree's
   index to the rewritten commit, and cheaply rewrite linear descendants with
-  their trees unchanged. Rewritten commits carry `tix-rebase: pending`, invalidate
+  their trees unchanged. Rewritten commits carry `tix-rebase-parent`, invalidate
   existing signatures, retain the original parent needed for later replay, and
   use a bright-cyan commit marker.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
@@ -492,10 +492,11 @@ space first; changes blocks adapt within the remaining history width.
   preparation—including cherry-pick conflict detection—finishes before objects
   become reachable through refs.
 - `Tree::LeaveAsIs` rewrites parentage without changing trees;
-  `LeaveAsIsAndMark` additionally writes `tix-rebase: pending`; and `CherryPick`
-  transplants each tree delta. User edits use `LeaveAsIsAndMark`; time travel is
-  the only eager `CherryPick` caller. A successful repeated rebase clears its
-  markers. On conflict, the existing `tix-rebase-parent` identifies the original
+  `LeaveAsIsAndMark` additionally writes the original first parent to
+  `tix-rebase-parent`, using the repository hash kind's null ID for a root; and
+  `CherryPick` transplants each tree delta. User edits use `LeaveAsIsAndMark`;
+  time travel is the only eager `CherryPick` caller. A successful repeated rebase
+  clears the marker. On conflict, `tix-rebase-parent` identifies the original
   base and later descendants remain marked instead of being cherry-picked.
 - `Signature::RedoIfNeeded` signs every rewritten commit when signing is
   configured and otherwise removes stale signature headers.
@@ -545,7 +546,9 @@ space first; changes blocks adapt within the remaining history width.
   remain untouched. Every resulting leaf without a surviving mutable ref gets a
   direct `refs/worktree/tix/pins/*` ref, except the checked-out leaf. Concurrent
   ref edits win by making the transaction fail; the editor result is not rebuilt
-  against a later graph snapshot. Leaving the document unchanged is a no-op.
+  against a later graph snapshot. Leaving the document unchanged is a no-op unless
+  its scope contains pending commits; then the unchanged plan runs with the same
+  eager `@` ancestry and lazy-fork rules.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 320c71ddf37..3867c4617af 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -19,7 +19,6 @@ use crate::history::HistoryGraph;
 
 const MARKER: &[u8] = b"tix-rebase";
 const ORIGINAL_PARENT: &[u8] = b"tix-rebase-parent";
-const PENDING: &[u8] = b"pending";
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum Signature {
@@ -360,16 +359,12 @@ fn perform_inner(
         if Some(old_id) != root || repeat {
             commit.committer = committer.clone();
         }
-        let original_parent = repeat.then(|| marked_parent(&commit)).transpose()?.flatten();
-        let original_parents = original_parent.into_iter().collect::<Vec<_>>();
+        let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
+        let original_parents = recorded_parent.flatten().into_iter().collect::<Vec<_>>();
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
-            if original_parents.is_empty() {
-                &old_parents
-            } else {
-                &original_parents
-            },
+            if !repeat { &old_parents } else { &original_parents },
             &new_parents,
             if conflict.is_some() {
                 Tree::LeaveAsIsAndMark
@@ -392,7 +387,7 @@ fn perform_inner(
         marker(
             &mut commit,
             pending,
-            original_parent.or_else(|| old_parents.first().copied()),
+            recorded_parent.flatten().or_else(|| old_parents.first().copied()),
         );
         let is_conflicting_commit = new_conflict.is_some();
         let new_id = write_commit(
@@ -651,17 +646,22 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
                 extra_headers: Vec::new(),
             },
         };
-        let old_parents = match step.commit {
+        let graph_parents = match step.commit {
             PlanCommit::Pick(id) => graph.parents_of(id).context("a picked commit is incomplete")?,
             PlanCommit::Empty(_) => vec![parent],
         };
+        let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
+        let replay_parents = recorded_parent.map_or_else(
+            || graph_parents.clone(),
+            |parent| parent.into_iter().collect::<Vec<_>>(),
+        );
         let mode = if eager {
             Tree::CherryPick
         } else {
             Tree::LeaveAsIsAndMark
         };
         let mut new_conflict = None;
-        commit.tree = match rewritten_tree(&repo, &commit, &old_parents, &[parent], mode)? {
+        commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
             TreeRewrite::Conflict { tree, conflicts } => {
                 new_conflict = Some((tree, conflicts));
@@ -673,7 +673,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         marker(
             &mut commit,
             !eager || new_conflict.is_some(),
-            old_parents.first().copied(),
+            recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
         );
         let signature = if eager && new_conflict.is_none() {
             Signature::RedoIfNeeded
@@ -1041,16 +1041,14 @@ fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<Objec
 }
 
 fn marker(commit: &mut gix::objs::Commit, add: bool, original_parent: Option<ObjectId>) {
-    commit.extra_headers.retain(|(name, value)| {
-        !(name.as_slice() == MARKER && value.as_slice() == PENDING) && name.as_slice() != ORIGINAL_PARENT
-    });
+    commit
+        .extra_headers
+        .retain(|(name, _)| name.as_slice() != ORIGINAL_PARENT);
     if add {
-        commit.extra_headers.push((MARKER.into(), PENDING.into()));
-        if let Some(parent) = original_parent {
-            commit
-                .extra_headers
-                .push((ORIGINAL_PARENT.into(), parent.to_hex().to_string().into()));
-        }
+        let parent = original_parent.unwrap_or_else(|| ObjectId::null(commit.tree.kind()));
+        commit
+            .extra_headers
+            .push((ORIGINAL_PARENT.into(), parent.to_hex().to_string().into()));
     }
 }
 
@@ -1059,15 +1057,20 @@ fn marked_parent(commit: &gix::objs::Commit) -> Result<Option<ObjectId>> {
         .extra_headers
         .iter()
         .find(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
-        .map(|(_, value)| ObjectId::from_hex(value).context("pending rebase has an invalid original parent"))
+        .map(|(_, value)| {
+            ObjectId::from_hex(value)
+                .context("pending rebase has an invalid original parent")
+                .map(|id| (!id.is_null()).then_some(id))
+        })
         .transpose()
+        .map(Option::flatten)
 }
 
 pub(super) fn has_marker(commit: &gix::objs::Commit) -> bool {
     commit
         .extra_headers
         .iter()
-        .any(|(name, value)| name.as_slice() == MARKER && value.as_slice() == PENDING)
+        .any(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
 }
 
 fn write_commit(
@@ -1521,6 +1524,33 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pending_roots_use_a_null_parent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let root = repo.rev_parse_single("HEAD~2")?.detach();
+        let commit = repo.find_commit(root)?.decode()?.into_owned()?;
+        let marked = perform(
+            &repo,
+            &graph,
+            Edit::Replace { target: root, commit },
+            Signature::InvalidateExisting,
+            Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?
+        .selected
+        .expect("the pending replacement selects its rewritten root");
+        let commit = repo.find_commit(marked)?.decode()?.into_owned()?;
+        assert!(has_marker(&commit));
+        assert_eq!(marked_parent(&commit)?, None);
+        assert!(commit.extra_headers.iter().any(|(name, value)| {
+            name.as_slice() == ORIGINAL_PARENT
+                && ObjectId::from_hex(value).is_ok_and(|id| id == ObjectId::null(repo.object_hash()))
+        }));
+        Ok(())
+    }
+
     #[test]
     fn rewrites_every_fork_without_flattening_it() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index f35a10a7708..32e3de038a1 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -6,7 +6,7 @@ HEAD detached C1
 
 [refs]
 refs/heads/main = C2
-refs/worktree/tix/pins/6a06a74d = -> refs/heads/main
+refs/worktree/tix/pins/06e842b0 = -> refs/heads/main
 
 [commits]
 C0
@@ -29,7 +29,6 @@ C2
   parent C1
   author author <author@example.com> 946944000 +0000
   committer author <author@example.com> 978307200 +0000
-  tix-rebase pending
   tix-rebase-parent 76ca9987dd431a8b8be20a52aeed5066cd1058fe
 
   after
@@ -44,9 +43,9 @@ tree = conflicted
 100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
 
 [objects]
+C2 = 06e842b07e26ecf14fa3af38af83313e25b407dc
 T0 = 0f42ecffc297189265600788215c8b0055d862b8
 C1 = 54b039307b71caeb5f620a9ad9c965d10db1f598
-C2 = 6a06a74d441ff8640e0951400beff9498ded5814
 T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T2 = 6f2762b571ef9a93001cc607058818aa5d0d055c
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 2dbb7fea395..9d475c69656 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -16,7 +16,7 @@ const HELP: &[u8] = br#"
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
-- Saving an unchanged document is a no-op. Otherwise, the ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
+- Saving an unchanged document is a no-op unless listed commits have a pending rebase. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Mutable refs follow rewritten and dropped commits, except tags and remote-tracking refs. New unreferenced leaves are pinned.
 - A checkout conflict uses tix's standard suspended-conflict flow; concurrent ref changes abort the update.
 -->
@@ -36,6 +36,7 @@ pub(crate) struct Prepared {
     marker_required: bool,
     checkout_allowed: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
+    pub has_pending: bool,
 }
 
 struct Section {
@@ -60,6 +61,9 @@ pub(crate) fn prepare(
     let scope_set: HashSet<_> = scope.iter().copied().collect();
     let marker_required = head.is_some_and(|head| scope_set.contains(&head));
     let expected_refs = rebase::capture_refs(repo, &scope)?;
+    let has_pending = commits.iter().try_fold(false, |pending, commit| {
+        Ok::<_, anyhow::Error>(pending || rebase::has_marker(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
+    })?;
 
     let mut children = HashMap::<ObjectId, Vec<ObjectId>>::new();
     let by_id: HashMap<_, _> = commits.iter().map(|commit| (commit.id, commit)).collect();
@@ -130,6 +134,7 @@ pub(crate) fn prepare(
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
         expected_refs,
+        has_pending,
     })
 }
 
@@ -318,6 +323,8 @@ fn resolve_commit(repo: &gix::Repository, value: &str) -> Result<ObjectId> {
 
 #[cfg(test)]
 mod tests {
+    use std::process::Command;
+
     use super::*;
 
     fn repo() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
@@ -362,6 +369,7 @@ mod tests {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
         let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        assert!(!prepared.has_pending);
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
@@ -381,6 +389,62 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn an_unchanged_todo_replays_pending_commits_with_normal_plan_semantics() -> gix_testtools::Result {
+        let (fixture, repo) = repo()?;
+        let (base, middle, _tip, _) = commits(&repo)?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.tree = repo.find_commit(base)?.tree_id()?.detach();
+        let marked = rebase::perform(
+            &repo,
+            &graph,
+            rebase::Edit::Replace { target: middle, commit },
+            rebase::Signature::InvalidateExisting,
+            rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?
+        .selected
+        .expect("the pending replacement selects its rewritten commit");
+        let tip = repo.head_id()?.detach();
+        let commits = vec![
+            Commit {
+                id: tip,
+                parents: vec![marked],
+                info: "tip".into(),
+            },
+            Commit {
+                id: marked,
+                parents: vec![base],
+                info: "middle".into(),
+            },
+        ];
+        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        assert!(
+            prepared.has_pending,
+            "pending commits make an unchanged todo actionable"
+        );
+        let document = prepared.document.clone();
+        let plan = parse(&repo, prepared, &document)?;
+        let graph = super::super::loaded_graph(&repo)?;
+        rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+
+        let mut current = Some(repo.head_id()?.detach());
+        while let Some(id) = current {
+            let commit = repo.find_commit(id)?.decode()?.into_owned()?;
+            assert!(!rebase::has_marker(&commit), "the eager @ ancestry is replayed");
+            current = commit.parents.first().copied();
+        }
+        let files = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["ls-tree", "-r", "--name-only", "HEAD"])
+            .output()?;
+        assert!(files.status.success());
+        assert_eq!(files.stdout, b"base\ntip\n", "replay uses the recorded original parent");
+        Ok(())
+    }
+
     #[test]
     fn update_todo_roots_the_stack_at_the_hidden_tip_and_labels_only_that_heading() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 1092401104f..a79d6e0a711 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1435,7 +1435,7 @@ fn decode_metadata<'a>(
                     }
                 }
             }
-            Token::ExtraHeader((name, value)) if name == "tix-rebase" && value.as_ref() == b"pending" => {
+            Token::ExtraHeader((name, _)) if name == "tix-rebase-parent" => {
                 signature = SignatureState::PendingRebase;
             }
             Token::ExtraHeader((name, value))
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index e02ceefa059..95021a40155 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3209,15 +3209,17 @@ fn rebase_history(
         repository.object_cache_size(None);
         edit::todo::prepare(&repository, base, onto, onto_title.as_deref(), &commits, head)?
     };
-    let Some(edited) = edit::edit_document(
+    let edited = edit::edit_document(
         terminal,
         &prepared.editor,
         &prepared.document,
         &format!("tix-rebase-{}.md", std::process::id()),
         enhanced_keyboard,
-    )?
-    else {
-        return Ok(None);
+    )?;
+    let edited = match edited {
+        Some(edited) => edited,
+        None if prepared.has_pending => prepared.document.clone(),
+        None => return Ok(None),
     };
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing rebase")?;

From 34a5d974e4fb8fb99de9e5fb4ad12a81e16f693f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 14:37:59 +0200
Subject: [PATCH 086/282] feat: distinguish the current symbolic branch in tix

The commit marker identifies the current checkout, but a plain local branch
decoration cannot show whether HEAD is attached to that branch or merely
detached at the same commit.

Classify the current worktree's exact symbolic target from the existing
worktree snapshot and render it as @branch in the normal local-reference color.
Keep branches checked out in other worktrees as branch@, and leave coincident
branch decorations unchanged while the current HEAD is detached.

Preserve reference visibility and upstream lookup semantics, and document and
test attached, detached, current, and linked-worktree labels.
---
 gix-tix/spec.md        |  7 ++++---
 gix-tix/src/history.rs | 30 ++++++++++++++++++------------
 gix-tix/src/ui.rs      | 14 ++++++++++++++
 3 files changed, 36 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 608ea10e04f..a68fe0fff94 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -95,9 +95,10 @@ without trading responsiveness for metadata that is not visible.
   row keeps only bold `@`.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. Other detached
-  worktrees use their checkout directory basename. The current worktree is
-  represented by the commit's `@` marker and ordinary local reference; identical
-  labels are deduplicated.
+  worktrees use their checkout directory basename. The current worktree's
+  symbolic branch is displayed as `@short-name` in the local-reference color;
+  if its HEAD is detached, a branch that happens to point at the same commit
+  remains an ordinary branch label. Identical labels are deduplicated.
 - When reference labels are hidden, worktree labels are visible only on the
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index a79d6e0a711..6bb17599435 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -31,6 +31,7 @@ pub(crate) enum DecorationKind {
     Head,
     Pin,
     Review,
+    CurrentWorktreeBranch,
     WorktreeBranch,
     WorktreeDetached,
     Local,
@@ -364,7 +365,10 @@ impl HistoryGraph {
             .into_iter()
             .flatten()
             .map(|decoration| {
-                let upstream = if matches!(decoration.kind, DecorationKind::Local | DecorationKind::WorktreeBranch) {
+                let upstream = if matches!(
+                    decoration.kind,
+                    DecorationKind::Local | DecorationKind::CurrentWorktreeBranch | DecorationKind::WorktreeBranch
+                ) {
                     tracked
                         .into_iter()
                         .flatten()
@@ -1603,7 +1607,12 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             continue;
         };
         let id = id.detach();
-        if worktrees.iter().any(|worktree| {
+        if worktrees
+            .iter()
+            .any(|worktree| worktree.is_current && worktree.id == id && worktree.reference.as_ref() == Some(&full_name))
+        {
+            kind = DecorationKind::CurrentWorktreeBranch;
+        } else if worktrees.iter().any(|worktree| {
             !worktree.is_current && worktree.id == id && worktree.reference.as_ref() == Some(&full_name)
         }) {
             kind = DecorationKind::WorktreeBranch;
@@ -1971,11 +1980,9 @@ mod tests {
 
         let main_repo_decorations = decorations(&repo, &[], &worktrees)?;
         let main_decorations = main_repo_decorations.get(&main).expect("main is decorated");
-        assert!(
-            main_decorations
-                .iter()
-                .any(|decoration| { decoration.kind == DecorationKind::Local && decoration.name == "main" })
-        );
+        assert!(main_decorations.iter().any(|decoration| {
+            decoration.kind == DecorationKind::CurrentWorktreeBranch && decoration.name == "main"
+        }));
         assert!(
             !main_decorations
                 .iter()
@@ -2010,12 +2017,11 @@ mod tests {
         );
         let linked_decorations = decorations(&linked_repo, &[], &linked_worktrees)?;
         assert!(linked_decorations.get(&topic).is_some_and(|decorations| {
-            decorations
+            decorations.iter().any(|decoration| {
+                decoration.kind == DecorationKind::CurrentWorktreeBranch && decoration.name == "topic"
+            }) && !decorations
                 .iter()
-                .any(|decoration| decoration.kind == DecorationKind::Local && decoration.name == "topic")
-                && !decorations
-                    .iter()
-                    .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "topic")
+                .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "topic")
         }));
         assert!(linked_decorations.get(&main).is_some_and(|decorations| {
             decorations
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 766838e1598..9a602ea742d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1660,6 +1660,8 @@ fn metadata_line<'a>(
                     DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
                 ) {
                     format!("{name}@").into()
+                } else if decoration.kind == DecorationKind::CurrentWorktreeBranch {
+                    format!("@{name}").into()
                 } else {
                     name
                 },
@@ -1853,6 +1855,7 @@ fn decoration_style(kind: DecorationKind) -> Style {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
         DecorationKind::Review => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
+        DecorationKind::CurrentWorktreeBranch => Style::default().fg(Color::Cyan),
         DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => Style::default().fg(Color::LightBlue),
         DecorationKind::Local => Style::default().fg(Color::Cyan),
         DecorationKind::Remote => Style::default().fg(Color::Yellow),
@@ -2921,6 +2924,10 @@ mod tests {
         let decorations = Decorations::from([(
             checked_out,
             vec![
+                Decoration {
+                    name: "current".into(),
+                    kind: DecorationKind::CurrentWorktreeBranch,
+                },
                 Decoration {
                     name: "main".into(),
                     kind: DecorationKind::WorktreeBranch,
@@ -2938,11 +2945,14 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(140, 3))?;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
+        assert!(row.contains("@current"));
         assert!(row.contains("main@"));
         assert!(row.contains("detached@"));
         assert!(!row.contains("HEAD"), "a worktree label replaces textual HEAD");
         let x = row.find("main@").expect("the worktree label is visible") as u16;
         assert_eq!(terminal.backend().buffer()[(x, 0)].fg, Color::LightBlue);
+        let x = row.find("@current").expect("the current branch label is visible") as u16;
+        assert_eq!(terminal.backend().buffer()[(x, 0)].fg, Color::Cyan);
 
         app.update(Action::ToggleRefs);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
@@ -2950,6 +2960,10 @@ mod tests {
             rendered_row(&terminal).contains("main@"),
             "the selected row retains worktrees"
         );
+        assert!(
+            !rendered_row(&terminal).contains("@current"),
+            "the current branch follows ordinary reference visibility"
+        );
         app.update(Action::MoveDown);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(

From ff12a8f6be424b0861f324d0a9744bc3be57fa70 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 14:47:59 +0200
Subject: [PATCH 087/282] feat: label external anchors in tix rebase todos

Fork headings previously made the selected hidden boundary look identical to a
fork created within the editable history, while rebase-update identified its
unfamiliar target only through an unlabelled title.

Render the selected boundary as `(base)` and a rebase-update target as
`(updated-base)`, followed by the same marker-aware title shown in history.
Keep descendant fork headings terse and rely on the existing display-only tail
syntax so the annotations cannot change the parsed plan.

Document both external anchors in the generated Markdown help and behavioral
specification, and test their escaped titles, labels, and parsing semantics.
---
 gix-tix/spec.md          | 11 ++++--
 gix-tix/src/edit/todo.rs | 82 ++++++++++++++++++++++++++--------------
 gix-tix/src/lib.rs       | 20 ++++------
 3 files changed, 69 insertions(+), 44 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a68fe0fff94..ea7d19f5f70 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -520,12 +520,15 @@ space first; changes blocks adapt within the remaining history width.
   `.md` todo. It grows upward like the history view: each `## fork <id>` section
   lists its commits oldest-to-newest as `` `pick <short-id>` <displayed metadata> ``.
   IDs are shortened through repository configuration; metadata repeats the
-  information visible in history and always includes the subject.
+  information visible in history and always includes the subject. Base-level
+  stacks begin with `## fork <id> (base) <title>`, using the Markdown-escaped
+  title exactly as displayed in history. Fork points within the editable tree
+  remain plain `## fork <id>` headings.
 - When that boundary shows `⇣N`, `e u` opens the same editor with each base-level
   stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
-  `## fork <id>` heading additionally includes the Markdown-escaped title exactly
-  as shown in history, including `[A]` and `[N]`; ordinary and internal fork
-  headings remain unchanged. The hidden branch itself is not moved.
+  heading is `## fork <id> (updated-base) <title>`, with the Markdown-escaped
+  title exactly as shown in history, including `[A]` and `[N]`. The hidden branch
+  itself is not moved.
 - Pick lines may be reordered or removed. Fork headings may target an earlier
   pick or any existing commit, so adding and removing headings creates and joins
   branches. `empty <title>` inserts an empty commit. Markdown code spans and
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 9d475c69656..c8ec942c9b5 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -12,7 +12,7 @@ const HELP: &[u8] = br#"
 
 - Each fork section lists a stack from its oldest commit to its newest. Blank lines are ignored.
 - `pick <id>` keeps a commit. Delete its line to drop it, or move the line to reorder it. Each listed commit may be picked only once.
-- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
+- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is labelled `(updated-base)` with its title. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
@@ -49,7 +49,7 @@ pub(crate) fn prepare(
     repo: &gix::Repository,
     base: ObjectId,
     onto: ObjectId,
-    onto_title: Option<&str>,
+    anchor_title: &str,
     commits: &[Commit],
     head: Option<ObjectId>,
 ) -> Result<Prepared> {
@@ -99,6 +99,7 @@ pub(crate) fn prepare(
     let mut document = b"<!-- Rebase help is at the bottom of this file. -->\n\n".to_vec();
     document.extend_from_slice(title.as_bytes());
     document.extend_from_slice(b"\n\n");
+    let anchor_kind = if base == onto { "base" } else { "updated-base" };
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
             document.push(b'\n');
@@ -107,7 +108,7 @@ pub(crate) fn prepare(
             &mut document,
             repo,
             section.parent,
-            (section.parent == onto && onto != base).then_some(onto_title).flatten(),
+            (section.parent == onto).then_some((anchor_kind, anchor_title)),
         )?;
         for id in &section.commits {
             let commit = by_id[id];
@@ -118,12 +119,7 @@ pub(crate) fn prepare(
         }
     }
     if sections.is_empty() {
-        write_fork_heading(
-            &mut document,
-            repo,
-            onto,
-            (onto != base).then_some(onto_title).flatten(),
-        )?;
+        write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title)))?;
     }
     document.extend_from_slice(HELP);
     Ok(Prepared {
@@ -138,10 +134,15 @@ pub(crate) fn prepare(
     })
 }
 
-fn write_fork_heading(out: &mut Vec<u8>, repo: &gix::Repository, id: ObjectId, title: Option<&str>) -> Result<()> {
+fn write_fork_heading(
+    out: &mut Vec<u8>,
+    repo: &gix::Repository,
+    id: ObjectId,
+    annotation: Option<(&str, &str)>,
+) -> Result<()> {
     out.extend_from_slice(format!("## fork {}", short(repo, id)?).as_bytes());
-    if let Some(title) = title {
-        out.extend_from_slice(format!(" {}", escape_markdown(title)).as_bytes());
+    if let Some((kind, title)) = annotation {
+        out.extend_from_slice(format!(" ({kind}) {}", escape_markdown(title)).as_bytes());
     }
     out.push(b'\n');
     Ok(())
@@ -368,12 +369,15 @@ mod tests {
     fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, "[A] base * title", &commits, Some(tip))?;
         assert!(!prepared.has_pending);
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
-        assert!(document.contains(&format!("## fork {}", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!(
+            "## fork {} (base) \\[A\\] base \\* title",
+            base.to_hex_with_len(7)
+        )));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
         assert!(middle < tip, "the todo grows from the base towards the tip");
@@ -419,7 +423,7 @@ mod tests {
                 info: "middle".into(),
             },
         ];
-        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
         assert!(
             prepared.has_pending,
             "pending commits make an unchanged todo actionable"
@@ -445,6 +449,35 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn descendant_forks_stay_terse() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, mut commits) = commits(&repo)?;
+        let mut sibling = repo.find_commit(tip)?.decode()?.into_owned()?;
+        sibling.parents = [middle].into_iter().collect();
+        sibling.message = "sibling".into();
+        let sibling = repo.write_object(&sibling)?.detach();
+        commits.insert(
+            0,
+            Commit {
+                id: sibling,
+                parents: vec![middle],
+                info: "sibling title".into(),
+            },
+        );
+
+        let prepared = prepare(&repo, base, base, "base title", &commits, Some(tip))?;
+        let document = String::from_utf8(prepared.document.clone())?;
+        assert!(document.contains(&format!("## fork {} (base) base title", base.to_hex_with_len(7))));
+        assert!(
+            document.contains(&format!("## fork {}\n", middle.to_hex_with_len(7))),
+            "a fork within the editable tree has no external-anchor annotation"
+        );
+        let plan = parse(&repo, prepared, document.as_bytes())?;
+        assert_eq!(plan.steps.len(), 3, "display annotations do not alter the plan");
+        Ok(())
+    }
+
     #[test]
     fn update_todo_roots_the_stack_at_the_hidden_tip_and_labels_only_that_heading() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
@@ -454,14 +487,7 @@ mod tests {
         commit.message = "updated hidden base".into();
         let onto = repo.write_object(&commit)?.detach();
 
-        let prepared = prepare(
-            &repo,
-            base,
-            onto,
-            Some("[A] updated * hidden base"),
-            &commits,
-            Some(tip),
-        )?;
+        let prepared = prepare(&repo, base, onto, "[A] updated * hidden base", &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(
             document.contains(&format!(
@@ -473,7 +499,7 @@ mod tests {
         );
         assert!(
             document.contains(&format!(
-                "## fork {} \\[A\\] updated \\* hidden base",
+                "## fork {} (updated-base) \\[A\\] updated \\* hidden base",
                 onto.to_hex_with_len(7)
             )),
             "the unfamiliar fork target carries its escaped UI title"
@@ -494,7 +520,7 @@ mod tests {
     fn parses_reordering_forks_empty_commits_and_a_moved_checkout() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
         let edited = format!(
             "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -505,7 +531,7 @@ mod tests {
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("two checkout markers are invalid");
         assert!(format!("{err:#}").contains("more than one @"));
 
-        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
         let edited = format!(
             "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -525,12 +551,12 @@ mod tests {
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, None, &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
         let edited = format!("## fork {}\n", base.to_hex_with_len(7));
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
 
-        let prepared = prepare(&repo, base, base, None, &commits, None)?;
+        let prepared = prepare(&repo, base, base, "base", &commits, None)?;
         let plan = parse(&repo, prepared, edited.as_bytes())?;
         assert!(
             plan.steps.is_empty(),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 95021a40155..8be1e3bb8f1 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2032,15 +2032,11 @@ fn event_loop(
                         .as_ref()
                         .context("rebasing requires a completed history graph")
                         .and_then(|graph| {
-                            let onto_title = if onto == base {
-                                None
-                            } else {
-                                Some(ui::todo_title(
-                                    &app,
-                                    app.commit(onto)
-                                        .context("the hidden rebase target disappeared from the view")?,
-                                ))
-                            };
+                            let anchor_title = ui::todo_title(
+                                &app,
+                                app.commit(onto)
+                                    .context("the rebase anchor disappeared from the view")?,
+                            );
                             rebase_history(
                                 terminal,
                                 &repository_path,
@@ -2048,7 +2044,7 @@ fn event_loop(
                                 graph,
                                 base,
                                 onto,
-                                onto_title,
+                                anchor_title,
                                 todo_commits?,
                                 head,
                                 enhanced_keyboard,
@@ -3198,7 +3194,7 @@ fn rebase_history(
     graph: &HistoryGraph,
     base: gix::ObjectId,
     onto: gix::ObjectId,
-    onto_title: Option<String>,
+    anchor_title: String,
     commits: Vec<edit::todo::Commit>,
     head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
@@ -3207,7 +3203,7 @@ fn rebase_history(
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;
         repository.object_cache_size(None);
-        edit::todo::prepare(&repository, base, onto, onto_title.as_deref(), &commits, head)?
+        edit::todo::prepare(&repository, base, onto, &anchor_title, &commits, head)?
     };
     let edited = edit::edit_document(
         terminal,

From bf7aa1daa43bc47c7776b38d1b364843e1159213 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 16:24:09 +0200
Subject: [PATCH 088/282] feat: amend selected worktree paths in tix

Offer amend from the edit prefix while a worktree-change path is selected.
Use the selected staged or unstaged version of that path to rewrite HEAD,
while leaving every unrelated path out of the commit.

Synchronize only the amended destination and any renamed source back into
the index after the ref transaction. This retains unrelated staged changes,
keeps the worktree untouched, and participates in the existing rollback if
the index cannot be locked or written.

Keep review commits restricted to staged path amendments and reject scoped
amend while the index contains unresolved conflicts. Cover staged and
unstaged content as well as additions, deletions, renames, copies, and index
rollback, and document the behavior in the tix specification.
---
 gix-tix/spec.md            |  14 +-
 gix-tix/src/app.rs         |  29 ++++-
 gix-tix/src/edit/create.rs |   4 +-
 gix-tix/src/edit/head.rs   | 259 +++++++++++++++++++++++++++++++++----
 gix-tix/src/edit/rebase.rs |  81 ++++++++++--
 gix-tix/src/lib.rs         |  20 ++-
 gix-tix/src/ui.rs          |  79 ++++++++++-
 7 files changed, 434 insertions(+), 52 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ea7d19f5f70..48f630b317f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -405,6 +405,13 @@ space first; changes blocks adapt within the remaining history width.
 - With a path selected in the focused tree-changes block, the main `e` prefix
   offers `spill` and `e s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
+- With a path selected in the focused worktree-changes block, the main `e`
+  prefix offers `amend` and `e a` amends only that path. A staged row uses its
+  index version; an unstaged row uses its filtered worktree version. If both
+  rows exist for one path, the selected row determines the version. Review
+  commits accept only staged rows, and unresolved indexes cannot be amended.
+  Unrelated staged entries retain their index state. The CLI intentionally
+  supports only whole-commit amending.
 - `e p` is offered at `@` only when both staged and unstaged changes exist. It
   amends the unstaged changes into the source commit, then creates a new upper
   commit from the staged delta using the standard Markdown editor buffer. Both
@@ -414,9 +421,10 @@ space first; changes blocks adapt within the remaining history width.
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Both commits are marked for the
   same lazy signature-aware rebase used by amend and spill.
-- All three operations leave worktree files untouched, reset the affected worktree's
-  index to the rewritten commit, and cheaply rewrite linear descendants with
-  their trees unchanged. Rewritten commits carry `tix-rebase-parent`, invalidate
+- All three operations leave worktree files untouched and cheaply rewrite linear
+  descendants with their trees unchanged. Whole-commit edits reset the affected
+  worktree's index to the rewritten commit; selected-path amend synchronizes only
+  its destination and renamed source. Rewritten commits carry `tix-rebase-parent`, invalidate
   existing signatures, retain the original parent needed for later replay, and
   use a bright-cyan commit marker.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index cfc2a663f3c..200b4059855 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -440,6 +440,7 @@ pub(crate) struct App {
     pending_rebase_conflict: Option<ObjectId>,
     worktree_conflicted: bool,
     amend_available: bool,
+    worktree_path_amend_available: bool,
     finish_review_available: bool,
     spill_available: bool,
     split_available: bool,
@@ -529,6 +530,7 @@ impl App {
             pending_rebase_conflict: None,
             worktree_conflicted: false,
             amend_available: false,
+            worktree_path_amend_available: false,
             finish_review_available: false,
             spill_available: false,
             split_available: false,
@@ -1774,7 +1776,13 @@ impl App {
     }
 
     pub(crate) fn can_amend(&self) -> bool {
-        self.can_edit_head() && self.changes_focus.is_none() && self.amend_available
+        self.can_edit_head()
+            && self.amend_available
+            && match self.changes_focus {
+                None => true,
+                Some(ChangePane::Worktree) => self.worktree_path_amend_available,
+                Some(ChangePane::Tree) => false,
+            }
     }
 
     pub(crate) fn can_spill(&self) -> bool {
@@ -1785,8 +1793,16 @@ impl App {
         self.can_edit_head() && self.changes_focus.is_none() && self.split_available
     }
 
-    pub(crate) fn set_head_edit_availability(&mut self, amend: bool, finish_review: bool, spill: bool, split: bool) {
+    pub(crate) fn set_head_edit_availability(
+        &mut self,
+        amend: bool,
+        worktree_path_amend: bool,
+        finish_review: bool,
+        spill: bool,
+        split: bool,
+    ) {
         self.amend_available = amend;
+        self.worktree_path_amend_available = worktree_path_amend;
         self.finish_review_available = finish_review;
         self.spill_available = spill;
         self.split_available = split;
@@ -2543,7 +2559,7 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_head_edit_availability(true, false, true, false);
+        app.set_head_edit_availability(true, true, false, true, false);
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
         assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
@@ -2551,7 +2567,7 @@ mod tests {
             app.update(Action::Split).is_empty(),
             "split needs both kinds of changes"
         );
-        app.set_head_edit_availability(true, false, true, true);
+        app.set_head_edit_availability(true, true, false, true, true);
         assert_eq!(app.update(Action::Split), vec![Effect::Split(id(2))]);
         app.changes_focus = Some(ChangePane::Tree);
         assert!(!app.can_amend(), "a tree path cannot be amended");
@@ -2563,6 +2579,11 @@ mod tests {
         );
         app.changes_focus = Some(ChangePane::Worktree);
         assert!(!app.can_spill(), "worktree paths cannot be spilled from a commit");
+        assert_eq!(
+            app.update(Action::Amend),
+            vec![Effect::Amend(id(2))],
+            "worktree focus scopes amend to its selected path"
+        );
         app.changes_focus = None;
         app.update(Action::MoveDown);
         assert!(!app.can_amend());
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 3682cfdd239..7e33bee446b 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -203,7 +203,9 @@ fn worktree_tree_with_changes_inner(
         }) {
             continue;
         }
-        if let Some(source) = &change.source {
+        if change.kind == ChangeKind::Renamed
+            && let Some(source) = &change.source
+        {
             editor
                 .remove(source)
                 .context("could not remove a renamed source path")?;
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 480f322e03c..f07f543775b 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -54,15 +54,25 @@ pub fn perform(
             {
                 anyhow::bail!("cannot amend with unresolved index conflicts");
             }
-            let index_tree = create::index_tree(&repo, &index)?;
-            drop(index);
-            if index_tree != old_tree {
-                index_tree
+            if let Some((path, _)) = selected_path {
+                if review && path.group != crate::ChangeGroup::Staged {
+                    anyhow::bail!("review commits can amend only staged paths");
+                }
+                amend_path_tree(&repo, old_tree, path, &index)?
             } else if review {
-                return Ok(None);
+                let index_tree = create::index_tree(&repo, &index)?;
+                if index_tree == old_tree {
+                    return Ok(None);
+                }
+                index_tree
             } else {
-                let baseline = repo.find_tree(old_tree)?;
-                create::worktree_tree(&repo, &baseline)?
+                let index_tree = create::index_tree(&repo, &index)?;
+                if index_tree != old_tree {
+                    index_tree
+                } else {
+                    let baseline = repo.find_tree(old_tree)?;
+                    create::worktree_tree(&repo, &baseline)?
+                }
             }
         }
     };
@@ -70,23 +80,85 @@ pub fn perform(
         return Ok(None);
     }
     commit.tree = tree;
-    Ok(rebase::perform(
-        &repo,
-        graph,
-        rebase::Edit::Replace { target: head, commit },
-        if review {
-            rebase::Signature::Remove
-        } else {
-            rebase::Signature::InvalidateExisting
-        },
-        if review {
-            rebase::Tree::LeaveAsIsAndMarkDescendants
-        } else {
-            rebase::Tree::LeaveAsIsAndMark
-        },
-    )?
-    .complete()?
-    .selected)
+    let edit = rebase::Edit::Replace { target: head, commit };
+    let signature = if review {
+        rebase::Signature::Remove
+    } else {
+        rebase::Signature::InvalidateExisting
+    };
+    let tree_mode = if review {
+        rebase::Tree::LeaveAsIsAndMarkDescendants
+    } else {
+        rebase::Tree::LeaveAsIsAndMark
+    };
+    let performed = match selected_path {
+        Some((path, _)) if kind == Kind::Amend => {
+            let mut paths = vec![path.path.clone()];
+            if path.kind == ChangeKind::Renamed
+                && let Some(source) = &path.source
+            {
+                paths.push(source.clone());
+            }
+            rebase::perform_resetting_index_paths(&repo, graph, edit, signature, tree_mode, paths)?
+        }
+        _ => rebase::perform(&repo, graph, edit, signature, tree_mode)?,
+    };
+    Ok(performed.complete()?.selected)
+}
+
+fn amend_path_tree(
+    repo: &gix::Repository,
+    commit_tree: ObjectId,
+    change: &PathChange,
+    index: &gix::index::File,
+) -> Result<ObjectId> {
+    match change.group {
+        crate::ChangeGroup::Staged => {
+            let index_tree = create::index_tree(repo, index)?;
+            apply_path_from_tree(repo, commit_tree, index_tree, change)
+        }
+        crate::ChangeGroup::Unstaged => {
+            let baseline = repo.find_tree(commit_tree)?;
+            create::worktree_tree_with_changes(
+                repo,
+                &baseline,
+                &crate::Changes {
+                    paths: vec![change.clone()],
+                    ..crate::Changes::default()
+                },
+            )
+        }
+        crate::ChangeGroup::Tree => anyhow::bail!("a tree change cannot be amended from the worktree"),
+    }
+}
+
+fn apply_path_from_tree(
+    repo: &gix::Repository,
+    commit_tree: ObjectId,
+    source_tree: ObjectId,
+    change: &PathChange,
+) -> Result<ObjectId> {
+    let mut editor = repo.find_tree(commit_tree)?.edit()?;
+    if change.kind == ChangeKind::Renamed
+        && let Some(source) = &change.source
+    {
+        editor.remove(source)?;
+    }
+    if change.kind == ChangeKind::Deleted {
+        editor.remove(&change.path)?;
+    } else {
+        let source = repo.find_tree(source_tree)?;
+        let entry = source
+            .lookup_entry(
+                change
+                    .path
+                    .split(|byte| *byte == b'/')
+                    .map(|component| BStr::new(component).to_owned()),
+            )?
+            .context("the selected path is absent from its source tree")?;
+        editor.upsert(&change.path, entry.mode().kind(), entry.object_id())?;
+    }
+    Ok(editor.write()?.detach())
 }
 
 fn spill_path_tree(
@@ -192,6 +264,145 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn amending_one_worktree_path_preserves_unrelated_staging() -> gix_testtools::Result {
+        for (group, expected) in [
+            (crate::ChangeGroup::Staged, b"staged\n".as_slice()),
+            (crate::ChangeGroup::Unstaged, b"unstaged\n".as_slice()),
+        ] {
+            let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+            std::fs::write(fixture.path().join("other"), "other\n")?;
+            git(fixture.path(), &["add", "other"])?;
+            let repo = open(fixture.path())?;
+            let graph = super::super::loaded_graph(&repo)?;
+            let selected = PathChange {
+                kind: ChangeKind::Modified,
+                group,
+                source: None,
+                path: "tracked".into(),
+                lines: None,
+            };
+            let new =
+                perform(repo, &graph, Kind::Amend, Some((&selected, None)))?.expect("the selected path changes HEAD");
+            assert_eq!(git(fixture.path(), &["show", &format!("{new}:tracked")])?, expected);
+            assert_eq!(
+                git(fixture.path(), &["diff", "--cached", "--name-only"])?,
+                b"other\n",
+                "an unrelated addition remains staged"
+            );
+            assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
+            let unstaged = git(fixture.path(), &["diff", "--name-only"])?;
+            if group == crate::ChangeGroup::Staged {
+                assert_eq!(unstaged, b"tracked\n", "the worktree-only delta remains");
+            } else {
+                assert!(unstaged.is_empty(), "the amended worktree version becomes clean");
+            }
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn scoped_amend_rolls_back_if_the_index_cannot_be_locked() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let index_before = std::fs::read(repo.index_path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let selected = PathChange {
+            kind: ChangeKind::Modified,
+            group: crate::ChangeGroup::Staged,
+            source: None,
+            path: "tracked".into(),
+            lines: None,
+        };
+        std::fs::write(fixture.path().join(".git/index.lock"), "locked")?;
+        let err =
+            perform(repo, &graph, Kind::Amend, Some((&selected, None))).expect_err("an index lock prevents the amend");
+        assert!(format!("{err:#}").contains("selected index paths"));
+        let repo = open(fixture.path())?;
+        assert_eq!(repo.head_id()?.detach(), old, "the rewritten ref is rolled back");
+        assert_eq!(
+            std::fs::read(repo.index_path())?,
+            index_before,
+            "the original index is restored"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn scoped_amend_synchronizes_changed_index_paths() -> gix_testtools::Result {
+        for kind in [
+            ChangeKind::Added,
+            ChangeKind::Deleted,
+            ChangeKind::Renamed,
+            ChangeKind::Copied,
+        ] {
+            let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+            git(
+                fixture.path(),
+                &["restore", "--source=HEAD", "--staged", "--worktree", "tracked"],
+            )?;
+            std::fs::write(fixture.path().join("other"), "other\n")?;
+            git(fixture.path(), &["add", "other"])?;
+            let (path, source) = match kind {
+                ChangeKind::Added => {
+                    std::fs::write(fixture.path().join("added"), "added\n")?;
+                    git(fixture.path(), &["add", "added"])?;
+                    ("added", None)
+                }
+                ChangeKind::Deleted => {
+                    std::fs::remove_file(fixture.path().join("tracked"))?;
+                    git(fixture.path(), &["add", "-u", "tracked"])?;
+                    ("tracked", None)
+                }
+                ChangeKind::Renamed => {
+                    git(fixture.path(), &["mv", "tracked", "renamed"])?;
+                    ("renamed", Some("tracked"))
+                }
+                ChangeKind::Copied => {
+                    std::fs::copy(fixture.path().join("tracked"), fixture.path().join("copied"))?;
+                    git(fixture.path(), &["add", "copied"])?;
+                    ("copied", Some("tracked"))
+                }
+                _ => unreachable!("the test lists only path-shape changes"),
+            };
+            let repo = open(fixture.path())?;
+            let graph = super::super::loaded_graph(&repo)?;
+            let selected = PathChange {
+                kind,
+                group: crate::ChangeGroup::Staged,
+                source: source.map(Into::into),
+                path: path.into(),
+                lines: None,
+            };
+            let new =
+                perform(repo, &graph, Kind::Amend, Some((&selected, None)))?.expect("the selected path changes HEAD");
+            let repo = open(fixture.path())?;
+            let tree = repo.find_commit(new)?.tree()?;
+            assert_eq!(
+                tree.lookup_entry([path])?.is_some(),
+                kind != ChangeKind::Deleted,
+                "the destination follows the selected change"
+            );
+            if kind == ChangeKind::Renamed
+                && let Some(source) = source
+            {
+                assert!(tree.lookup_entry([source])?.is_none(), "the renamed source is removed");
+            } else if kind == ChangeKind::Copied {
+                assert!(
+                    tree.lookup_entry(["tracked"])?.is_some(),
+                    "the copied source is retained"
+                );
+            }
+            assert_eq!(
+                git(fixture.path(), &["diff", "--cached", "--name-only"])?,
+                b"other\n",
+                "the unrelated addition remains staged"
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn spill_moves_the_tip_tree_change_to_the_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 3867c4617af..336d52310ce 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -7,7 +7,7 @@ use std::{
 use anyhow::{Context, Result};
 use gix::{
     ObjectId,
-    bstr::{BStr, BString},
+    bstr::{BStr, BString, ByteSlice},
     objs::Write,
     refs::{
         Category, Target,
@@ -177,6 +177,7 @@ struct Prepared {
     repo: gix::Repository,
     root: Option<ObjectId>,
     reset_index: bool,
+    reset_index_paths: Option<Vec<BString>>,
     skip_worktree_transitions: bool,
     selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
@@ -233,7 +234,18 @@ pub(crate) fn perform(
     signature: Signature,
     tree_mode: Tree,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new())
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None)
+}
+
+pub(super) fn perform_resetting_index_paths(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    paths: Vec<BString>,
+) -> Result<Perform> {
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), Some(paths))
 }
 
 pub(super) fn perform_deleting_refs(
@@ -244,7 +256,7 @@ pub(super) fn perform_deleting_refs(
     tree_mode: Tree,
     deletions: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, deletions)
+    perform_inner(repo, graph, edit, signature, tree_mode, deletions, None)
 }
 
 fn perform_inner(
@@ -254,6 +266,7 @@ fn perform_inner(
     signature: Signature,
     mut tree_mode: Tree,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
+    reset_index_paths: Option<Vec<BString>>,
 ) -> Result<Perform> {
     let mut repo = repo.clone();
     let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
@@ -423,6 +436,7 @@ fn perform_inner(
         repo,
         root,
         reset_index: if inserted { reset_index } else { marked },
+        reset_index_paths,
         skip_worktree_transitions: inserted
             || forked
             || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
@@ -560,6 +574,7 @@ pub(super) fn finish_review(
         repo,
         root: Some(review),
         reset_index: false,
+        reset_index_paths: None,
         skip_worktree_transitions: false,
         selected: Some(finished_review),
         rewritten,
@@ -749,6 +764,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         repo,
         root: Some(plan.base),
         reset_index: marked,
+        reset_index_paths: None,
         skip_worktree_transitions: false,
         selected,
         rewritten,
@@ -816,9 +832,9 @@ impl Prepared {
                 );
             }
         }
-        let index_resets = index_resets.unwrap_or_default();
-        for (index, reset) in index_resets.iter().enumerate() {
-            if let Err(mut err) = reset_index(&reset.workdir, reset.new) {
+        let mut index_resets = index_resets.unwrap_or_default();
+        for index in 0..index_resets.len() {
+            if let Err(mut err) = reset_index(&mut index_resets[index], self.reset_index_paths.as_deref()) {
                 for applied in index_resets[..=index].iter().rev() {
                     if let Err(restore) = std::fs::write(&applied.index, &applied.before) {
                         err = err.context(format!("index rollback failed: {restore}"));
@@ -891,12 +907,15 @@ fn index_resets(
         let Some(Some(new)) = rewritten.get(&old).copied() else {
             continue;
         };
-        if let Some(workdir) = worktree_repo.workdir().filter(|path| path.is_dir()) {
+        if let Some(workdir) = worktree_repo.workdir().filter(|path| path.is_dir()).map(PathBuf::from) {
             let index = worktree_repo.index_path();
+            let index_path = index.to_owned();
+            let before = std::fs::read(index).context("could not preserve an affected index")?;
             out.push(IndexReset {
-                workdir: workdir.to_owned(),
-                index: index.to_owned(),
-                before: std::fs::read(index).context("could not preserve an affected index")?,
+                repo: worktree_repo,
+                workdir,
+                index: index_path,
+                before,
                 new,
             });
         }
@@ -905,18 +924,22 @@ fn index_resets(
 }
 
 struct IndexReset {
+    repo: gix::Repository,
     workdir: PathBuf,
     index: PathBuf,
     before: Vec<u8>,
     new: ObjectId,
 }
 
-fn reset_index(workdir: &std::path::Path, id: ObjectId) -> Result<()> {
+fn reset_index(reset: &mut IndexReset, paths: Option<&[BString]>) -> Result<()> {
+    if let Some(paths) = paths {
+        return reset_index_paths(&reset.repo, reset.new, paths);
+    }
     let output = Command::new("git")
         .arg("-C")
-        .arg(workdir)
+        .arg(&reset.workdir)
         .args(["reset", "--mixed", "--quiet"])
-        .arg(id.to_string())
+        .arg(reset.new.to_string())
         .output()
         .context("could not update the index after inserting a commit")?;
     if output.status.success() {
@@ -926,6 +949,38 @@ fn reset_index(workdir: &std::path::Path, id: ObjectId) -> Result<()> {
     }
 }
 
+fn reset_index_paths(repo: &gix::Repository, id: ObjectId, paths: &[BString]) -> Result<()> {
+    let tree = repo.find_commit(id)?.tree()?;
+    let mut index = repo
+        .open_index()
+        .context("could not load the index to update selected paths")?;
+    for path in paths {
+        let previous = index
+            .entry_by_path(path.as_bstr())
+            .map(|entry| (entry.stat, entry.flags));
+        index.remove_entries(|_, candidate, _| candidate == path.as_bstr());
+        if let Some(entry) = tree.lookup_entry(
+            path.split(|byte| *byte == b'/')
+                .map(|component| BStr::new(component).to_owned()),
+        )? {
+            let (stat, flags) =
+                previous.unwrap_or((gix::index::entry::Stat::default(), gix::index::entry::Flags::empty()));
+            index.dangerously_push_entry(
+                stat,
+                entry.object_id(),
+                flags,
+                entry.mode().kind().into(),
+                path.as_bstr(),
+            );
+        }
+    }
+    index.sort_entries();
+    index.remove_tree();
+    index
+        .write(gix::index::write::Options::default())
+        .context("could not update selected index paths")
+}
+
 fn validate(
     repo: &gix::Repository,
     graph: &HistoryGraph,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8be1e3bb8f1..479ab5a8ab3 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1942,8 +1942,8 @@ fn event_loop(
                     } else {
                         "spill"
                     };
-                    let path = (kind == edit::head::Kind::Spill && app.changes_focus == Some(ChangePane::Tree))
-                        .then(|| {
+                    let path = match (kind, app.changes_focus) {
+                        (edit::head::Kind::Spill, Some(ChangePane::Tree)) => Some(
                             tree_changes
                                 .as_ref()
                                 .filter(|(target, _)| target.selected() == id)
@@ -1954,9 +1954,19 @@ fn event_loop(
                                         .cloned()
                                         .map(|path| (path, changes.parent.map(|parent| parent.id)))
                                 })
-                                .context("selected tree path is no longer available")
-                        })
-                        .transpose();
+                                .context("selected tree path is no longer available"),
+                        ),
+                        (edit::head::Kind::Amend, Some(ChangePane::Worktree)) => Some(
+                            worktree_changes
+                                .as_ref()
+                                .and_then(|(_, changes)| changes.paths.get(app.worktree_changes.selected))
+                                .cloned()
+                                .map(|path| (path, None))
+                                .context("selected worktree path is no longer available"),
+                        ),
+                        _ => None,
+                    }
+                    .transpose();
                     let result = history_graph
                         .as_ref()
                         .context("editing HEAD requires a completed history graph")
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 9a602ea742d..36287b4ca7b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -260,6 +260,13 @@ pub(crate) fn draw_with_worktree(
         .selected
         .and_then(|index| app.rows.get(index))
         .is_some_and(|row| row.is_review);
+    let worktree_path_amend = worktree_changes.is_some_and(|changes| {
+        !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
+            && changes
+                .paths
+                .get(app.worktree_changes.selected)
+                .is_some_and(|change| !selected_is_review || change.group == ChangeGroup::Staged)
+    });
     app.set_head_edit_availability(
         selected_is_head
             && worktree_changes.is_some_and(|changes| {
@@ -269,6 +276,7 @@ pub(crate) fn draw_with_worktree(
                     !changes.paths.is_empty()
                 }
             }),
+        selected_is_head && worktree_path_amend,
         selected_is_head && selected_is_review && worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
         selected_is_head
@@ -736,7 +744,7 @@ pub(crate) fn draw_with_worktree(
         ));
     }
     let mut edit_prefix_spans = Vec::new();
-    if app.changes_focus != Some(ChangePane::Worktree) {
+    if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
         let time_travel = if app.time_travel_shortcut_visible()
             && decorations
                 .values()
@@ -2845,7 +2853,7 @@ mod tests {
     }
 
     #[test]
-    fn focused_tree_path_offers_only_spill_in_the_main_edit_prefix() -> Result<(), Box<dyn std::error::Error>> {
+    fn focused_paths_offer_only_their_scoped_edit_in_the_main_prefix() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
         let mut app = App::new(4);
         app.extend_commits(vec![Commit {
@@ -2898,6 +2906,73 @@ mod tests {
             "tree focus keeps the scoped edit visible: {footer}"
         );
         assert!(!footer.contains("amend"), "tree paths cannot be amended");
+
+        app.changes_focus = Some(ChangePane::Worktree);
+        let mut worktree = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group: ChangeGroup::Unstaged,
+                source: None,
+                path: "file".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        app.set_head_edit_availability(true, true, false, false, false);
+        assert!(app.can_amend(), "the focused worktree path is amendable");
+        assert!(app.edit_expanded, "the edit prefix remains expanded");
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&worktree),
+            );
+        })?;
+        assert!(app.can_amend(), "drawing retains scoped amend availability");
+        assert!(app.edit_expanded, "drawing retains the expanded edit prefix");
+        let footer = rendered_line(&terminal, 7);
+        assert!(
+            footer.contains("edit (amend)"),
+            "worktree focus keeps the scoped edit visible: {footer}"
+        );
+        assert!(!footer.contains("spill"), "worktree paths cannot be spilled");
+
+        std::sync::Arc::make_mut(&mut app.rows[0]).is_review = true;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&worktree),
+            );
+        })?;
+        assert!(
+            !rendered_line(&terminal, 7).contains("amend"),
+            "a review cannot amend an unstaged selected path"
+        );
+        worktree.paths[0].group = ChangeGroup::Staged;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&worktree),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 7).contains("edit (amend)"),
+            "a review may amend its selected staged path"
+        );
         Ok(())
     }
 

From ff1f4bd96d53a08b86f91b7e865f9316e587428e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 16:41:50 +0200
Subject: [PATCH 089/282] feat: group tix view status behind question mark

Replace the history footer actions after the reference toggle with a compact
question-mark group. Expanding it reveals signature verification state,
alignment, commit-message visibility, and changes visibility while leaving
movement, focus, diff, and quit guidance at the top level.

Keep the existing action keys direct so this is only an information-density
change. The group remains open across those actions, closes on navigation or
unrelated commands, and is mutually exclusive with the view and edit groups.

Cover collapsed and expanded rendering, colored signature success and failure
states, prefix lifecycle, and direct question-mark input, and record the new
footer contract in the tix specification.
---
 gix-tix/spec.md    |  9 ++++--
 gix-tix/src/app.rs | 42 ++++++++++++++++++++++++
 gix-tix/src/lib.rs |  5 +++
 gix-tix/src/ui.rs  | 81 ++++++++++++++++++++++++++++------------------
 4 files changed, 103 insertions(+), 34 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 48f630b317f..58df0e9dc7a 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -156,6 +156,7 @@ without trading responsiveness for metadata that is not visible.
 | `Ctrl-u`/`Ctrl-d` | Move half a page. |
 | `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
+| `?` | Toggle the view-information key group. Its actions remain direct shortcuts. |
 | `[` | Toggle graph/metadata alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Toggle committer dates. |
@@ -175,14 +176,16 @@ without trading responsiveness for metadata that is not visible.
 | `t` | Time-travel to the selected commit, or return through its tix pin. |
 
 The display group remains open for consecutive display changes and closes on
-navigation or another recognized command. `[` and overlay controls remain direct
-shortcuts. The footer underlines the `v` in `view`; while active, `view (` contains
+navigation or another recognized command. The `?` group similarly remains open
+for signature verification, alignment, message, and changes actions, but these
+actions retain their direct shortcuts while the group is closed. The footer
+underlines the `v` in `view`; while active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
 actions follow before movement, panning, and diff navigation shortcuts. Copy
 immediately follows the edit group; the reference toggle immediately precedes
-signature verification when verification is available; quit is always last.
+the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
 possible; keys that cannot be expressed naturally in the label remain explicit.
 The Enter key is written as `<enter>` throughout.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 200b4059855..40ff1e4fc2e 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -289,6 +289,7 @@ pub(crate) enum Action {
     ToggleHidden,
     ToggleHistoryDisplay,
     ToggleEdit,
+    ToggleInformation,
     ToggleAlign,
     ToggleCommit,
     ToggleChanges,
@@ -425,6 +426,7 @@ pub(crate) struct App {
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) edit_expanded: bool,
+    pub(crate) information_expanded: bool,
     forget_confirmation: Option<ObjectId>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
@@ -515,6 +517,7 @@ impl App {
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             edit_expanded: false,
+            information_expanded: false,
             forget_confirmation: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
@@ -810,6 +813,16 @@ impl App {
         ) {
             self.edit_expanded = false;
         }
+        if !matches!(
+            &action,
+            Action::ToggleInformation
+                | Action::VerifySignatures
+                | Action::ToggleAlign
+                | Action::ToggleCommit
+                | Action::ToggleChanges
+        ) {
+            self.information_expanded = false;
+        }
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
@@ -901,6 +914,7 @@ impl App {
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
             Action::ToggleEdit => self.edit_expanded = !self.edit_expanded,
+            Action::ToggleInformation => self.information_expanded = !self.information_expanded,
             Action::CycleRefs => {
                 self.ref_mode = match self.ref_mode {
                     RefMode::All => RefMode::Default,
@@ -3398,6 +3412,34 @@ mod tests {
         assert!(!app.edit_expanded, "the prefix key toggles the group");
     }
 
+    #[test]
+    fn information_group_keeps_direct_actions_and_excludes_other_prefixes() {
+        let mut app = App::new(1);
+
+        app.update(Action::ToggleInformation);
+        assert!(app.information_expanded);
+        for action in [
+            Action::ToggleAlign,
+            Action::ToggleCommit,
+            Action::ToggleChanges,
+            Action::VerifySignatures,
+        ] {
+            app.update(action);
+            assert!(app.information_expanded, "information actions keep the group open");
+        }
+
+        app.update(Action::MoveDown);
+        assert!(!app.information_expanded, "navigation collapses the group");
+
+        app.update(Action::ToggleInformation);
+        app.update(Action::ToggleHistoryDisplay);
+        assert!(!app.information_expanded, "opening view closes information");
+        app.update(Action::ToggleInformation);
+        assert!(!app.history_display_expanded, "opening information closes view");
+        app.update(Action::ToggleEdit);
+        assert!(!app.information_expanded, "opening edit closes information");
+    }
+
     #[test]
     fn cycles_both_tree_and_hidden_changes() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 479ab5a8ab3..d200cb60ed6 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4085,6 +4085,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
+        KeyCode::Char('?') => Some(Action::ToggleInformation),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
@@ -5037,6 +5038,10 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE)),
             Some(Action::ToggleHistoryDisplay)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::SHIFT)),
+            Some(Action::ToggleInformation)
+        );
         for (key, expected) in [
             ('d', Action::ToggleDate),
             ('e', Action::ToggleEmail),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 36287b4ca7b..35e7768259b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -848,11 +848,6 @@ pub(crate) fn draw_with_worktree(
     if app.changes_focus.is_some() {
         footer_spans.push(Span::raw(" · q/Esc history"));
     }
-    footer_spans.extend([Span::raw(" · "), toggle("[ align", app.align_metadata)]);
-    footer_spans.push(Span::raw(" · "));
-    footer_spans.extend(shortcut("message", 'm', app.show_commit));
-    footer_spans.push(Span::raw(" · "));
-    footer_spans.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
     let mut view_prefix_spans = Vec::new();
     if app.history_display_expanded {
         view_prefix_spans.push(Span::raw(" · "));
@@ -912,18 +907,31 @@ pub(crate) fn draw_with_worktree(
     } else {
         ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     }
-    if app.signature_failures > 0 {
-        ordered.extend([
-            Span::raw(format!(" · s {} ", app.signature_failures)),
-            Span::styled("●", color(Color::LightRed)),
-        ]);
-    } else if has_verifiable_signatures {
-        ordered.extend([
-            Span::raw(" · s "),
-            Span::styled("●", color(Color::Rgb(255, 165, 0))),
-            Span::raw(" -> "),
-            Span::styled("●", color(Color::Green)),
-        ]);
+    ordered.push(Span::raw(" · "));
+    ordered.push(Span::styled("?", Style::default().add_modifier(Modifier::UNDERLINED)));
+    if app.information_expanded {
+        ordered.push(Span::raw(" ("));
+        if app.signature_failures > 0 {
+            ordered.extend([
+                Span::raw(format!("s {} ", app.signature_failures)),
+                Span::styled("●", color(Color::LightRed)),
+                Span::raw(" · "),
+            ]);
+        } else if has_verifiable_signatures {
+            ordered.extend([
+                Span::raw("s "),
+                Span::styled("●", color(Color::Rgb(255, 165, 0))),
+                Span::raw(" -> "),
+                Span::styled("●", color(Color::Green)),
+                Span::raw(" · "),
+            ]);
+        }
+        ordered.push(toggle("[ align", app.align_metadata));
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("message", 'm', app.show_commit));
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
+        ordered.push(Span::raw(")"));
     }
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
@@ -2537,8 +2545,7 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
-        let footer_text =
-            "#1 · view · edit · copy · refs · [ align · message · changes · ↑↓/jk move · h/l pan · <enter> diff · quit";
+        let footer_text = "#1 · view · edit · copy · refs · ? · ↑↓/jk move · h/l pan · <enter> diff · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2562,18 +2569,10 @@ mod tests {
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
-        let message = footer_text[..footer_text.find("message").expect("the message toggle is present")]
-            .chars()
-            .count();
-        for x in message..message + "message".len() {
-            expected[(x as u16, 1)].set_style(Style::default().add_modifier(Modifier::DIM));
-        }
         for (label, key) in [
             ("view", 'v'),
             ("edit", 'e'),
             ("copy", 'y'),
-            ("message", 'm'),
-            ("changes", 'c'),
             ("refs", 'r'),
             ("quit", 'q'),
         ] {
@@ -2587,6 +2586,10 @@ mod tests {
                 .modifier
                 .insert(Modifier::UNDERLINED);
         }
+        let information = footer_text[..footer_text.find('?').expect("the information prefix is present")]
+            .chars()
+            .count();
+        expected[(information as u16, 1)].modifier.insert(Modifier::UNDERLINED);
         terminal.backend().assert_buffer(&expected);
 
         let row = terminal.backend().buffer();
@@ -2829,7 +2832,7 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "view (date · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · copy · refs · [ align")),
+            footer.starts_with(&format!("0 commits · {view} · copy · refs · ?")),
             "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
@@ -2846,9 +2849,18 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · refs · [ align"),
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · refs · ?"),
             "the edit prefix follows the view prefix even when no action is available"
         );
+
+        app.edit_expanded = false;
+        app.information_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 1)
+                .starts_with("0 commits · view · edit · copy · refs · ? ([ align · message · changes)"),
+            "the information prefix contains the post-reference view actions"
+        );
         Ok(())
     }
 
@@ -3434,11 +3446,16 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("copy · refs · s ● -> ●"));
+        assert!(rendered_line(&terminal, 1).contains("copy · refs · ? ·"));
+        assert!(!rendered_line(&terminal, 1).contains("s ● -> ●"));
+
+        app.information_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_line(&terminal, 1).contains("copy · refs · ? (s ● -> ● · [ align"));
 
         app.finish_signature_verification(vec![(id, false)]);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("s 1 ●"));
+        assert!(rendered_line(&terminal, 1).contains("? (s 1 ● · [ align"));
         Ok(())
     }
 
@@ -3478,6 +3495,7 @@ mod tests {
         }]);
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
 
+        app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(footer_is_dim(&terminal, "message"), "the closed commit pane is dimmed");
 
@@ -3912,6 +3930,7 @@ mod tests {
         assert!(rendered_line(&terminal, 15).contains("<tab> switch"));
 
         app.changes_suppressed = true;
+        app.information_expanded = true;
         terminal.draw(|frame| {
             super::draw(
                 frame,

From 058bf4710dd5edfebcd6f72b86d7746dfed45091 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 17:14:02 +0200
Subject: [PATCH 090/282] fix: apply tix rebase updates from hidden anchors

Resolve rebase todo anchor titles from the freshly opened repository instead
of requiring the updated hidden tip to have a visible history row. This keeps
the `(updated-base)` heading available for tips outside the displayed view and
retains the same agent, notes, and subject markers as history titles.

Treat `base != onto` as an actionable unchanged todo, just like pending lazy
rebases. Rebase-update now applies when the user saves the generated document
without editing its picks, because moving the fork point is itself the edit.

Extend the update regression to use an unlisted, annotated hidden anchor, save
the todo unchanged, execute the plan, and assert that the first rewritten
commit is parented onto the new hidden tip. Update the tix specification to
record this behavior.
---
 gix-tix/spec.md          |   4 +-
 gix-tix/src/app.rs       |   4 --
 gix-tix/src/edit/todo.rs | 100 +++++++++++++++++++++++++++++----------
 gix-tix/src/history.rs   |   2 +-
 gix-tix/src/lib.rs       |  11 +----
 gix-tix/src/ui.rs        |  17 -------
 6 files changed, 81 insertions(+), 57 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 58df0e9dc7a..414d159e169 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -562,8 +562,8 @@ space first; changes blocks adapt within the remaining history width.
   direct `refs/worktree/tix/pins/*` ref, except the checked-out leaf. Concurrent
   ref edits win by making the transaction fail; the editor result is not rebuilt
   against a later graph snapshot. Leaving the document unchanged is a no-op unless
-  its scope contains pending commits; then the unchanged plan runs with the same
-  eager `@` ancestry and lazy-fork rules.
+  its scope contains pending commits or rebase-update selected a newer base; then
+  the unchanged plan runs with the same eager `@` ancestry and lazy-fork rules.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 40ff1e4fc2e..518c84f96c0 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1173,10 +1173,6 @@ impl App {
         self.hidden_branch_updates.get(&id).map(|(behind, _)| *behind)
     }
 
-    pub(crate) fn commit(&self, id: ObjectId) -> Option<&CommitRow> {
-        self.all_rows.get(&id).map(AsRef::as_ref)
-    }
-
     pub(crate) fn selected_tree_diff_target(&self) -> Option<TreeDiffTarget> {
         let id = self.selected.and_then(|index| self.rows.get(index))?.id;
         Some(match self.hidden_branch_targets.get(&id) {
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index c8ec942c9b5..cf1de798bdb 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1,7 +1,11 @@
 use std::collections::{HashMap, HashSet};
 
 use anyhow::{Context, Result};
-use gix::{ObjectId, bstr::BString, prelude::ObjectIdExt};
+use gix::{
+    ObjectId,
+    bstr::{BString, ByteSlice},
+    prelude::ObjectIdExt,
+};
 
 use super::rebase;
 
@@ -36,7 +40,7 @@ pub(crate) struct Prepared {
     marker_required: bool,
     checkout_allowed: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
-    pub has_pending: bool,
+    pub apply_unchanged: bool,
 }
 
 struct Section {
@@ -49,7 +53,6 @@ pub(crate) fn prepare(
     repo: &gix::Repository,
     base: ObjectId,
     onto: ObjectId,
-    anchor_title: &str,
     commits: &[Commit],
     head: Option<ObjectId>,
 ) -> Result<Prepared> {
@@ -64,6 +67,7 @@ pub(crate) fn prepare(
     let has_pending = commits.iter().try_fold(false, |pending, commit| {
         Ok::<_, anyhow::Error>(pending || rebase::has_marker(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
     })?;
+    let apply_unchanged = base != onto || has_pending;
 
     let mut children = HashMap::<ObjectId, Vec<ObjectId>>::new();
     let by_id: HashMap<_, _> = commits.iter().map(|commit| (commit.id, commit)).collect();
@@ -100,6 +104,7 @@ pub(crate) fn prepare(
     document.extend_from_slice(title.as_bytes());
     document.extend_from_slice(b"\n\n");
     let anchor_kind = if base == onto { "base" } else { "updated-base" };
+    let anchor_title = anchor_title(repo, onto)?;
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
             document.push(b'\n');
@@ -108,7 +113,7 @@ pub(crate) fn prepare(
             &mut document,
             repo,
             section.parent,
-            (section.parent == onto).then_some((anchor_kind, anchor_title)),
+            (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
         )?;
         for id in &section.commits {
             let commit = by_id[id];
@@ -119,7 +124,7 @@ pub(crate) fn prepare(
         }
     }
     if sections.is_empty() {
-        write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title)))?;
+        write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
     }
     document.extend_from_slice(HELP);
     Ok(Prepared {
@@ -130,10 +135,41 @@ pub(crate) fn prepare(
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
         expected_refs,
-        has_pending,
+        apply_unchanged,
     })
 }
 
+fn anchor_title(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+    let message = repo
+        .find_commit(id)
+        .context("could not load the rebase anchor")?
+        .message_raw()
+        .context("could not decode the rebase anchor message")?
+        .to_owned();
+    let mut notes = repo
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes for the rebase anchor")?;
+    let has_notes = !notes
+        .get(id)
+        .map_err(gix::Exn::into_error)
+        .context("could not load rebase anchor notes")?
+        .is_empty();
+    let mut out = String::new();
+    if crate::history::contains_agent_marker(&message) {
+        out.push_str("[A] ");
+    }
+    if has_notes {
+        out.push_str("[N] ");
+    }
+    out.push_str(
+        &gix::objs::commit::MessageRef::from_bytes(&message)
+            .summary()
+            .to_str_lossy(),
+    );
+    Ok(out)
+}
+
 fn write_fork_heading(
     out: &mut Vec<u8>,
     repo: &gix::Repository,
@@ -369,15 +405,12 @@ mod tests {
     fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, "[A] base * title", &commits, Some(tip))?;
-        assert!(!prepared.has_pending);
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        assert!(!prepared.apply_unchanged);
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
-        assert!(document.contains(&format!(
-            "## fork {} (base) \\[A\\] base \\* title",
-            base.to_hex_with_len(7)
-        )));
+        assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
         assert!(middle < tip, "the todo grows from the base towards the tip");
@@ -423,9 +456,9 @@ mod tests {
                 info: "middle".into(),
             },
         ];
-        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
         assert!(
-            prepared.has_pending,
+            prepared.apply_unchanged,
             "pending commits make an unchanged todo actionable"
         );
         let document = prepared.document.clone();
@@ -466,9 +499,9 @@ mod tests {
             },
         );
 
-        let prepared = prepare(&repo, base, base, "base title", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.contains(&format!("## fork {} (base) base title", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
         assert!(
             document.contains(&format!("## fork {}\n", middle.to_hex_with_len(7))),
             "a fork within the editable tree has no external-anchor annotation"
@@ -481,13 +514,21 @@ mod tests {
     #[test]
     fn update_todo_roots_the_stack_at_the_hidden_tip_and_labels_only_that_heading() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
-        let (base, _middle, tip, commits) = commits(&repo)?;
+        let (base, middle, tip, commits) = commits(&repo)?;
         let mut commit = repo.find_commit(base)?.decode()?.into_owned()?;
         commit.parents = [base].into_iter().collect();
-        commit.message = "updated hidden base".into();
+        commit.message = "updated * hidden base\n\n<!-- agent -->".into();
         let onto = repo.write_object(&commit)?.detach();
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add("refs/notes/commits", onto, "anchor note")
+            .map_err(gix::Exn::into_error)?;
 
-        let prepared = prepare(&repo, base, onto, "[A] updated * hidden base", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, onto, &commits, Some(tip))?;
+        assert!(
+            prepared.apply_unchanged,
+            "moving the base makes an unchanged editor document actionable"
+        );
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(
             document.contains(&format!(
@@ -499,7 +540,7 @@ mod tests {
         );
         assert!(
             document.contains(&format!(
-                "## fork {} (updated-base) \\[A\\] updated \\* hidden base",
+                "## fork {} (updated-base) \\[A\\] \\[N\\] updated \\* hidden base",
                 onto.to_hex_with_len(7)
             )),
             "the unfamiliar fork target carries its escaped UI title"
@@ -513,6 +554,17 @@ mod tests {
         let plan = parse(&repo, prepared, document.as_bytes())?;
         assert_eq!(plan.base, onto);
         assert_eq!(plan.steps[0].parent, rebase::PlanParent::Existing(onto));
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+        let rewritten_middle = outcome.map(middle).expect("the middle commit is retained");
+        assert_eq!(
+            repo.find_commit(rewritten_middle)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(onto),
+            "saving the unchanged update todo rebases the stack onto the hidden tip"
+        );
         Ok(())
     }
 
@@ -520,7 +572,7 @@ mod tests {
     fn parses_reordering_forks_empty_commits_and_a_moved_checkout() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
             "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -531,7 +583,7 @@ mod tests {
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("two checkout markers are invalid");
         assert!(format!("{err:#}").contains("more than one @"));
 
-        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
             "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -551,12 +603,12 @@ mod tests {
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, "base", &commits, Some(tip))?;
+        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
         let edited = format!("## fork {}\n", base.to_hex_with_len(7));
         let err = parse(&repo, prepared, edited.as_bytes()).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
 
-        let prepared = prepare(&repo, base, base, "base", &commits, None)?;
+        let prepared = prepare(&repo, base, base, &commits, None)?;
         let plan = parse(&repo, prepared, edited.as_bytes())?;
         assert!(
             plan.steps.is_empty(),
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 6bb17599435..906fdc3d81f 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1466,7 +1466,7 @@ fn decode_metadata<'a>(
     })
 }
 
-fn contains_agent_marker(message: &[u8]) -> bool {
+pub(crate) fn contains_agent_marker(message: &[u8]) -> bool {
     [b"--- agent".as_slice(), b"<!-- agent -->".as_slice()]
         .iter()
         .any(|marker| message.windows(marker.len()).any(|window| window == *marker))
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d200cb60ed6..c5ece81ff5f 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2042,11 +2042,6 @@ fn event_loop(
                         .as_ref()
                         .context("rebasing requires a completed history graph")
                         .and_then(|graph| {
-                            let anchor_title = ui::todo_title(
-                                &app,
-                                app.commit(onto)
-                                    .context("the rebase anchor disappeared from the view")?,
-                            );
                             rebase_history(
                                 terminal,
                                 &repository_path,
@@ -2054,7 +2049,6 @@ fn event_loop(
                                 graph,
                                 base,
                                 onto,
-                                anchor_title,
                                 todo_commits?,
                                 head,
                                 enhanced_keyboard,
@@ -3204,7 +3198,6 @@ fn rebase_history(
     graph: &HistoryGraph,
     base: gix::ObjectId,
     onto: gix::ObjectId,
-    anchor_title: String,
     commits: Vec<edit::todo::Commit>,
     head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
@@ -3213,7 +3206,7 @@ fn rebase_history(
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;
         repository.object_cache_size(None);
-        edit::todo::prepare(&repository, base, onto, &anchor_title, &commits, head)?
+        edit::todo::prepare(&repository, base, onto, &commits, head)?
     };
     let edited = edit::edit_document(
         terminal,
@@ -3224,7 +3217,7 @@ fn rebase_history(
     )?;
     let edited = match edited {
         Some(edited) => edited,
-        None if prepared.has_pending => prepared.document.clone(),
+        None if prepared.apply_unchanged => prepared.document.clone(),
         None => return Ok(None),
     };
     let mut repository =
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 35e7768259b..7f88b30e6c4 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1830,18 +1830,6 @@ pub(crate) fn todo_metadata(
     out
 }
 
-pub(crate) fn todo_title(app: &App, row: &CommitRow) -> String {
-    let mut out = String::new();
-    if row.has_agent_marker {
-        out.push_str("[A] ");
-    }
-    if !app.notes(row.id).is_empty() {
-        out.push_str("[N] ");
-    }
-    out.push_str(&app.title(row).to_str_lossy());
-    out
-}
-
 fn author_label(
     author: &crate::app::Author,
     mailmap: &gix::mailmap::Snapshot,
@@ -4523,11 +4511,6 @@ mod tests {
             row.contains("[A] [N] subject"),
             "agent and note markers precede the title"
         );
-        assert_eq!(
-            todo_title(&app, &app.rows[0]),
-            "[A] [N] subject",
-            "rebase headings reuse the title exactly as shown in history"
-        );
         assert_eq!(history.backend().buffer()[(agent_x, 0)].fg, Color::LightMagenta);
         assert_eq!(history.backend().buffer()[(note_x, 0)].fg, Color::LightMagenta);
 

From 2ccc88a38c1deb5f679f0853e43e3635a9dd82a8 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 17:51:59 +0200
Subject: [PATCH 091/282] change!: promote tix head edits to top-level commands

Replace the standalone manual parser with one Clap-derived command platform. Keep bare tix launching the history view, expose amend and spill directly, retain literal command-name revisions after --, and document that the experimental interface does not carry compatibility shims.
---
 Cargo.lock             |   1 +
 gix-tix/AGENTS.md      |   6 ++
 gix-tix/Cargo.toml     |   1 +
 gix-tix/spec.md        |   2 +-
 gix-tix/src/command.rs | 156 +++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs     |  26 +------
 gix-tix/src/main.rs    | 122 +-------------------------------
 7 files changed, 168 insertions(+), 146 deletions(-)
 create mode 100644 gix-tix/src/command.rs

diff --git a/Cargo.lock b/Cargo.lock
index 75e9dc3f559..91215fd2ac3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2595,6 +2595,7 @@ name = "gix-tix"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "clap",
  "crossterm",
  "directories",
  "gix",
diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 769df6a9b68..e28dbabbe68 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -1,5 +1,11 @@
 # gix-tix invariants
 
+## Compatibility
+
+- Tix is experimental. Implement requested command-line and behavioral changes
+  without compatibility aliases or migration shims unless compatibility is
+  explicitly requested.
+
 ## Behavioral specification
 
 - Keep `spec.md` synchronized with every user-visible, lifecycle, performance,
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index ea9e0e23481..a5a5bd5dff2 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -24,6 +24,7 @@ sha256 = ["gix/sha256"]
 
 [dependencies]
 anyhow = "1.0.98"
+clap = { version = "4.5.42", features = ["derive"] }
 crossterm = { version = "0.29.0", features = ["osc52"] }
 directories = "6.0.0"
 gix = { version = "^0.86.0", path = "../gix", default-features = false, features = ["blob-diff", "mailmap", "merge", "notes", "parallel", "revision", "command", "sha1", "status"] }
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 414d159e169..ec27c66bb0f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -404,7 +404,7 @@ space first; changes blocks adapt within the remaining history width.
   worktree changes when the index already matches `HEAD`. `e s` spills that
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
-  unavailable and report a no-op through `tix edit amend|spill`.
+  unavailable and report a no-op through `tix amend|spill`.
 - With a path selected in the focused tree-changes block, the main `e` prefix
   offers `spill` and `e s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
new file mode 100644
index 00000000000..0b153b39cef
--- /dev/null
+++ b/gix-tix/src/command.rs
@@ -0,0 +1,156 @@
+use std::ffi::OsString;
+
+use anyhow::{Context, Result};
+use clap::Parser;
+
+/// Arguments and commands shared by the standalone `tix` binary and `gix tix`.
+#[derive(Debug, clap::Args)]
+#[command(args_conflicts_with_subcommands = true)]
+pub struct Platform {
+    /// Print help.
+    #[arg(long, action = clap::ArgAction::HelpLong)]
+    help: Option<bool>,
+    /// Exit once all commits and graph lanes have been computed.
+    #[arg(long)]
+    quit_on_finish: bool,
+    /// Add all worktree HEADs as visible traversal tips.
+    #[arg(short = 'w', long)]
+    worktrees: bool,
+    /// Hide this revision and every commit reachable from it.
+    #[arg(short = 'h', long, value_name = "REVSPEC")]
+    hide: Vec<OsString>,
+    #[command(subcommand)]
+    command: Option<Command>,
+    /// Revisions whose reachable commits should be shown, or HEAD if omitted.
+    revisions: Vec<OsString>,
+}
+
+#[derive(Debug, clap::Subcommand)]
+enum Command {
+    /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
+    Amend,
+    /// Move the changes introduced by HEAD into the worktree.
+    Spill,
+}
+
+#[derive(Debug, clap::Parser)]
+#[command(
+    name = "tix",
+    about = "Browse commits or edit the checked-out commit",
+    disable_help_flag = true
+)]
+struct Cli {
+    #[command(flatten)]
+    platform: Platform,
+}
+
+/// Parse the standalone `tix` command line.
+pub fn parse() -> Platform {
+    Cli::parse_from(gix::env::args_os()).platform
+}
+
+impl Platform {
+    /// Run this command against `repository`.
+    pub fn run(self, repository: gix::ThreadSafeRepository) -> Result<()> {
+        let Platform {
+            help: _,
+            quit_on_finish,
+            worktrees,
+            hide,
+            command,
+            revisions,
+        } = self;
+        let Some(command) = command else {
+            return crate::run(
+                repository,
+                revisions,
+                crate::Options {
+                    quit_on_finish,
+                    hide,
+                    worktrees,
+                },
+            );
+        };
+
+        let (kind, verb) = match command {
+            Command::Amend => (crate::edit::head::Kind::Amend, "amend"),
+            Command::Spill => (crate::edit::head::Kind::Spill, "spill"),
+        };
+        let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
+        let repository = repository.to_thread_local();
+        let graph = crate::edit::loaded_graph(&repository)?;
+        match crate::edit::head::perform(repository, &graph, kind, None)? {
+            Some(id) => println!("{}", id.to_hex_with_len(7)),
+            None => println!("nothing to {verb}"),
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use clap::{CommandFactory, error::ErrorKind};
+
+    use super::*;
+
+    #[test]
+    fn clap_definition_is_valid() {
+        Cli::command().debug_assert();
+    }
+
+    #[test]
+    fn parses_tui_options_and_top_level_commands() {
+        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-w", "-h", "main", "--hide", "tag", "topic"])
+            .expect("TUI arguments parse");
+        assert!(cli.platform.quit_on_finish);
+        assert!(cli.platform.worktrees);
+        assert_eq!(cli.platform.hide, ["main", "tag"], "hide options append");
+        assert_eq!(
+            cli.platform.revisions,
+            ["topic"],
+            "positional revisions remain visible tips"
+        );
+        assert!(cli.platform.command.is_none(), "omitting a command launches the TUI");
+
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "amend"])
+                .expect("amend parses")
+                .platform
+                .command,
+            Some(Command::Amend)
+        ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "spill"])
+                .expect("spill parses")
+                .platform
+                .command,
+            Some(Command::Spill)
+        ));
+    }
+
+    #[test]
+    fn preserves_hide_and_help_semantics() {
+        assert_eq!(
+            Cli::try_parse_from(["tix", "--help"])
+                .expect_err("long help exits through clap")
+                .kind(),
+            ErrorKind::DisplayHelp
+        );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "-h"])
+                .expect_err("hide requires a value")
+                .kind(),
+            ErrorKind::InvalidValue
+        );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "amend", "topic"])
+                .expect_err("commands reject TUI arguments")
+                .kind(),
+            ErrorKind::UnknownArgument
+        );
+
+        let cli = Cli::try_parse_from(["tix", "--", "amend"]).expect("-- makes amend a revision");
+        assert!(cli.platform.command.is_none());
+        assert_eq!(cli.platform.revisions, ["amend"]);
+    }
+}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c5ece81ff5f..a822d317c2f 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4,6 +4,7 @@
 
 mod animation;
 mod app;
+pub mod command;
 mod edit;
 mod history;
 mod logging;
@@ -741,31 +742,6 @@ pub struct Options {
     pub worktrees: bool,
 }
 
-/// An edit applied to the commit checked out by the current worktree.
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum HeadEdit {
-    /// Add staged changes, or worktree changes when nothing is staged, to `HEAD`.
-    Amend,
-    /// Move the changes introduced by `HEAD` into the worktree.
-    Spill,
-}
-
-/// Apply `edit` to the current worktree's `HEAD` without starting the terminal UI.
-pub fn edit_head(repository: gix::ThreadSafeRepository, edit: HeadEdit) -> Result<Option<gix::ObjectId>> {
-    let _log_guard = logging::init().context("could not initialize tix diagnostics")?;
-    let repository = repository.to_thread_local();
-    let graph = edit::loaded_graph(&repository)?;
-    edit::head::perform(
-        repository,
-        &graph,
-        match edit {
-            HeadEdit::Amend => edit::head::Kind::Amend,
-            HeadEdit::Spill => edit::head::Kind::Spill,
-        },
-        None,
-    )
-}
-
 fn detect_commit_pane_background() -> Option<(u8, u8, u8)> {
     let mut options = terminal_colorsaurus::QueryOptions::default();
     options.timeout = THEME_QUERY_TIMEOUT;
diff --git a/gix-tix/src/main.rs b/gix-tix/src/main.rs
index 942d159e7d7..96bbe72c74a 100644
--- a/gix-tix/src/main.rs
+++ b/gix-tix/src/main.rs
@@ -1,129 +1,11 @@
 #![forbid(unsafe_code)]
 
-use std::ffi::OsString;
-
 use anyhow::{Context, Result};
 
 fn main() -> Result<()> {
-    let mut args = gix::env::args_os().skip(1).peekable();
-    let edit = if args.peek().is_some_and(|arg| arg == "edit") {
-        args.next();
-        let edit = match args.next().as_deref() {
-            Some(value) if value == "amend" => gix_tix::HeadEdit::Amend,
-            Some(value) if value == "spill" => gix_tix::HeadEdit::Spill,
-            _ => anyhow::bail!("usage: tix edit amend|spill"),
-        };
-        if args.next().is_some() {
-            anyhow::bail!("usage: tix edit amend|spill");
-        }
-        Some(edit)
-    } else {
-        None
-    };
-    let (revisions, options, help) = arguments(args)?;
-    if help {
-        println!(
-            "Usage: tix [--quit-on-finish] [-w|--worktrees] [-h|--hide REVSPEC] [REVISION]...\n       tix edit amend|spill\n\nBrowse commits reachable from HEAD or edit its checked-out commit.\n\nOptions:\n  -h, --hide REVSPEC  Hide this revision and all commits reachable from it\n  -w, --worktrees     Add all worktree HEADs as visible tips\n      --help          Print help"
-        );
-        return Ok(());
-    }
-
+    let command = gix_tix::command::parse();
     let current_dir = std::env::current_dir().context("could not determine current directory")?;
     let repository = gix::ThreadSafeRepository::discover_with_environment_overrides(current_dir)
         .context("could not discover repository")?;
-    if let Some(edit) = edit {
-        match gix_tix::edit_head(repository, edit)? {
-            Some(id) => println!("{}", id.to_hex_with_len(7)),
-            None => println!(
-                "nothing to {}",
-                if edit == gix_tix::HeadEdit::Amend {
-                    "amend"
-                } else {
-                    "spill"
-                }
-            ),
-        }
-        return Ok(());
-    }
-    gix_tix::run(repository, revisions, options)
-}
-
-fn arguments(mut args: impl Iterator<Item = OsString>) -> Result<(Vec<OsString>, gix_tix::Options, bool)> {
-    let mut revisions = Vec::new();
-    let mut options = gix_tix::Options::default();
-    let mut help = false;
-    while let Some(arg) = args.next() {
-        if arg == "--help" {
-            help = true;
-            break;
-        } else if arg == "--quit-on-finish" {
-            options.quit_on_finish = true;
-        } else if arg == "-w" || arg == "--worktrees" {
-            options.worktrees = true;
-        } else if arg == "-h" || arg == "--hide" {
-            let revision = args.next().context("-h/--hide requires a revision to hide")?;
-            if revision == "--help" {
-                help = true;
-                break;
-            }
-            if revision == "-h"
-                || revision == "--hide"
-                || revision == "-w"
-                || revision == "--worktrees"
-                || revision == "--quit-on-finish"
-            {
-                anyhow::bail!("-h/--hide requires a revision to hide");
-            }
-            options.hide.push(revision);
-        } else {
-            revisions.push(arg);
-        }
-    }
-    Ok((revisions, options, help))
-}
-
-#[cfg(test)]
-mod tests {
-    use std::ffi::OsString;
-
-    use super::*;
-
-    #[test]
-    fn separates_options_from_revisions() -> Result<()> {
-        let (revisions, options, help) = arguments(
-            [
-                "--quit-on-finish",
-                "-w",
-                "-h",
-                "main",
-                "--hide",
-                "tag",
-                "topic",
-                "--help",
-            ]
-            .into_iter()
-            .map(OsString::from),
-        )?;
-
-        assert!(options.quit_on_finish);
-        assert!(options.worktrees);
-        assert_eq!(options.hide, ["main", "tag"], "both hide options are retained");
-        assert_eq!(revisions, ["topic"], "only positional revisions remain");
-        assert!(help, "--help remains available without claiming -h");
-        assert!(
-            arguments(["-h"].into_iter().map(OsString::from)).is_err(),
-            "a missing hidden revision is rejected"
-        );
-        for args in [["--help", "-h"], ["-h", "--help"]] {
-            assert!(
-                arguments(args.into_iter().map(OsString::from))?.2,
-                "--help wins regardless of its position"
-            );
-        }
-        assert!(
-            arguments(["--hide", "--worktrees"].into_iter().map(OsString::from)).is_err(),
-            "worktree options cannot be consumed as hidden revisions"
-        );
-        Ok(())
-    }
+    command.run(repository)
 }

From b971ddbc45dbd19ea5a2423dfdf30aba2d060a66 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 17:52:34 +0200
Subject: [PATCH 092/282] feat: delegate tix commands through gix-tix

Embed the complete gix-tix Clap platform in the plumbing command instead of maintaining a second parser and dispatcher. This keeps standalone and plumbing invocations aligned, adds worktree-tip parity, and makes amend and spill available through gix tix without duplicating their execution logic.
---
 src/plumbing/main.rs        | 37 +++++++++++++++----------------------
 src/plumbing/options/mod.rs | 14 +-------------
 2 files changed, 16 insertions(+), 35 deletions(-)

diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index 8640da5da3b..5b83fb7e4cf 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -158,20 +158,7 @@ pub fn main() -> Result<()> {
 
     match cmd {
         #[cfg(feature = "tix")]
-        Subcommands::Tix {
-            help: _,
-            quit_on_finish,
-            hide,
-            revisions,
-        } => gix_tix::run(
-            repository(Mode::Lenient)?.into_sync(),
-            revisions,
-            gix_tix::Options {
-                quit_on_finish,
-                hide,
-                ..Default::default()
-            },
-        ),
+        Subcommands::Tix(command) => command.run(repository(Mode::Lenient)?.into_sync()),
         Subcommands::Env => prepare_and_run(
             "env",
             trace,
@@ -1859,18 +1846,24 @@ mod tests {
         for name in ["tix", "tui", "interactive", "i"] {
             let args = Args::try_parse_from(["gix", name]).expect("the command or alias parses");
             assert!(
-                matches!(args.cmd, Subcommands::Tix { .. }),
+                matches!(args.cmd, Subcommands::Tix(_)),
                 "{name} routes to the tix command"
             );
         }
 
-        let args = Args::try_parse_from(["gix", "tix", "-h", "main", "--hide", "tag", "topic"])
-            .expect("hide options and a visible revision parse");
-        let Subcommands::Tix { hide, revisions, .. } = args.cmd else {
-            panic!("tix arguments route to tix")
-        };
-        assert_eq!(hide, ["main", "tag"], "short and long hide options append");
-        assert_eq!(revisions, ["topic"], "positional revisions remain visible tips");
+        for arguments in [
+            vec!["gix", "tix", "-h", "main", "--hide", "tag", "-w", "topic"],
+            vec!["gix", "tix", "amend"],
+            vec!["gix", "tix", "spill"],
+        ] {
+            assert!(
+                matches!(
+                    Args::try_parse_from(arguments).expect("shared tix arguments parse").cmd,
+                    Subcommands::Tix(_)
+                ),
+                "the complete tix command is delegated"
+            );
+        }
         assert_eq!(
             Args::try_parse_from(["gix", "tix", "--screen", "half"])
                 .expect_err("screen selection is no longer supported")
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
index 7bfe8608d64..d860b2cd1d0 100644
--- a/src/plumbing/options/mod.rs
+++ b/src/plumbing/options/mod.rs
@@ -171,19 +171,7 @@ pub enum Subcommands {
         visible_alias = "i",
         disable_help_flag = true
     )]
-    Tix {
-        /// Print help.
-        #[clap(long, action = clap::ArgAction::HelpLong)]
-        help: Option<bool>,
-        /// Exit once all commits and graph lanes have been computed.
-        #[clap(long)]
-        quit_on_finish: bool,
-        /// Hide this revision and every commit reachable from it.
-        #[clap(short = 'h', long, value_name = "REVSPEC")]
-        hide: Vec<std::ffi::OsString>,
-        /// Revisions whose reachable commits should be shown, or HEAD if omitted.
-        revisions: Vec<std::ffi::OsString>,
-    },
+    Tix(gix_tix::command::Platform),
     Worktree(worktree::Platform),
     /// Subcommands that need no Git repository to run.
     #[clap(subcommand)]

From 46422066a1c32256fe9aa53dc0881a2a8eee6078 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 18:01:22 +0200
Subject: [PATCH 093/282] fix: scope tix command edits to the visible history

Build the amend and spill graph from the same default HEAD, pin, and review tips as the history view. Keep the all-reference graph for rebase primitives that intentionally rewrite multiple mutable lines, while preventing unrelated descendant merges from blocking HEAD-only command edits.
---
 gix-tix/spec.md         |  3 ++
 gix-tix/src/command.rs  |  2 +-
 gix-tix/src/edit/mod.rs | 84 ++++++++++++++++++++++++++++++++---------
 3 files changed, 71 insertions(+), 18 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ec27c66bb0f..9bd7b947c9c 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -405,6 +405,9 @@ space first; changes blocks adapt within the remaining history width.
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
   unavailable and report a no-op through `tix amend|spill`.
+- Command-line edits use the same default HEAD, applicable pin, and review tips
+  as the history view. Unrelated refs do not broaden their descendant rewrite
+  scope, while mutable refs pointing into that scope are still retargeted.
 - With a path selected in the focused tree-changes block, the main `e` prefix
   offers `spill` and `e s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 0b153b39cef..ad23ef6f787 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -78,7 +78,7 @@ impl Platform {
         };
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         let repository = repository.to_thread_local();
-        let graph = crate::edit::loaded_graph(&repository)?;
+        let graph = crate::edit::loaded_view_graph(&repository)?;
         match crate::edit::head::perform(repository, &graph, kind, None)? {
             Some(id) => println!("{}", id.to_hex_with_len(7)),
             None => println!("nothing to {verb}"),
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index b7a45e40026..a812c38f52b 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -3,14 +3,9 @@ use std::{ffi::OsStr, io::Write, process::Command};
 use anyhow::{Context, Result};
 
 pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::HistoryGraph> {
-    use std::sync::atomic::AtomicBool;
-
     if repo.head_id().is_err() {
         return Ok(crate::history::HistoryGraph::default());
     }
-    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
-        crate::history::Authors::default(),
-    ));
     let mut revisions = Vec::new();
     for reference in repo.references()?.all()? {
         let reference = reference.map_err(|err| anyhow::anyhow!("could not read reference: {err}"))?;
@@ -33,10 +28,23 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
     if repo.head().is_ok_and(|head| head.referent_name().is_none()) {
         revisions.push("HEAD".into());
     }
+    load_graph(repo, &revisions)
+}
+
+pub(super) fn loaded_view_graph(repo: &gix::Repository) -> Result<crate::history::HistoryGraph> {
+    load_graph(repo, &[])
+}
+
+fn load_graph(repo: &gix::Repository, revisions: &[std::ffi::OsString]) -> Result<crate::history::HistoryGraph> {
+    use std::sync::atomic::AtomicBool;
+
+    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+        crate::history::Authors::default(),
+    ));
     let mut graph = None;
     crate::history::load(
         repo,
-        &revisions,
+        revisions,
         &[],
         false,
         &authors,
@@ -103,27 +111,69 @@ pub(crate) fn edit_document(
 
 #[cfg(test)]
 mod tests {
-    use std::process::Command;
+    use std::{path::Path, process::Command};
 
     use super::*;
 
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into());
+        }
+        Ok(output.stdout)
+    }
+
     #[test]
     fn edit_graph_ignores_refs_that_do_not_point_to_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
-        let output = Command::new("git")
-            .arg("-C")
-            .arg(fixture.path())
-            .args(["update-ref", "refs/cache/tree", "HEAD^{tree}"])
-            .output()?;
-        assert!(
-            output.status.success(),
-            "the non-commit ref is created: {}",
-            String::from_utf8_lossy(&output.stderr)
-        );
+        git(fixture.path(), &["update-ref", "refs/cache/tree", "HEAD^{tree}"])?;
         let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
         let head = repo.head_id()?.detach();
         let graph = loaded_graph(&repo)?;
         assert!(graph.parents_of(head).is_some(), "HEAD remains part of the edit graph");
         Ok(())
     }
+
+    #[test]
+    fn edit_graph_excludes_unrelated_descendant_merges() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let path = fixture.path();
+        let head = String::from_utf8(git(path, &["rev-parse", "HEAD"])?)?;
+        let head = head.trim();
+        let tree = String::from_utf8(git(path, &["rev-parse", "HEAD^{tree}"])?)?;
+        let tree = tree.trim();
+        let pinned = String::from_utf8(git(path, &["commit-tree", tree, "-p", head, "-m", "pinned tip"])?)?;
+        let pinned = pinned.trim();
+        let merge = String::from_utf8(git(
+            path,
+            &["commit-tree", tree, "-p", head, "-p", pinned, "-m", "unrelated merge"],
+        )?)?;
+        let merge = merge.trim();
+        git(path, &["update-ref", "refs/worktree/tix/pins/keep", pinned])?;
+        git(path, &["update-ref", "refs/heads/unrelated", merge])?;
+        git(path, &["checkout", "--detach", head])?;
+
+        let repo = gix::open_opts(path, gix::open::Options::isolated())?;
+        let graph = loaded_view_graph(&repo)?;
+        let pinned = gix::ObjectId::from_hex(pinned.as_bytes())?;
+        let merge = gix::ObjectId::from_hex(merge.as_bytes())?;
+        assert!(
+            graph.parents_of(pinned).is_some(),
+            "the applicable pin remains in edit scope"
+        );
+        assert!(
+            graph.parents_of(merge).is_none(),
+            "an unrelated ref does not add its descendant merge to edit scope"
+        );
+        assert!(
+            head::perform(repo, &graph, head::Kind::Amend, None)?.is_some(),
+            "amending HEAD succeeds despite the unrelated merge"
+        );
+        Ok(())
+    }
 }

From 5fa7a1c45dbe76d82a69176559b9cdccd91f03af Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 19:56:26 +0200
Subject: [PATCH 094/282] fix: materialize only selected pending ancestry in
 tix

Treat empty signature fields as pending without attaching an original-parent marker to commits whose tree and parent are already final.

Replay and sign only the ancestry through the time-travel destination while reparenting later descendants as lazy commits. Cover signed spill traversal, conflict handling, and the resulting history state.
---
 gix-tix/spec.md                               |  39 ++--
 gix-tix/src/edit/head.rs                      |   5 +-
 gix-tix/src/edit/rebase.rs                    |  89 +++++----
 gix-tix/src/edit/review.rs                    |   4 +-
 gix-tix/src/edit/reword.rs                    |  20 +-
 ...sts__accepted-pending-rebase-conflict.snap |   7 +-
 gix-tix/src/edit/split.rs                     |  14 +-
 gix-tix/src/edit/time_travel.rs               | 173 ++++++++++++++----
 gix-tix/src/edit/todo.rs                      |   2 +-
 gix-tix/src/history.rs                        |  10 +-
 10 files changed, 249 insertions(+), 114 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 9bd7b947c9c..73997e68be4 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -343,8 +343,9 @@ space first; changes blocks adapt within the remaining history width.
   regardless of value.
 - An unchanged editor document is a no-op. Otherwise tix recreates the commit,
   signs it when commit-signing configuration is enabled, and rewrites every
-  linear descendant with unchanged trees and corrected parentage. The rewritten
-  region is marked with `tix-rebase-parent` for cherry-pick replay during time travel.
+  linear descendant with unchanged trees and corrected parentage. Descendants
+  whose parent changed retain that original parent for cherry-pick replay during
+  time travel; the edited commit itself needs no replay marker.
   Mutable refs follow every rewritten commit; tags and remote-tracking refs remain
   unchanged.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
@@ -425,18 +426,23 @@ space first; changes blocks adapt within the remaining history width.
   changes abort without writing objects or changing refs, the index, or files.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
-  the upper commit receives the edited message. Both commits are marked for the
-  same lazy signature-aware rebase used by amend and spill.
+  the upper commit receives the edited message. Their final trees and ancestry
+  need no replay marker; rewritten descendants use the same lazy rebase as amend
+  and spill.
 - All three operations leave worktree files untouched and cheaply rewrite linear
   descendants with their trees unchanged. Whole-commit edits reset the affected
   worktree's index to the rewritten commit; selected-path amend synchronizes only
-  its destination and renamed source. Rewritten commits carry `tix-rebase-parent`, invalidate
-  existing signatures, retain the original parent needed for later replay, and
-  use a bright-cyan commit marker.
+  its destination and renamed source. A directly amended or spilled commit already
+  has its final tree and unchanged parent, so an empty signature field alone keeps
+  a formerly signed commit pending. Reparented descendants additionally carry
+  `tix-rebase-parent`, retaining the original parent needed for later replay. Both
+  pending forms use a bright-cyan commit marker.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
-- Time travel from either endpoint of a pending region completes the marked
-  rebase with cherry-picking and configured signing before checkout. A conflict
+- Time travel toward a pending destination cherry-picks and signs only the pending
+  ancestry through that destination. Pending descendants are reparented but remain
+  lazy and unsigned; traveling toward a non-pending ancestor leaves the entire
+  pending region untouched. A conflict
   retains the exact merge tree, conflict stages, prepared commits, and in-memory
   objects without changing the repository. The conflicting row shows a blinking
   red `C`; `<enter>` persists the prepared rebase, leaves later descendants lazy,
@@ -507,16 +513,17 @@ space first; changes blocks adapt within the remaining history width.
   preparation—including cherry-pick conflict detection—finishes before objects
   become reachable through refs.
 - `Tree::LeaveAsIs` rewrites parentage without changing trees;
-  `LeaveAsIsAndMark` additionally writes the original first parent to
-  `tix-rebase-parent`, using the repository hash kind's null ID for a root; and
-  `CherryPick` transplants each tree delta. User edits use `LeaveAsIsAndMark`;
-  time travel is the only eager `CherryPick` caller. A successful repeated rebase
-  clears the marker. On conflict, `tix-rebase-parent` identifies the original
-  base and later descendants remain marked instead of being cherry-picked.
+  `LeaveAsIsAndMark` writes the original first parent to `tix-rebase-parent` only
+  when later replay needs it; and `CherryPick` transplants each tree delta. User
+  edits use `LeaveAsIsAndMark`; time travel is the only eager `CherryPick` caller.
+  A successful repeated rebase clears the marker through its checkout destination.
+  On conflict, `tix-rebase-parent` identifies the original base and later descendants
+  remain marked instead of being cherry-picked.
 - `Signature::RedoIfNeeded` signs every rewritten commit when signing is
   configured and otherwise removes stale signature headers.
   `InvalidateExisting` empties existing signature values when signing is
-  configured, or removes them when it is not. Automatically rebased descendants
+  configured, making the empty field a pending-signature signal, or removes them
+  when it is not. Automatically rebased descendants
   retain their author and receive one configured current committer identity and
   timestamp for the operation.
 - All mutable local refs pointing anywhere into the rewritten set are changed in
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index f07f543775b..8e0a0af1d7a 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -260,7 +260,10 @@ mod tests {
             "the index follows the amended commit"
         );
         let commit = open(fixture.path())?.find_commit(new)?.decode()?.into_owned()?;
-        assert!(super::super::rebase::has_marker(&commit), "lazy descendants are marked");
+        assert!(
+            !super::super::rebase::is_pending(&commit),
+            "an unsigned amended commit already has its final tree and parent"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 336d52310ce..dce05c001f6 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -60,6 +60,7 @@ pub(crate) enum Edit {
     },
     Repeat {
         base: ObjectId,
+        checkout: ObjectId,
     },
 }
 
@@ -264,11 +265,15 @@ fn perform_inner(
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
-    mut tree_mode: Tree,
+    tree_mode: Tree,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     reset_index_paths: Option<Vec<BString>>,
 ) -> Result<Perform> {
     let mut repo = repo.clone();
+    let repeat_checkout = match &edit {
+        Edit::Repeat { checkout, .. } => Some(*checkout),
+        _ => None,
+    };
     let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
         Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, false, None),
         Edit::Insert {
@@ -288,11 +293,8 @@ fn perform_inner(
             false,
             Some(upper),
         ),
-        Edit::Repeat { base } => (Some(base), None, false, false, false, false, true, None),
+        Edit::Repeat { base, .. } => (Some(base), None, false, false, false, false, true, None),
     };
-    if repeat {
-        tree_mode = Tree::CherryPick;
-    }
 
     let affected = match root.filter(|_| !forked) {
         Some(root) => graph
@@ -319,7 +321,7 @@ fn perform_inner(
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        marker(&mut commit, inserted && tree_mode == Tree::LeaveAsIsAndMark, root);
+        marker(&mut commit, false, None);
         let id = write_commit(&repo, commit, signature, signing.clone())?;
         selected = Some(id);
         if inserted {
@@ -373,17 +375,27 @@ fn perform_inner(
             commit.committer = committer.clone();
         }
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
-        let original_parents = recorded_parent.flatten().into_iter().collect::<Vec<_>>();
+        let original_parents =
+            recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
+        let eager =
+            repeat && repeat_checkout.is_some_and(|checkout| graph.is_ancestor(old_id, checkout)) && conflict.is_none();
+        let commit_tree_mode = if repeat {
+            if eager {
+                Tree::CherryPick
+            } else {
+                Tree::LeaveAsIsAndMark
+            }
+        } else if conflict.is_some() {
+            Tree::LeaveAsIsAndMark
+        } else {
+            tree_mode
+        };
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
             if !repeat { &old_parents } else { &original_parents },
             &new_parents,
-            if conflict.is_some() {
-                Tree::LeaveAsIsAndMark
-            } else {
-                tree_mode
-            },
+            commit_tree_mode,
         )?;
         let mut new_conflict = None;
         commit.tree = match rewritten_tree {
@@ -394,20 +406,23 @@ fn perform_inner(
             }
         };
         commit.parents = new_parents.into_iter().collect();
-        let pending = tree_mode == Tree::LeaveAsIsAndMark
-            || (tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
-            || conflict.is_some();
+        let pending = commit_tree_mode == Tree::LeaveAsIsAndMark
+            || (commit_tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
+            || conflict.is_some()
+            || new_conflict.is_some();
         marker(
             &mut commit,
-            pending,
+            pending && (repeat || Some(old_id) != root),
             recorded_parent.flatten().or_else(|| old_parents.first().copied()),
         );
         let is_conflicting_commit = new_conflict.is_some();
         let new_id = write_commit(
             &repo,
             commit,
-            if conflict.is_some() || is_conflicting_commit {
+            if conflict.is_some() || is_conflicting_commit || (repeat && !eager) {
                 Signature::InvalidateExisting
+            } else if repeat {
+                Signature::RedoIfNeeded
             } else {
                 signature
             },
@@ -420,7 +435,7 @@ fn perform_inner(
         if Some(old_id) == root {
             if let Some(mut upper) = split_upper.take() {
                 upper.parents = [new_id].into_iter().collect();
-                marker(&mut upper, true, Some(new_id));
+                marker(&mut upper, false, None);
                 let upper_id = write_commit(&repo, upper, Signature::RedoIfNeeded, signing.clone())?;
                 rewritten.insert(old_id, Some(upper_id));
                 selected = Some(upper_id);
@@ -996,17 +1011,17 @@ fn validate(
         }
         if repeat {
             let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
-            if !has_marker(&commit) {
-                anyhow::bail!("all repeated rebase commits must carry the pending marker");
+            if !is_pending(&commit) {
+                anyhow::bail!("all repeated rebase commits must be pending");
             }
         }
     }
     if repeat
         && let Some(base) = affected.first()
         && let Some(parent) = graph.parents_of(*base).and_then(|parents| parents.first().copied())
-        && has_marker(&repo.find_commit(parent)?.decode()?.into_owned()?)
+        && is_pending(&repo.find_commit(parent)?.decode()?.into_owned()?)
     {
-        anyhow::bail!("the parent of a repeated rebase must not carry the pending marker");
+        anyhow::bail!("the parent of a repeated rebase must not be pending");
     }
     Ok(())
 }
@@ -1128,6 +1143,14 @@ pub(super) fn has_marker(commit: &gix::objs::Commit) -> bool {
         .any(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
 }
 
+pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
+    has_marker(commit)
+        || commit
+            .extra_headers
+            .iter()
+            .any(|(name, value)| is_signature(name) && value.is_empty())
+}
+
 fn write_commit(
     repo: &gix::Repository,
     mut commit: gix::objs::Commit,
@@ -1540,7 +1563,7 @@ mod tests {
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
         commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~2")?)?.tree_id()?.detach();
-        let marked = perform(
+        perform(
             &repo,
             &graph,
             Edit::Replace { target: middle, commit },
@@ -1552,10 +1575,14 @@ mod tests {
         .expect("marking rewrites the selected commit");
 
         let graph = super::super::loaded_graph(&repo)?;
+        let tip = repo.head_id()?.detach();
         perform(
             &repo,
             &graph,
-            Edit::Repeat { base: marked },
+            Edit::Repeat {
+                base: tip,
+                checkout: tip,
+            },
             Signature::RedoIfNeeded,
             Tree::CherryPick,
         )?
@@ -1580,7 +1607,7 @@ mod tests {
     }
 
     #[test]
-    fn pending_roots_use_a_null_parent() -> gix_testtools::Result {
+    fn authoritative_replacements_do_not_record_an_original_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
@@ -1595,14 +1622,12 @@ mod tests {
         )?
         .complete()?
         .selected
-        .expect("the pending replacement selects its rewritten root");
+        .expect("the replacement selects its rewritten root");
         let commit = repo.find_commit(marked)?.decode()?.into_owned()?;
-        assert!(has_marker(&commit));
-        assert_eq!(marked_parent(&commit)?, None);
-        assert!(commit.extra_headers.iter().any(|(name, value)| {
-            name.as_slice() == ORIGINAL_PARENT
-                && ObjectId::from_hex(value).is_ok_and(|id| id == ObjectId::null(repo.object_hash()))
-        }));
+        assert!(
+            !has_marker(&commit),
+            "the replacement tree and unchanged parent need no later cherry-pick"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index ff4c06d7585..d681a135489 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -100,7 +100,7 @@ pub(crate) fn start(
             .with_context(|| format!("could not find {label}"))?
             .decode()?
             .into_owned()?;
-        if super::rebase::has_marker(&commit) {
+        if super::rebase::is_pending(&commit) {
             anyhow::bail!("{label} has a pending rebase");
         }
     }
@@ -189,7 +189,7 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
     let delete_refs = resources(&repo, review_ref.clone())?;
     for (label, id) in [("reviewed commit", tip), ("review base", base)] {
         let endpoint = repo.find_commit(id)?.decode()?.into_owned()?;
-        if super::rebase::has_marker(&endpoint) {
+        if super::rebase::is_pending(&endpoint) {
             anyhow::bail!("{label} has a pending rebase");
         }
     }
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 95a73a0360f..b72ba278ef6 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -312,7 +312,7 @@ mod tests {
     }
 
     #[test]
-    fn marks_the_reworded_commit_and_its_linear_descendants_for_lazy_replay() -> gix_testtools::Result {
+    fn marks_only_reworded_descendants_for_lazy_replay() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repository = gix::open_opts(
             fixture.path(),
@@ -324,12 +324,14 @@ mod tests {
         let graph = super::super::loaded_graph(&repository)?;
         let new_middle = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
         let new_tip = repository.head_id()?.detach();
-        for id in [new_middle, new_tip] {
-            assert!(
-                rebase::has_marker(&repository.find_commit(id)?.decode()?.into_owned()?),
-                "every rewritten commit is marked for lazy replay"
-            );
-        }
+        assert!(
+            !rebase::is_pending(&repository.find_commit(new_middle)?.decode()?.into_owned()?),
+            "the reworded commit already has its final tree, parent, and signature"
+        );
+        assert!(
+            rebase::has_marker(&repository.find_commit(new_tip)?.decode()?.into_owned()?),
+            "the reparented descendant retains its original parent for lazy replay"
+        );
         Ok(())
     }
 
@@ -380,8 +382,8 @@ mod tests {
         );
         assert_eq!(decoded.author()?.name, b"New Author".as_bstr());
         assert!(
-            rebase::has_marker(&decoded.into_owned()?),
-            "the reword is marked for lazy replay"
+            !rebase::is_pending(&decoded.into_owned()?),
+            "a signed reword with unchanged ancestry needs no later replay"
         );
         assert!(
             commit
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index 32e3de038a1..ffed3abf164 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -6,7 +6,7 @@ HEAD detached C1
 
 [refs]
 refs/heads/main = C2
-refs/worktree/tix/pins/06e842b0 = -> refs/heads/main
+refs/worktree/tix/pins/9dabf957 = -> refs/heads/main
 
 [commits]
 C0
@@ -21,6 +21,7 @@ C1
   parent C0
   author author <author@example.com> 946684800 +0000
   committer author <author@example.com> 978307200 +0000
+  tix-rebase-parent 48dd951f6d729bd3debd703cc9a8392702bf9124
 
   tip
 
@@ -43,12 +44,12 @@ tree = conflicted
 100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
 
 [objects]
-C2 = 06e842b07e26ecf14fa3af38af83313e25b407dc
 T0 = 0f42ecffc297189265600788215c8b0055d862b8
-C1 = 54b039307b71caeb5f620a9ad9c965d10db1f598
 T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T2 = 6f2762b571ef9a93001cc607058818aa5d0d055c
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
+C1 = ba56ce9b9d8d6244d2515a069c41954891242837
 C0 = c0b811a58f27425263a4276fe881de38736a9446
+C2 = caa38dc6da6e13db4a27c3d73fa15562f2890764
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
 B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 5f844f22000..3615776448d 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -189,12 +189,14 @@ mod tests {
             repository.find_commit(upper)?.message_raw()?,
             b"upper\n\nreason\n".as_bstr()
         );
-        assert!(super::super::rebase::has_marker(
-            &repository.find_commit(source)?.decode()?.into_owned()?
-        ));
-        assert!(super::super::rebase::has_marker(
-            &repository.find_commit(upper)?.decode()?.into_owned()?
-        ));
+        assert!(
+            !super::super::rebase::is_pending(&repository.find_commit(source)?.decode()?.into_owned()?),
+            "the unsigned source already has its final tree and parent"
+        );
+        assert!(
+            !super::super::rebase::is_pending(&repository.find_commit(upper)?.decode()?.into_owned()?),
+            "the new upper commit already has its final tree and parent"
+        );
         assert_eq!(git(fixture.path(), &["status", "--short"])?, b"");
         for name in ["refs/heads/main", "refs/patches/split"] {
             assert_eq!(
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 035f02d0784..8e2323d1516 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -198,11 +198,14 @@ pub(crate) fn perform(
     }
     let mut completed_graph = None;
     let mut review_roots = review_roots.to_vec();
-    while let Some(base) = pending_base(&repository, head_id, selected)? {
+    while let Some(base) = pending_base(&repository, selected)? {
         let outcome = super::rebase::perform(
             &repository,
             completed_graph.as_ref().unwrap_or(graph),
-            super::rebase::Edit::Repeat { base },
+            super::rebase::Edit::Repeat {
+                base,
+                checkout: selected,
+            },
             super::rebase::Signature::RedoIfNeeded,
             super::rebase::Tree::CherryPick,
         )?;
@@ -468,30 +471,25 @@ fn append_notice(notice: &mut Option<String>, addition: String) {
     }
 }
 
-fn pending_base(repository: &gix::Repository, head: ObjectId, selected: ObjectId) -> Result<Option<ObjectId>> {
-    for endpoint in [head, selected] {
-        let mut current = endpoint;
-        let mut base = None;
-        loop {
-            let commit = repository
-                .find_commit(current)
-                .context("could not inspect a time-travel endpoint for a pending rebase")?
-                .decode()?
-                .into_owned()?;
-            if !super::rebase::has_marker(&commit) {
-                break;
-            }
-            base = Some(current);
-            let Some(parent) = commit.parents.first().copied() else {
-                break;
-            };
-            current = parent;
-        }
-        if base.is_some() {
-            return Ok(base);
+fn pending_base(repository: &gix::Repository, selected: ObjectId) -> Result<Option<ObjectId>> {
+    let mut current = selected;
+    let mut base = None;
+    loop {
+        let commit = repository
+            .find_commit(current)
+            .context("could not inspect a time-travel destination for a pending rebase")?
+            .decode()?
+            .into_owned()?;
+        if !super::rebase::is_pending(&commit) {
+            break;
         }
+        base = Some(current);
+        let Some(parent) = commit.parents.first().copied() else {
+            break;
+        };
+        current = parent;
     }
-    Ok(None)
+    Ok(base)
 }
 
 fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
@@ -1093,9 +1091,14 @@ mod tests {
         .complete()?;
         let graph = super::super::loaded_graph(&repository)?;
         let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let tip = repository.find_reference("refs/heads/main")?.id().detach();
+        drop(repository);
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let graph = super::super::loaded_graph(&repository)?;
         let before = gix_testtools::repository::snapshot(fixture.path())?;
 
-        let Perform::Conflict(conflict) = perform(&repository_path, false, root, &graph, &[], &[], false)? else {
+        let Perform::Conflict(conflict) = perform(&repository_path, false, tip, &graph, &[], &[], false)? else {
             return Err("the pending rebase should suspend at its conflicting cherry-pick".into());
         };
         assert_eq!(
@@ -1149,34 +1152,124 @@ mod tests {
     }
 
     #[test]
-    fn travelling_completes_the_whole_pending_rebase() -> gix_testtools::Result {
+    fn time_travel_materializes_only_the_pending_path_to_the_destination() -> gix_testtools::Result {
+        if !gix_testtools::signature::program_available("ssh-keygen") {
+            return Ok(());
+        }
+        let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let allowed_signers = gix_testtools::signature::fixture("ssh-allowed-signers");
+        git(fixture.path(), &["config", "commit.gpgSign", "true"])?;
+        git(fixture.path(), &["config", "gpg.format", "ssh"])?;
+        git(
+            fixture.path(),
+            &["config", "user.signingKey", key.to_string_lossy().as_ref()],
+        )?;
+        git(
+            fixture.path(),
+            &[
+                "config",
+                "gpg.ssh.allowedSignersFile",
+                allowed_signers.to_string_lossy().as_ref(),
+            ],
+        )?;
         let repository = crate::open_test_repository(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         let root = repository.rev_parse_single("HEAD~2")?.detach();
-        let graph = loaded_graph(&repository, &[])?;
+        let graph = super::super::loaded_graph(&repository)?;
         let commit = repository.find_commit(middle)?.decode()?.into_owned()?;
-        super::super::rebase::perform(
+        let signed_middle = super::super::rebase::perform(
             &repository,
             &graph,
             super::super::rebase::Edit::Replace { target: middle, commit },
-            super::super::rebase::Signature::InvalidateExisting,
-            super::super::rebase::Tree::LeaveAsIsAndMark,
+            super::super::rebase::Signature::RedoIfNeeded,
+            super::super::rebase::Tree::LeaveAsIs,
+        )?
+        .complete()?
+        .selected
+        .expect("signing rewrites the middle commit");
+        drop(repository);
+        git(
+            fixture.path(),
+            &["checkout", "-q", "--detach", &signed_middle.to_string()],
         )?;
-        let graph = loaded_graph(&repository, &[])?;
+
+        let repository = crate::open_test_repository(fixture.path())?;
+        let graph = super::super::loaded_graph(&repository)?;
+        let pending_middle =
+            super::super::head::perform(repository.clone(), &graph, super::super::head::Kind::Spill, None)?
+                .expect("spilling changes the middle commit");
+        let pending_tip = repository.find_reference("refs/heads/main")?.id().detach();
+        let middle_commit = repository.find_commit(pending_middle)?.decode()?.into_owned()?;
+        let tip_commit = repository.find_commit(pending_tip)?.decode()?.into_owned()?;
+        assert!(super::super::rebase::is_pending(&middle_commit));
+        assert!(
+            !super::super::rebase::has_marker(&middle_commit),
+            "the authoritative spilled tree needs no original-parent marker"
+        );
+        let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+            history::Authors::default(),
+        ));
+        assert_eq!(
+            history::load_metadata(&repository, pending_middle, &authors)?
+                .0
+                .signature,
+            crate::app::SignatureState::PendingRebase,
+            "an empty signature keeps the authoritative commit visibly pending"
+        );
+        assert!(super::super::rebase::has_marker(&tip_commit));
+        drop(repository);
+
+        let repository = crate::open_test_repository(fixture.path())?;
+        let graph = super::super::loaded_graph(&repository)?;
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), pending_tip);
+        assert!(super::super::rebase::is_pending(
+            &repository.find_commit(pending_middle)?.decode()?.into_owned()?
+        ));
+        assert!(super::super::rebase::is_pending(
+            &repository.find_commit(pending_tip)?.decode()?.into_owned()?
+        ));
+        let graph = super::super::loaded_graph(&repository)?;
+        drop(repository);
+
+        perform(&repository_path, false, pending_middle, &graph, &[], &[], false)?.complete()?;
 
         let repository = crate::open_test_repository(fixture.path())?;
-        let mut current = Some(repository.find_reference("refs/heads/main")?.id().detach());
-        while let Some(id) = current {
-            let commit = repository.find_commit(id)?.decode()?.into_owned()?;
-            assert!(
-                !super::super::rebase::has_marker(&commit),
-                "time travel clears the complete pending region"
-            );
-            current = commit.parents.first().copied();
-        }
+        let materialized_middle = repository.head_id()?.detach();
+        let still_pending_tip = repository.find_reference("refs/heads/main")?.id().detach();
+        assert_ne!(materialized_middle, pending_middle);
+        assert_ne!(still_pending_tip, pending_tip);
+        let middle_commit = repository.find_commit(materialized_middle)?;
+        assert!(!super::super::rebase::is_pending(
+            &middle_commit.decode()?.into_owned()?
+        ));
+        assert!(
+            middle_commit
+                .verify_signature()?
+                .expect("returning to the spilled commit adds its configured signature")
+                .is_valid()
+        );
+        drop(middle_commit);
+        let tip_commit = repository.find_commit(still_pending_tip)?.decode()?.into_owned()?;
+        assert_eq!(tip_commit.parents.first().copied(), Some(materialized_middle));
+        assert!(super::super::rebase::is_pending(&tip_commit));
+        assert!(super::super::rebase::has_marker(&tip_commit));
+        let graph = super::super::loaded_graph(&repository)?;
+        drop(repository);
+
+        perform(&repository_path, false, still_pending_tip, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let tip_commit = repository.find_commit(repository.head_id()?)?;
+        assert!(!super::super::rebase::is_pending(&tip_commit.decode()?.into_owned()?));
+        assert!(
+            tip_commit
+                .verify_signature()?
+                .expect("travelling to the remaining descendant signs it")
+                .is_valid()
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index cf1de798bdb..6de63f07161 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -65,7 +65,7 @@ pub(crate) fn prepare(
     let marker_required = head.is_some_and(|head| scope_set.contains(&head));
     let expected_refs = rebase::capture_refs(repo, &scope)?;
     let has_pending = commits.iter().try_fold(false, |pending, commit| {
-        Ok::<_, anyhow::Error>(pending || rebase::has_marker(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
+        Ok::<_, anyhow::Error>(pending || rebase::is_pending(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
     })?;
     let apply_unchanged = base != onto || has_pending;
 
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 906fdc3d81f..74f69dbd16e 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1447,10 +1447,12 @@ fn decode_metadata<'a>(
             {
                 is_review = true;
             }
-            Token::ExtraHeader((name, _))
-                if (name == "gpgsig" || name == "gpgsig-sha256") && signature != SignatureState::PendingRebase =>
-            {
-                signature = SignatureState::Unverified;
+            Token::ExtraHeader((name, value)) if name == "gpgsig" || name == "gpgsig-sha256" => {
+                if value.is_empty() {
+                    signature = SignatureState::PendingRebase;
+                } else if signature != SignatureState::PendingRebase {
+                    signature = SignatureState::Unverified;
+                }
             }
             _ => {}
         }

From 11a3c851badb060a16126335d0ff969ff0e1a1ea Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 20:03:27 +0200
Subject: [PATCH 095/282] feat: add a top-level tix split command

Run the existing transactional split flow outside the TUI by sharing its commit-message editor routine. The command amends worktree changes into HEAD and creates the new top commit from staged index changes.

Document the behavior in clap short help and the tix specification, with command-level coverage for the resulting trees and clean index.
---
 gix-tix/spec.md         |  2 +
 gix-tix/src/command.rs  | 97 ++++++++++++++++++++++++++++++++++++++---
 gix-tix/src/edit/mod.rs | 36 +++++++++------
 3 files changed, 115 insertions(+), 20 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 73997e68be4..8dba6219731 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -424,6 +424,8 @@ space first; changes blocks adapt within the remaining history width.
   commit from the staged delta using the standard Markdown editor buffer. Both
   deltas are three-way applied in memory before the editor opens, so overlapping
   changes abort without writing objects or changing refs, the index, or files.
+- `tix split` performs the same split at `HEAD`: worktree changes are amended
+  into the source commit and staged index changes become the new commit on top.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Their final trees and ancestry
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index ad23ef6f787..3abab0e8f8c 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -31,6 +31,8 @@ enum Command {
     Amend,
     /// Move the changes introduced by HEAD into the worktree.
     Spill,
+    /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
+    Split,
 }
 
 #[derive(Debug, clap::Parser)]
@@ -72,23 +74,56 @@ impl Platform {
             );
         };
 
-        let (kind, verb) = match command {
-            Command::Amend => (crate::edit::head::Kind::Amend, "amend"),
-            Command::Spill => (crate::edit::head::Kind::Spill, "spill"),
-        };
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         let repository = repository.to_thread_local();
         let graph = crate::edit::loaded_view_graph(&repository)?;
-        match crate::edit::head::perform(repository, &graph, kind, None)? {
-            Some(id) => println!("{}", id.to_hex_with_len(7)),
-            None => println!("nothing to {verb}"),
+        match command {
+            Command::Amend => edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?,
+            Command::Spill => edit_head(repository, &graph, crate::edit::head::Kind::Spill, "spill")?,
+            Command::Split => split(repository, &graph)?,
         }
         Ok(())
     }
 }
 
+fn edit_head(
+    repository: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    kind: crate::edit::head::Kind,
+    verb: &str,
+) -> Result<()> {
+    match crate::edit::head::perform(repository, graph, kind, None)? {
+        Some(id) => println!("{}", id.to_hex_with_len(7)),
+        None => println!("nothing to {verb}"),
+    }
+    Ok(())
+}
+
+fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<()> {
+    let repository_path = repository.git_dir().to_owned();
+    let bare = repository.is_bare();
+    let prepared = crate::edit::split::prepare(repository)?;
+    let Some(edited) = crate::edit::edit_document_without_terminal(
+        &prepared.editor,
+        &prepared.document,
+        &format!("tix-split-{}.md", std::process::id()),
+    )?
+    else {
+        println!("no split performed: no input was provided");
+        return Ok(());
+    };
+    let mut repository = crate::open_repository(&repository_path, bare, false)
+        .context("could not reopen repository after editing split")?;
+    repository.object_cache_size(None);
+    let id = crate::edit::split::apply(repository, graph, prepared, &edited)?;
+    println!("{}", id.to_hex_with_len(7));
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
+    use std::{path::Path, process::Command as ProcessCommand};
+
     use clap::{CommandFactory, error::ErrorKind};
 
     use super::*;
@@ -126,6 +161,20 @@ mod tests {
                 .command,
             Some(Command::Spill)
         ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "split"])
+                .expect("split parses")
+                .platform
+                .command,
+            Some(Command::Split)
+        ));
+        assert!(
+            Cli::command()
+                .render_help()
+                .to_string()
+                .contains("Split HEAD by amending worktree changes into it and committing staged index changes on top"),
+            "short help explains how split distributes index and worktree changes"
+        );
     }
 
     #[test]
@@ -153,4 +202,38 @@ mod tests {
         assert!(cli.platform.command.is_none());
         assert_eq!(cli.platform.revisions, ["amend"]);
     }
+
+    #[test]
+    fn split_command_uses_the_index_for_the_new_commit_and_worktree_for_its_parent() -> gix_testtools::Result {
+        fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+            let output = ProcessCommand::new("git").arg("-C").arg(path).args(args).output()?;
+            if !output.status.success() {
+                return Err(format!(
+                    "git {} failed: {}",
+                    args.join(" "),
+                    String::from_utf8_lossy(&output.stderr)
+                )
+                .into());
+            }
+            Ok(output.stdout)
+        }
+
+        let fixture = gix_testtools::scripted_fixture_writable("split_commit.sh")?;
+        let repository = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=sed -i.bak -e 's/^what$/split/'".to_owned(),
+                "commit.gpgSign=false".to_owned(),
+            ]),
+        )?;
+        let graph = crate::edit::loaded_view_graph(&repository)?;
+        split(repository, &graph)?;
+
+        assert_eq!(git(fixture.path(), &["log", "-1", "--format=%s"])?, b"split\n");
+        assert_eq!(git(fixture.path(), &["show", "HEAD^:unstaged"])?, b"worktree\n");
+        assert_eq!(git(fixture.path(), &["show", "HEAD:staged"])?, b"staged\n");
+        assert!(git(fixture.path(), &["diff", "--exit-code"])?.is_empty());
+        assert!(git(fixture.path(), &["diff", "--cached", "--exit-code"])?.is_empty());
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index a812c38f52b..cdf16e78469 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -76,6 +76,19 @@ pub(crate) fn edit_document(
     document: &[u8],
     filename: &str,
     enhanced_keyboard: bool,
+) -> Result<Option<Vec<u8>>> {
+    if editor == ":" {
+        return edit_document_without_terminal(editor, document, filename);
+    }
+    crate::with_suspended_terminal(terminal, enhanced_keyboard, || {
+        edit_document_without_terminal(editor, document, filename)
+    })
+}
+
+pub(crate) fn edit_document_without_terminal(
+    editor: &OsStr,
+    document: &[u8],
+    filename: &str,
 ) -> Result<Option<Vec<u8>>> {
     let mut tempfile = gix::tempfile::writable_at(
         std::env::temp_dir().join(filename),
@@ -91,19 +104,16 @@ pub(crate) fn edit_document(
     tempfile.flush().context("could not flush commit message file")?;
 
     if editor != ":" {
-        crate::with_suspended_terminal(terminal, enhanced_keyboard, || {
-            let status = Command::from(
-                gix::command::prepare(editor)
-                    .arg(tempfile.path())
-                    .command_may_be_shell_script_allow_manual_argument_splitting(),
-            )
-            .status()
-            .with_context(|| format!("could not launch Git editor {}", editor.to_string_lossy()))?;
-            if !status.success() {
-                anyhow::bail!("Git editor {} exited with {status}", editor.to_string_lossy());
-            }
-            Ok(())
-        })?;
+        let status = Command::from(
+            gix::command::prepare(editor)
+                .arg(tempfile.path())
+                .command_may_be_shell_script_allow_manual_argument_splitting(),
+        )
+        .status()
+        .with_context(|| format!("could not launch Git editor {}", editor.to_string_lossy()))?;
+        if !status.success() {
+            anyhow::bail!("Git editor {} exited with {status}", editor.to_string_lossy());
+        }
     }
     let edited = std::fs::read(tempfile.path()).context("could not read edited commit message")?;
     Ok((edited != document).then_some(edited))

From ea3e912f52b13e43ee9ca23a140e733212001337 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 20:40:07 +0200
Subject: [PATCH 096/282] fix: keep rebased tix descendants visible

---
 gix-tix/spec.md            |  8 +++++---
 gix-tix/src/edit/rebase.rs | 25 ++++++++++++++++++++++++-
 gix-tix/src/history.rs     | 21 ++++++++++++++++-----
 3 files changed, 45 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8dba6219731..733ea2ef12d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -203,9 +203,11 @@ The Enter key is written as `<enter>` throughout.
 - A pin is symbolic when the previous `HEAD` named a local branch, so later branch
   advances move the pinned tip. An already detached `HEAD` receives a direct pin.
 - While `HEAD` is detached, every valid pin from the current worktree augments
-  implicit and explicit revision tips. Pins from other worktrees, legacy shared
-  `refs/tix/pins/*` refs, dangling, malformed, and non-commit pins do not enter the
-  view or its decorations. Normal hidden-revision exclusions still apply.
+  implicit and explicit revision tips. While it is attached, only pins at strict
+  descendants of `HEAD` do so, preserving rewritten leaves after a history rebase
+  moves the checked-out branch down its stack. Pins from other worktrees, legacy
+  shared `refs/tix/pins/*` refs, dangling, malformed, and non-commit pins do not
+  enter the view or its decorations. Normal hidden-revision exclusions still apply.
 - Worktree pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index dce05c001f6..f749e2a1789 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1795,7 +1795,8 @@ mod tests {
 
         let pins = crate::history::all_pins(&repo)?;
         assert_eq!(pins.len(), 1, "the unreferenced new empty leaf receives one pin");
-        let empty = repo.find_commit(pins[0].id)?.decode()?.into_owned()?;
+        let empty_id = pins[0].id;
+        let empty = repo.find_commit(empty_id)?.decode()?.into_owned()?;
         assert_eq!(
             empty.message, b"checkpoint",
             "the complete empty-commit title becomes its message"
@@ -1806,6 +1807,28 @@ mod tests {
             empty.tree, middle_commit.tree,
             "the empty commit reuses its parent tree"
         );
+        let mut unrelated = repo.find_commit(base)?.decode()?.into_owned()?;
+        unrelated.parents.clear();
+        unrelated.message = "unrelated".into();
+        let unrelated = repo.write_object(&unrelated)?.detach();
+        repo.reference(
+            "refs/worktree/tix/pins/side",
+            unrelated,
+            PreviousValue::MustNotExist,
+            "test unrelated pin",
+        )?;
+        assert!(
+            !repo.head()?.is_detached(),
+            "the branch remains checked out after rebasing"
+        );
+        assert_eq!(
+            crate::history::applicable_pins(&repo)?
+                .into_iter()
+                .map(|pin| pin.id)
+                .collect::<Vec<_>>(),
+            [empty_id],
+            "only the pinned descendant keeps the rewritten stack visible"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 74f69dbd16e..ac593dbcdff 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1327,13 +1327,24 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
 
 pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
     let head = repo.head().context("could not read HEAD while resolving tix pins")?;
-    if !head.is_detached() {
-        return Ok(Vec::new());
-    }
-    if head.id().is_none() {
+    let detached = head.is_detached();
+    let Some(head_id) = head.id().map(gix::Id::detach) else {
         return Ok(Vec::new());
+    };
+    drop(head);
+    let pins = all_pins(repo)?;
+    if detached {
+        return Ok(pins);
     }
-    all_pins(repo)
+    Ok(pins
+        .into_iter()
+        .filter(|pin| {
+            pin.id != head_id
+                && repo
+                    .merge_base(head_id, pin.id)
+                    .is_ok_and(|base| base.as_ref() == head_id)
+        })
+        .collect())
 }
 
 fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {

From e0af06e88986b618d9dd82f3388ce154194de765 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 20:58:51 +0200
Subject: [PATCH 097/282] fix: keep pending tix rebases unsigned

---
 gix-tix/spec.md            |  3 +-
 gix-tix/src/edit/rebase.rs | 93 ++++++++++++++++++++++++--------------
 gix-tix/src/edit/reword.rs | 46 +++++++++++++++++++
 3 files changed, 106 insertions(+), 36 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 733ea2ef12d..8579c012420 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -527,7 +527,8 @@ space first; changes blocks adapt within the remaining history width.
   configured and otherwise removes stale signature headers.
   `InvalidateExisting` empties existing signature values when signing is
   configured, making the empty field a pending-signature signal, or removes them
-  when it is not. Automatically rebased descendants
+  when it is not. A pending-rebase commit can only use the invalidation policy,
+  so it never carries a usable signature. Automatically rebased descendants
   retain their author and receive one configured current committer identity and
   timestamp for the operation.
 - All mutable local refs pointing anywhere into the rewritten set are changed in
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index f749e2a1789..06f90a661bd 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -27,6 +27,11 @@ pub(crate) enum Signature {
     Remove,
 }
 
+enum CommitState {
+    Unmarked(Signature),
+    Pending { original_parent: Option<ObjectId> },
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum Tree {
     #[cfg_attr(not(test), allow(dead_code))]
@@ -321,8 +326,7 @@ fn perform_inner(
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        marker(&mut commit, false, None);
-        let id = write_commit(&repo, commit, signature, signing.clone())?;
+        let id = write_commit(&repo, commit, CommitState::Unmarked(signature), signing.clone())?;
         selected = Some(id);
         if inserted {
             if let Some(root) = root {
@@ -410,24 +414,22 @@ fn perform_inner(
             || (commit_tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
             || conflict.is_some()
             || new_conflict.is_some();
-        marker(
-            &mut commit,
-            pending && (repeat || Some(old_id) != root),
-            recorded_parent.flatten().or_else(|| old_parents.first().copied()),
-        );
         let is_conflicting_commit = new_conflict.is_some();
-        let new_id = write_commit(
-            &repo,
-            commit,
-            if conflict.is_some() || is_conflicting_commit || (repeat && !eager) {
-                Signature::InvalidateExisting
-            } else if repeat {
-                Signature::RedoIfNeeded
-            } else {
-                signature
-            },
-            signing.clone(),
-        )?;
+        let signature = if conflict.is_some() || is_conflicting_commit || (repeat && !eager) {
+            Signature::InvalidateExisting
+        } else if repeat {
+            Signature::RedoIfNeeded
+        } else {
+            signature
+        };
+        let state = if pending && (repeat || Some(old_id) != root) {
+            CommitState::Pending {
+                original_parent: recorded_parent.flatten().or_else(|| old_parents.first().copied()),
+            }
+        } else {
+            CommitState::Unmarked(signature)
+        };
+        let new_id = write_commit(&repo, commit, state, signing.clone())?;
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
@@ -435,8 +437,12 @@ fn perform_inner(
         if Some(old_id) == root {
             if let Some(mut upper) = split_upper.take() {
                 upper.parents = [new_id].into_iter().collect();
-                marker(&mut upper, false, None);
-                let upper_id = write_commit(&repo, upper, Signature::RedoIfNeeded, signing.clone())?;
+                let upper_id = write_commit(
+                    &repo,
+                    upper,
+                    CommitState::Unmarked(Signature::RedoIfNeeded),
+                    signing.clone(),
+                )?;
                 rewritten.insert(old_id, Some(upper_id));
                 selected = Some(upper_id);
             } else {
@@ -540,8 +546,12 @@ pub(super) fn finish_review(
                     && value.as_slice().strip_prefix(b"onto ") == Some(review_ref.as_bstr().as_ref()))
             });
         }
-        marker(&mut commit, false, None);
-        let new = write_commit(&repo, commit, Signature::RedoIfNeeded, signing.clone())?;
+        let new = write_commit(
+            &repo,
+            commit,
+            CommitState::Unmarked(Signature::RedoIfNeeded),
+            signing.clone(),
+        )?;
         rewritten.insert(*old, Some(new));
         if *old == review {
             finished_review = Some(new);
@@ -580,8 +590,14 @@ pub(super) fn finish_review(
             .collect();
         commit.parents = new_parents.into_iter().collect();
         commit.committer = committer.clone();
-        marker(&mut commit, true, old_parents.first().copied());
-        let new = write_commit(&repo, commit, Signature::InvalidateExisting, signing.clone())?;
+        let new = write_commit(
+            &repo,
+            commit,
+            CommitState::Pending {
+                original_parent: old_parents.first().copied(),
+            },
+            signing.clone(),
+        )?;
         rewritten.insert(old, Some(new));
     }
 
@@ -700,17 +716,14 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         };
         commit.parents = [parent].into_iter().collect();
         commit.committer = committer.clone();
-        marker(
-            &mut commit,
-            !eager || new_conflict.is_some(),
-            recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
-        );
-        let signature = if eager && new_conflict.is_none() {
-            Signature::RedoIfNeeded
+        let state = if eager && new_conflict.is_none() {
+            CommitState::Unmarked(Signature::RedoIfNeeded)
         } else {
-            Signature::InvalidateExisting
+            CommitState::Pending {
+                original_parent: recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
+            }
         };
-        let new_id = write_commit(&repo, commit, signature, signing.clone())?;
+        let new_id = write_commit(&repo, commit, state, signing.clone())?;
         if let PlanCommit::Pick(old_id) = step.commit {
             rewritten.insert(old_id, Some(new_id));
         }
@@ -1154,9 +1167,19 @@ pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
 fn write_commit(
     repo: &gix::Repository,
     mut commit: gix::objs::Commit,
-    signature: Signature,
+    state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<ObjectId> {
+    let signature = match state {
+        CommitState::Unmarked(signature) => {
+            marker(&mut commit, false, None);
+            signature
+        }
+        CommitState::Pending { original_parent } => {
+            marker(&mut commit, true, original_parent);
+            Signature::InvalidateExisting
+        }
+    };
     let had_signature = commit.extra_headers.iter().any(|(name, _)| is_signature(name));
     commit.extra_headers.retain(|(name, _)| !is_signature(name));
     commit = match (signature, signing) {
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index b72ba278ef6..8bea2efd2f5 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -335,6 +335,52 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn signed_rewords_leave_pending_descendants_unsigned() -> gix_testtools::Result {
+        if !gix_testtools::signature::program_available("ssh-keygen") {
+            return Ok(());
+        }
+        let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "commit.gpgSign=true".to_owned(),
+                "gpg.format=ssh".to_owned(),
+                format!("user.signingKey={}", key.display()),
+                format!(
+                    "gpg.ssh.allowedSignersFile={}",
+                    gix_testtools::signature::fixture("ssh-allowed-signers").display()
+                ),
+            ]),
+        )?;
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let (_, document) = document(&repository, middle)?;
+        let edited = document.replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
+        let graph = super::super::loaded_graph(&repository)?;
+        let rewritten = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
+        assert!(
+            repository
+                .find_commit(rewritten)?
+                .verify_signature()?
+                .expect("the edited commit is signed")
+                .is_valid(),
+            "the final edited commit receives its configured signature"
+        );
+
+        let descendant = repository.find_commit(repository.head_id()?)?.decode()?.into_owned()?;
+        assert!(rebase::has_marker(&descendant), "the descendant remains pending");
+        assert!(
+            descendant
+                .extra_headers
+                .iter()
+                .filter(|(name, _)| name == "gpgsig" || name == "gpgsig-sha256")
+                .all(|(_, value)| value.is_empty()),
+            "a pending descendant never carries a usable signature"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rewrites_direct_refs_except_tags_and_remotes_and_signs_when_enabled() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {

From 9f656053f87f06b386305fe63344a99071ecaafa Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 21:06:24 +0200
Subject: [PATCH 098/282] fix: time-travel through mixed pending tix history

---
 gix-tix/spec.md            |  5 +-
 gix-tix/src/edit/rebase.rs | 95 +++++++++++++++++++++++++++++++++++++-
 2 files changed, 96 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8579c012420..85522c68285 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -444,8 +444,9 @@ space first; changes blocks adapt within the remaining history width.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
 - Time travel toward a pending destination cherry-picks and signs only the pending
-  ancestry through that destination. Pending descendants are reparented but remain
-  lazy and unsigned; traveling toward a non-pending ancestor leaves the entire
+  ancestry through that destination. Every later descendant is reparented and
+  becomes or remains lazy and unsigned, including ordinary commits created above
+  pending history; traveling toward a non-pending ancestor leaves the entire
   pending region untouched. A conflict
   retains the exact merge tree, conflict stages, prepared commits, and in-memory
   objects without changing the repository. The conflicting row shows a blinking
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 06f90a661bd..77ca7a5fe94 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1022,10 +1022,10 @@ fn validate(
         if parents.len() > 1 && (position > 0 || removed || tree == Tree::CherryPick) {
             anyhow::bail!("descendant merge commits cannot be rebased");
         }
-        if repeat {
+        if repeat && position == 0 {
             let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
             if !is_pending(&commit) {
-                anyhow::bail!("all repeated rebase commits must be pending");
+                anyhow::bail!("the root of a repeated rebase must be pending");
             }
         }
     }
@@ -1629,6 +1629,97 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_repeat_accepts_ordinary_descendants_above_legacy_signed_pending_commits() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "--allow-empty", "-q", "-m", "newer"])
+                .status()?
+                .success(),
+            "the fixture gains a second descendant"
+        );
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~2")?.detach();
+        let old_tip = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_newer = repo.head_id()?.detach();
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~3")?)?.tree_id()?.detach();
+        let marked = perform(
+            &repo,
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::InvalidateExisting,
+            Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let pending_tip = marked.map(old_tip).expect("the first descendant remains");
+        let pending_newer = marked.map(old_newer).expect("the second descendant remains");
+
+        let mut legacy_tip = repo.find_commit(pending_tip)?.decode()?.into_owned()?;
+        legacy_tip
+            .extra_headers
+            .push(("gpgsig".into(), "legacy signature".into()));
+        let legacy_tip = repo.write_object(&legacy_tip)?.detach();
+        let mut legacy_newer = repo.find_commit(pending_newer)?.decode()?.into_owned()?;
+        legacy_newer.parents = [legacy_tip].into_iter().collect();
+        legacy_newer
+            .extra_headers
+            .push(("gpgsig".into(), "legacy signature".into()));
+        let legacy_newer = repo.write_object(&legacy_newer)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(legacy_newer, "test legacy pending commits")?;
+        drop(repo);
+
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "--allow-empty", "-q", "-m", "ordinary descendant"])
+                .status()?
+                .success(),
+            "an ordinary commit can be created above pending history"
+        );
+        let repo = open(fixture.path())?;
+        let ordinary = repo.head_id()?.detach();
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = perform(
+            &repo,
+            &graph,
+            Edit::Repeat {
+                base: legacy_tip,
+                checkout: legacy_tip,
+            },
+            Signature::RedoIfNeeded,
+            Tree::CherryPick,
+        )?
+        .complete()?;
+        let selected = outcome
+            .map(legacy_tip)
+            .expect("the selected pending commit is retained");
+        assert!(!has_marker(&repo.find_commit(selected)?.decode()?.into_owned()?));
+        for id in [legacy_newer, ordinary].into_iter().map(|id| {
+            outcome
+                .map(id)
+                .expect("every descendant is retained while repeating the rebase")
+        }) {
+            let commit = repo.find_commit(id)?.decode()?.into_owned()?;
+            assert!(has_marker(&commit), "later descendants become or remain pending");
+            assert!(
+                commit
+                    .extra_headers
+                    .iter()
+                    .filter(|(name, _)| name == "gpgsig" || name == "gpgsig-sha256")
+                    .all(|(_, value)| value.is_empty()),
+                "later pending descendants have no usable signature"
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn authoritative_replacements_do_not_record_an_original_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;

From 2732cc934e6688527df0c36f7de69d38d2789d66 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 14 Aug 2026 21:42:02 +0200
Subject: [PATCH 099/282] fix: keep tix references at rewritten tips

---
 gix-tix/spec.md            |  20 ++--
 gix-tix/src/edit/rebase.rs | 207 ++++++++++++++++++++++++++++++-------
 gix-tix/src/edit/todo.rs   |  11 +-
 3 files changed, 190 insertions(+), 48 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 85522c68285..2928ecc4900 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -572,14 +572,18 @@ space first; changes blocks adapt within the remaining history width.
   invalidate old signatures for later time travel. With no `@`, the entire edit
   is lazy. The existing suspended-conflict acceptance path handles eager
   conflicts; bare repositories reject a conflict without persisting it.
-- Mutable refs captured before the editor opened follow retained or dropped
-  commits through one compare-and-swap transaction. Tags and remote-tracking refs
-  remain untouched. Every resulting leaf without a surviving mutable ref gets a
-  direct `refs/worktree/tix/pins/*` ref, except the checked-out leaf. Concurrent
-  ref edits win by making the transaction fail; the editor result is not rebuilt
-  against a later graph snapshot. Leaving the document unchanged is a no-op unless
-  its scope contains pending commits or rebase-update selected a newer base; then
-  the unchanged plan runs with the same eager `@` ancestry and lazy-fork rules.
+- Mutable refs captured on original leaves stay tips: after their commit is
+  rewritten or dropped, they follow the first continuation in todo order to its
+  resulting leaf. Other mutable refs remain bound to their rewritten commit.
+  All moves use one compare-and-swap transaction; tags and remote-tracking refs
+  remain untouched. Every other resulting leaf gets a direct
+  `refs/worktree/tix/pins/*` ref, except the checked-out leaf. When `@` moves below
+  a referenced leaf, the existing time-travel checkout detaches `HEAD` there while
+  the ref stays at the leaf. Concurrent ref edits win by making the transaction
+  fail; the editor result is not rebuilt against a later graph snapshot. Leaving
+  the document unchanged is a no-op unless its scope contains pending commits or
+  rebase-update selected a newer base; then the unchanged plan runs with the same
+  eager `@` ancestry and lazy-fork rules.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 77ca7a5fe94..083bc566fde 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -91,6 +91,8 @@ pub(crate) struct PlanStep {
 pub(crate) struct ExpectedRef {
     pub name: gix::refs::FullName,
     pub old: ObjectId,
+    new: ObjectId,
+    follows_tip: bool,
 }
 
 #[derive(Debug)]
@@ -193,8 +195,9 @@ struct Prepared {
     delete_refs: Vec<(gix::refs::FullName, Target)>,
 }
 
-pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result<Vec<ExpectedRef>> {
+pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[ObjectId]) -> Result<Vec<ExpectedRef>> {
     let scope: HashSet<_> = scope.iter().copied().collect();
+    let tips: HashSet<_> = tips.iter().copied().collect();
     let mut out = Vec::new();
     let mut seen = HashSet::new();
     for reference in repo.references()?.all()? {
@@ -216,6 +219,8 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result
             out.push(ExpectedRef {
                 name: reference.name().to_owned(),
                 old,
+                new: old,
+                follows_tip: tips.contains(&old),
             });
         }
     }
@@ -227,6 +232,8 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId]) -> Result
         out.push(ExpectedRef {
             name: head.name().to_owned(),
             old,
+            new: old,
+            follows_tip: tips.contains(&old),
         });
     }
     Ok(out)
@@ -618,7 +625,7 @@ pub(super) fn finish_review(
 }
 
 #[tracing::instrument(skip_all, fields(base = %plan.base, steps = plan.steps.len()))]
-pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: Plan) -> Result<Perform> {
+pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut plan: Plan) -> Result<Perform> {
     let mut repo = repo.clone();
     let signing = repo
         .commit_signing_options_if_enabled()
@@ -765,6 +772,28 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         rewritten.insert(dropped, ancestor.or(Some(plan.base)));
     }
 
+    let mut primary_children = HashMap::new();
+    for (index, step) in plan.steps.iter().enumerate() {
+        let parent = match step.parent {
+            PlanParent::Existing(id) => id,
+            PlanParent::Step(parent) => produced[parent],
+        };
+        primary_children.entry(parent).or_insert(produced[index]);
+    }
+    for expected in &mut plan.expected_refs {
+        let mut target = rewritten
+            .get(&expected.old)
+            .copied()
+            .flatten()
+            .context("a captured reference target disappeared from the rebase plan")?;
+        if expected.follows_tip {
+            while let Some(child) = primary_children.get(&target) {
+                target = *child;
+            }
+        }
+        expected.new = target;
+    }
+
     let planned_non_leaves: HashSet<_> = plan
         .steps
         .iter()
@@ -778,10 +807,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: P
         if planned_non_leaves.contains(&index) || plan.checkout == Some(index) {
             continue;
         }
-        let referenced = plan
-            .expected_refs
-            .iter()
-            .any(|expected| rewritten.get(&expected.old).copied().flatten() == Some(id));
+        let referenced = plan.expected_refs.iter().any(|expected| expected.new == id);
         if !referenced {
             pins.push(id);
         }
@@ -1283,13 +1309,12 @@ fn update_refs(
     let mut edits = Vec::new();
     let mut rollback = Vec::new();
     if let Some(expected_refs) = expected_refs {
-        for ExpectedRef { name, old } in expected_refs {
+        for ExpectedRef { name, old, new, .. } in expected_refs {
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
                 continue;
             }
-            let Some(new) = rewritten.get(&old) else { continue };
-            edits.push(ref_edit(name.clone(), old, *new));
-            rollback.push(reverse_ref_edit(name, old, *new));
+            edits.push(ref_edit(name.clone(), old, Some(new)));
+            rollback.push(reverse_ref_edit(name, old, Some(new)));
         }
     } else {
         for reference in repo.references()?.all()? {
@@ -1851,7 +1876,8 @@ mod tests {
     }
 
     #[test]
-    fn a_todo_rebase_eagerly_replays_only_the_checkout_ancestry_and_pins_a_new_leaf() -> gix_testtools::Result {
+    fn a_todo_rebase_eagerly_replays_only_the_checkout_ancestry_and_keeps_the_branch_at_the_leaf()
+    -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
@@ -1859,7 +1885,7 @@ mod tests {
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let tip = repo.head_id()?.detach();
         let old_middle_tree = repo.find_commit(middle)?.tree_id()?.detach();
-        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+        let expected_refs = capture_refs(&repo, &[middle, tip], &[tip])?;
 
         let outcome = perform_plan(
             &repo,
@@ -1889,9 +1915,9 @@ mod tests {
         let new_tip = outcome.map(tip).context("the picked tip is retained")?;
         let new_middle = outcome.map(middle).context("the picked middle is retained")?;
         assert_eq!(
-            repo.head_id()?.detach(),
-            new_tip,
-            "the branch follows its rewritten commit"
+            outcome.selected,
+            Some(new_tip),
+            "the checkout still follows its picked commit"
         );
         let tip_commit = repo.find_commit(new_tip)?.decode()?.into_owned()?;
         assert!(!has_marker(&tip_commit), "the checkout ancestry is eagerly replayed");
@@ -1907,9 +1933,7 @@ mod tests {
         );
         assert_eq!(middle_commit.parents.first().copied(), Some(new_tip));
 
-        let pins = crate::history::all_pins(&repo)?;
-        assert_eq!(pins.len(), 1, "the unreferenced new empty leaf receives one pin");
-        let empty_id = pins[0].id;
+        let empty_id = repo.head_id()?.detach();
         let empty = repo.find_commit(empty_id)?.decode()?.into_owned()?;
         assert_eq!(
             empty.message, b"checkpoint",
@@ -1921,27 +1945,134 @@ mod tests {
             empty.tree, middle_commit.tree,
             "the empty commit reuses its parent tree"
         );
-        let mut unrelated = repo.find_commit(base)?.decode()?.into_owned()?;
-        unrelated.parents.clear();
-        unrelated.message = "unrelated".into();
-        let unrelated = repo.write_object(&unrelated)?.detach();
-        repo.reference(
-            "refs/worktree/tix/pins/side",
-            unrelated,
-            PreviousValue::MustNotExist,
-            "test unrelated pin",
-        )?;
         assert!(
             !repo.head()?.is_detached(),
             "the branch remains checked out after rebasing"
         );
+        assert!(
+            crate::history::all_pins(&repo)?.is_empty(),
+            "the referenced leaf needs no pin"
+        );
+        let repository_path = repo.git_dir().to_owned();
+        drop(repo);
+        super::super::time_travel::checkout_without_replay(&repository_path, false, new_tip, &[], false)?;
+        let repo = open(fixture.path())?;
+        assert!(
+            repo.head()?.is_detached(),
+            "moving @ below the branch tip detaches HEAD"
+        );
+        assert_eq!(repo.head_id()?.detach(), new_tip, "HEAD follows the checkout marker");
+        assert_eq!(
+            repo.find_reference("refs/heads/main")?.id().detach(),
+            empty_id,
+            "the branch remains at the resulting leaf"
+        );
+        let pins = crate::history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "the detached view retains the branch through a pin");
+        assert_eq!(
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(b"refs/heads/main".as_bstr()),
+            "the visibility pin follows the branch symbolically"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn tip_refs_follow_the_primary_continuation_and_other_leaves_are_pinned() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        repo.reference(
+            "refs/custom/tip",
+            tip,
+            PreviousValue::MustNotExist,
+            "test custom tip reference",
+        )?;
+
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![
+                    PlanStep {
+                        parent: PlanParent::Existing(base),
+                        commit: PlanCommit::Pick(tip),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Pick(middle),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Empty("side".into()),
+                    },
+                ],
+                checkout: Some(0),
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        .complete()?;
+        let primary = outcome.map(middle).context("the primary leaf is retained")?;
+        for name in ["refs/heads/main", "refs/custom/tip"] {
+            assert_eq!(
+                repo.find_reference(name)?.id().detach(),
+                primary,
+                "{name} follows the first continuation"
+            );
+        }
+        let pins = crate::history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "the secondary leaf receives one pin");
+        assert_eq!(
+            repo.find_commit(pins[0].id)?.parent_ids().next().map(gix::Id::detach),
+            outcome.map(tip),
+            "the pin retains the secondary fork"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn dropping_a_referenced_tip_advances_its_refs_to_the_primary_leaf() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+
+        perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![
+                    PlanStep {
+                        parent: PlanParent::Existing(base),
+                        commit: PlanCommit::Pick(middle),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Empty("replacement tip".into()),
+                    },
+                ],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        .complete()?;
         assert_eq!(
-            crate::history::applicable_pins(&repo)?
-                .into_iter()
-                .map(|pin| pin.id)
-                .collect::<Vec<_>>(),
-            [empty_id],
-            "only the pinned descendant keeps the rewritten stack visible"
+            repo.find_commit(repo.head_id()?)?.message_raw()?,
+            b"replacement tip",
+            "the branch advances past the retained ancestor"
+        );
+        assert!(
+            crate::history::all_pins(&repo)?.is_empty(),
+            "the referenced replacement leaf needs no pin"
         );
         Ok(())
     }
@@ -1982,7 +2113,7 @@ mod tests {
                     },
                 ],
                 checkout: Some(1),
-                expected_refs: capture_refs(&repo, &[middle, tip])?,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?
         .complete()?;
@@ -2008,7 +2139,7 @@ mod tests {
         let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let tip = repo.head_id()?.detach();
-        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+        let expected_refs = capture_refs(&repo, &[middle, tip], &[tip])?;
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -2062,7 +2193,7 @@ mod tests {
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test reference",
         )?;
-        let expected_refs = capture_refs(&repo, &[middle, tip])?;
+        let expected_refs = capture_refs(&repo, &[middle, tip], &[tip])?;
 
         perform_plan(
             &repo,
@@ -2133,7 +2264,7 @@ mod tests {
                     commit: PlanCommit::Pick(tip),
                 }],
                 checkout: None,
-                expected_refs: capture_refs(&repo, &[middle, tip])?,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?
         .complete()?;
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 6de63f07161..387d01c4bf1 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -21,7 +21,7 @@ const HELP: &[u8] = br#"
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
 - Saving an unchanged document is a no-op unless listed commits have a pending rebase. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
-- Mutable refs follow rewritten and dropped commits, except tags and remote-tracking refs. New unreferenced leaves are pinned.
+- Mutable refs on original leaves stay on the primary resulting leaf; the first continuation in todo order is primary. Other mutable refs follow their commits. Tags and remote-tracking refs stay unchanged, and new unreferenced leaves are pinned.
 - A checkout conflict uses tix's standard suspended-conflict flow; concurrent ref changes abort the update.
 -->
 "#;
@@ -63,7 +63,14 @@ pub(crate) fn prepare(
     let scope: Vec<_> = commits.iter().map(|commit| commit.id).collect();
     let scope_set: HashSet<_> = scope.iter().copied().collect();
     let marker_required = head.is_some_and(|head| scope_set.contains(&head));
-    let expected_refs = rebase::capture_refs(repo, &scope)?;
+    let mut tips = scope_set.clone();
+    for commit in commits {
+        for parent in &commit.parents {
+            tips.remove(parent);
+        }
+    }
+    let tips = tips.into_iter().collect::<Vec<_>>();
+    let expected_refs = rebase::capture_refs(repo, &scope, &tips)?;
     let has_pending = commits.iter().try_fold(false, |pending, commit| {
         Ok::<_, anyhow::Error>(pending || rebase::is_pending(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
     })?;

From 36c3f7de31591e002822bc517d5f5bc60c828c9b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 05:36:42 +0200
Subject: [PATCH 100/282] feat: add self-contained rebase todo commands

---
 gix-tix/spec.md               |  22 +-
 gix-tix/src/app.rs            |   9 +
 gix-tix/src/command.rs        |  53 ++++-
 gix-tix/src/command/rebase.rs | 331 ++++++++++++++++++++++++++++
 gix-tix/src/edit/rebase.rs    |   8 +-
 gix-tix/src/edit/todo.rs      | 396 ++++++++++++++++++++++++++++++----
 gix-tix/src/history.rs        |  18 ++
 gix-tix/src/lib.rs            |  22 +-
 8 files changed, 804 insertions(+), 55 deletions(-)
 create mode 100644 gix-tix/src/command/rebase.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2928ecc4900..6649715d6b7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -20,6 +20,16 @@ without trading responsiveness for metadata that is not visible.
   revisions. Hidden revisions still exclude matching ancestry.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
+- `tix rebase todo -h HIDDEN... [--onto REV] [TIP...]` writes a self-contained
+  Markdown history-rebase plan to stdout. At least one hidden revision must
+  resolve; visible tips default to `HEAD`, and an ambiguous derived fork point is
+  an error. `--edit-and-apply` opens the same plan with Git's configured editor
+  and applies it when the editor exits.
+- `tix rebase apply [FILE]` applies such a plan from a file, or from standard
+  input when `FILE` is omitted or `-`. Removing its state comment or emptying the
+  document cancels successfully; malformed or unsupported state is an error.
+- Editor-launching commands honor Git's normal editor selection and
+  `GIT_EDITOR` overrides it.
 - Revisions must resolve and peel to commits. Invalid or non-commit visible
   revisions are errors. An unavailable hidden revision emits a warning and is
   ignored when another hidden revision resolves; if none resolve, startup fails.
@@ -564,6 +574,15 @@ space first; changes blocks adapt within the remaining history width.
 - The first line points to complete self-documenting help at the bottom. All
   instructions are enclosed in Markdown comments so only headings and command
   lines participate in the editable plan.
+- A versioned Markdown state comment makes the document independently
+  applicable in a later process. It records full base, target, scope and tip IDs,
+  checkout requirements, and compare-and-swap state for mutable refs. Ref names
+  use Git-compatible C-style quoting so arbitrary ref bytes round-trip. Missing
+  state cancels; present invalid state never reaches repository mutation.
+- Pick lines use display-only state symbols documented in the footer: `↻` for a
+  lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
+  unverified signature, and `○` for an unsigned commit. Applicable states may be
+  combined without changing plan semantics.
 - `@pick` or `@empty` chooses the post-rebase checkout. When the current worktree
   `HEAD` is in the editable region, exactly one generated `@` must remain; without
   one, zero or one may be added. A checkout marker is invalid without a worktree.
@@ -583,7 +602,8 @@ space first; changes blocks adapt within the remaining history width.
   fail; the editor result is not rebuilt against a later graph snapshot. Leaving
   the document unchanged is a no-op unless its scope contains pending commits or
   rebase-update selected a newer base; then the unchanged plan runs with the same
-  eager `@` ancestry and lazy-fork rules.
+  eager `@` ancestry and lazy-fork rules. Explicit `tix rebase apply` always
+  applies a valid plan, even when its editable commands are unchanged.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 518c84f96c0..05c02e5ac9a 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1254,6 +1254,15 @@ impl App {
         out
     }
 
+    pub(crate) fn hidden_rebase_candidates(&mut self) -> Vec<(ObjectId, Vec<ObjectId>)> {
+        self.update_hidden_branch_targets();
+        self.rows
+            .iter()
+            .filter(|row| self.hidden_rebase_bases.contains(&row.id))
+            .map(|row| (row.id, self.hidden_descendants(row.id)))
+            .collect()
+    }
+
     pub(crate) fn start_refresh(
         &mut self,
         commits: LoadedCommits,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 3abab0e8f8c..dcae8d8fbef 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -3,6 +3,8 @@ use std::ffi::OsString;
 use anyhow::{Context, Result};
 use clap::Parser;
 
+mod rebase;
+
 /// Arguments and commands shared by the standalone `tix` binary and `gix tix`.
 #[derive(Debug, clap::Args)]
 #[command(args_conflicts_with_subcommands = true)]
@@ -33,13 +35,17 @@ enum Command {
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
     Split,
+    /// Generate or apply a self-contained history-rebase todo.
+    #[command(subcommand)]
+    Rebase(rebase::Command),
 }
 
 #[derive(Debug, clap::Parser)]
 #[command(
     name = "tix",
     about = "Browse commits or edit the checked-out commit",
-    disable_help_flag = true
+    disable_help_flag = true,
+    after_long_help = "Commands which open an editor use Git's normal editor selection. Set GIT_EDITOR=<command> to override it."
 )]
 struct Cli {
     #[command(flatten)]
@@ -76,11 +82,20 @@ impl Platform {
 
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         let repository = repository.to_thread_local();
-        let graph = crate::edit::loaded_view_graph(&repository)?;
         match command {
-            Command::Amend => edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?,
-            Command::Spill => edit_head(repository, &graph, crate::edit::head::Kind::Spill, "spill")?,
-            Command::Split => split(repository, &graph)?,
+            Command::Amend => {
+                let graph = crate::edit::loaded_view_graph(&repository)?;
+                edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?;
+            }
+            Command::Spill => {
+                let graph = crate::edit::loaded_view_graph(&repository)?;
+                edit_head(repository, &graph, crate::edit::head::Kind::Spill, "spill")?;
+            }
+            Command::Split => {
+                let graph = crate::edit::loaded_view_graph(&repository)?;
+                split(repository, &graph)?;
+            }
+            Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
     }
@@ -168,6 +183,30 @@ mod tests {
                 .command,
             Some(Command::Split)
         ));
+        assert!(matches!(
+            Cli::try_parse_from([
+                "tix",
+                "rebase",
+                "todo",
+                "-h",
+                "main",
+                "--onto",
+                "next",
+                "--edit-and-apply",
+                "topic"
+            ])
+            .expect("rebase todo parses")
+            .platform
+            .command,
+            Some(Command::Rebase(rebase::Command::Todo(_)))
+        ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "rebase", "apply", "-"])
+                .expect("rebase apply parses")
+                .platform
+                .command,
+            Some(Command::Rebase(rebase::Command::Apply(_)))
+        ));
         assert!(
             Cli::command()
                 .render_help()
@@ -175,6 +214,10 @@ mod tests {
                 .contains("Split HEAD by amending worktree changes into it and committing staged index changes on top"),
             "short help explains how split distributes index and worktree changes"
         );
+        assert!(
+            Cli::command().render_long_help().to_string().contains("GIT_EDITOR"),
+            "top-level help explains how to override Git's editor"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
new file mode 100644
index 00000000000..b15075c7384
--- /dev/null
+++ b/gix-tix/src/command/rebase.rs
@@ -0,0 +1,331 @@
+use std::{
+    collections::HashMap,
+    ffi::{OsStr, OsString},
+    io::{Read, Write},
+    path::{Path, PathBuf},
+    sync::atomic::AtomicBool,
+};
+
+use anyhow::{Context, Result};
+use gix::ObjectId;
+
+use crate::{
+    app::App,
+    edit::{self, rebase, todo},
+    history::{self, Authors, Decorations, Event, HistoryGraph},
+};
+
+#[derive(Debug, clap::Subcommand)]
+pub(super) enum Command {
+    /// Produce a self-contained rebase todo, or edit and apply it immediately.
+    #[command(disable_help_flag = true)]
+    Todo(Todo),
+    /// Apply a self-contained rebase todo from FILE or standard input.
+    Apply(Apply),
+}
+
+#[derive(Debug, clap::Args)]
+#[command(
+    after_long_help = "Without --edit-and-apply, the todo is written to stdout. With it, Git's normal editor selection is used; GIT_EDITOR=<command> overrides it.\n\nExamples:\n  tix rebase todo -h main topic >todo.md\n  ${GIT_EDITOR:-editor} todo.md\n  tix rebase apply todo.md\n  tix rebase todo --edit-and-apply -h main topic"
+)]
+pub(super) struct Todo {
+    /// Print help.
+    #[arg(long, action = clap::ArgAction::HelpLong)]
+    help: Option<bool>,
+    /// Hide this revision and derive the editable fork point from it.
+    #[arg(short = 'h', long, value_name = "REVSPEC")]
+    hide: Vec<OsString>,
+    /// Rebase the derived scope onto this commit instead of its fork point.
+    #[arg(long, value_name = "REV")]
+    onto: Option<OsString>,
+    /// Open the todo in Git's editor and apply it after the editor exits.
+    #[arg(long)]
+    edit_and_apply: bool,
+    /// Visible traversal tips, or HEAD if omitted.
+    #[arg(value_name = "TIP")]
+    tips: Vec<OsString>,
+}
+
+#[derive(Debug, clap::Args)]
+pub(super) struct Apply {
+    /// Todo file to apply; omit or use '-' to read standard input.
+    #[arg(value_name = "FILE")]
+    file: Option<PathBuf>,
+}
+
+pub(super) fn run(repo: gix::Repository, command: Command) -> Result<()> {
+    match command {
+        Command::Todo(args) => todo(repo, args),
+        Command::Apply(args) => apply(repo, args),
+    }
+}
+
+fn todo(repo: gix::Repository, args: Todo) -> Result<()> {
+    let prepared = prepare(&repo, &args)?;
+    if !args.edit_and_apply {
+        std::io::stdout()
+            .write_all(&prepared.document)
+            .context("could not write the rebase todo")?;
+        return Ok(());
+    }
+
+    let editor = repo.editor().context("no Git editor is available")?;
+    let edited = edit::edit_document_without_terminal(
+        &editor,
+        &prepared.document,
+        &format!("tix-rebase-{}.md", std::process::id()),
+    )?
+    .unwrap_or(prepared.document);
+    apply_document(repo, &edited)
+}
+
+fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
+    if args.hide.is_empty() {
+        anyhow::bail!("rebase todo requires at least one -h/--hide revision");
+    }
+    let (hide, unavailable) = history::available_hidden_revisions(repo, &args.hide)?;
+    for (revision, err) in unavailable {
+        eprintln!(
+            "warning: ignoring unavailable hidden revision {}: {err}",
+            revision.to_string_lossy()
+        );
+    }
+    let resolved_tips = history::snapshot(repo, &args.tips, &hide, false)?.view_tips;
+
+    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+    let mut app = App::new(usize::MAX);
+    let mut decorations = Decorations::default();
+    let mut complete = false;
+    history::load(
+        repo,
+        &args.tips,
+        &hide,
+        false,
+        &authors,
+        &AtomicBool::new(false),
+        |event| {
+            match event {
+                Event::Decorations(value) => decorations = value,
+                Event::Commits(commits) => app.extend_commits(commits),
+                Event::HiddenCommits(commits) => app.extend_hidden_commits(commits),
+                Event::Complete(_) => complete = true,
+                Event::VisibleComplete | Event::Cancelled => {}
+            }
+            true
+        },
+    )?;
+    if !complete {
+        anyhow::bail!("history traversal did not produce a graph");
+    }
+    let mut candidates = app.hidden_rebase_candidates();
+    if candidates.len() != 1 {
+        if candidates.is_empty() {
+            anyhow::bail!("the hidden and visible revisions have no editable fork point");
+        }
+        candidates.sort_by_key(|(id, _)| *id);
+        anyhow::bail!(
+            "the revisions have multiple editable fork points: {}",
+            candidates
+                .iter()
+                .map(|(id, _)| id.to_string())
+                .collect::<Vec<_>>()
+                .join(", ")
+        );
+    }
+    let (base, scope) = candidates.pop().context("one rebase candidate was expected")?;
+    let onto = args
+        .onto
+        .as_deref()
+        .map(|revision| resolve_commit(repo, revision, "onto revision"))
+        .transpose()?
+        .unwrap_or(base);
+
+    let mut notes = repo
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes")?;
+    let row_indices: HashMap<_, _> = app
+        .rows
+        .iter()
+        .enumerate()
+        .map(|(index, row)| (row.id, index))
+        .collect();
+    for id in &scope {
+        let index = row_indices
+            .get(id)
+            .copied()
+            .context("an editable commit disappeared from the history view")?;
+        if !app.rows[index].metadata_loaded {
+            let (metadata, attributions) =
+                history::load_metadata(repo, *id, &authors).context("could not load editable commit metadata")?;
+            app.set_metadata(index, metadata, attributions);
+        }
+        let loaded = notes
+            .get(*id)
+            .map_err(gix::Exn::into_error)
+            .context("could not load commit notes")?
+            .into_iter()
+            .map(|note| {
+                let mut blob = note.blob;
+                blob.take_data().into()
+            })
+            .collect();
+        app.set_notes(*id, loaded);
+    }
+    let mailmap = repo.open_mailmap();
+    let commits = scope
+        .iter()
+        .map(|id| {
+            let row = row_indices
+                .get(id)
+                .and_then(|index| app.rows.get(*index))
+                .context("an editable commit disappeared while formatting the todo")?;
+            Ok(todo::Commit {
+                id: *id,
+                parents: row.parent_ids.iter().copied().collect(),
+                info: crate::ui::todo_metadata(&app, row, &decorations, &mailmap),
+            })
+        })
+        .collect::<Result<Vec<_>>>()?;
+    let head = repo.head()?.id().map(gix::Id::detach);
+    todo::prepare(repo, base, onto, &commits, head, &resolved_tips, todo::OntoKind::Onto)
+}
+
+fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
+    let revision =
+        gix::path::os_str_into_bstr(revision).with_context(|| format!("{description} is not valid UTF-8"))?;
+    let id = repo
+        .rev_parse_single(revision)
+        .with_context(|| format!("could not resolve {description}"))?;
+    id.object()
+        .with_context(|| format!("could not read {description}"))?
+        .try_into_commit()
+        .with_context(|| format!("{description} does not name a commit"))?;
+    Ok(id.detach())
+}
+
+fn apply(repo: gix::Repository, args: Apply) -> Result<()> {
+    let mut document = Vec::new();
+    match args.file.as_deref() {
+        None => {
+            std::io::stdin()
+                .read_to_end(&mut document)
+                .context("could not read the rebase todo from standard input")?;
+        }
+        Some(path) if path == Path::new("-") => {
+            std::io::stdin()
+                .read_to_end(&mut document)
+                .context("could not read the rebase todo from standard input")?;
+        }
+        Some(path) => {
+            document =
+                std::fs::read(path).with_context(|| format!("could not read rebase todo at {}", path.display()))?;
+        }
+    }
+    apply_document(repo, &document)
+}
+
+fn apply_document(repo: gix::Repository, document: &[u8]) -> Result<()> {
+    let Some(parsed) = todo::parse(&repo, document)? else {
+        println!("no rebase performed: the todo was cancelled");
+        return Ok(());
+    };
+    let graph = HistoryGraph::for_commits(&repo, &parsed.plan.scope)?;
+    let repository_path = repo.git_dir().to_owned();
+    let bare = repo.is_bare();
+    let tips = parsed.tips;
+    match rebase::perform_plan(&repo, &graph, parsed.plan)? {
+        rebase::Perform::Complete(outcome) => {
+            let revisions = mapped_revisions(&tips, |id| outcome.map(id));
+            if let Some(selected) = outcome.selected {
+                let notice =
+                    edit::time_travel::checkout_without_replay(&repository_path, bare, selected, &revisions, false)?;
+                println!("{}", notice.unwrap_or_else(|| "rebased history".into()));
+            } else {
+                println!("rebased history");
+            }
+            Ok(())
+        }
+        rebase::Perform::Conflict(conflict) => {
+            let revisions = mapped_revisions(&tips, |id| conflict.map(id));
+            let (notice, commit) =
+                edit::time_travel::Conflict::from_rebase(&repository_path, bare, conflict, &revisions, false)?
+                    .accept()?;
+            anyhow::bail!(
+                "{notice}; resolve conflicts at {} and amend the result",
+                commit.to_hex_with_len(7)
+            )
+        }
+    }
+}
+
+fn mapped_revisions(tips: &[ObjectId], mut map: impl FnMut(ObjectId) -> Option<ObjectId>) -> Vec<OsString> {
+    tips.iter()
+        .filter_map(|id| map(*id))
+        .map(|id| OsString::from(id.to_string()))
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn repository() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "core.abbrev=7".to_owned(),
+                "user.name=todo author".to_owned(),
+                "user.email=todo@example.com".to_owned(),
+            ]),
+        )?;
+        Ok((fixture, repo))
+    }
+
+    #[test]
+    fn generates_a_self_contained_todo_from_hidden_and_visible_revisions() -> gix_testtools::Result {
+        let (_fixture, repo) = repository()?;
+        let prepared = prepare(
+            &repo,
+            &Todo {
+                help: None,
+                hide: vec!["HEAD~2".into()],
+                onto: None,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )?;
+        let document = String::from_utf8(prepared.document)?;
+        assert!(document.contains("<!-- tix-rebase-state-v1"), "state is embedded");
+        assert!(document.contains("`@pick "), "HEAD is the generated checkout");
+        assert!(
+            document.contains("2000-01-02 author middle"),
+            "default TUI metadata is present"
+        );
+        assert!(
+            document.contains("2000-01-03 author tip"),
+            "the subject is always present"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn requires_a_hidden_revision_at_runtime() -> gix_testtools::Result {
+        let (_fixture, repo) = repository()?;
+        let err = prepare(
+            &repo,
+            &Todo {
+                help: None,
+                hide: Vec::new(),
+                onto: None,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )
+        .expect_err("a hidden revision is required");
+        assert!(format!("{err:#}").contains("at least one -h/--hide"));
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 083bc566fde..65fcca660a5 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -91,8 +91,8 @@ pub(crate) struct PlanStep {
 pub(crate) struct ExpectedRef {
     pub name: gix::refs::FullName,
     pub old: ObjectId,
-    new: ObjectId,
-    follows_tip: bool,
+    pub new: ObjectId,
+    pub follows_tip: bool,
 }
 
 #[derive(Debug)]
@@ -142,6 +142,10 @@ impl Conflict {
         self.original
     }
 
+    pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
+        self.prepared.rewritten.get(&id).copied().unwrap_or(Some(id))
+    }
+
     pub(crate) fn persist(mut self) -> Result<PersistedConflict> {
         self.prepared.finish()?;
         Ok(PersistedConflict {
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 387d01c4bf1..3e4a2969967 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -9,38 +9,60 @@ use gix::{
 
 use super::rebase;
 
-const HELP: &[u8] = br#"
+const HELP: &str = r#"
 
 <!--
 # Rebase todo help
 
 - Each fork section lists a stack from its oldest commit to its newest. Blank lines are ignored.
 - `pick <id>` keeps a commit. Delete its line to drop it, or move the line to reorder it. Each listed commit may be picked only once.
-- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is labelled `(updated-base)` with its title. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
+- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
-- Saving an unchanged document is a no-op unless listed commits have a pending rebase. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
+- Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Mutable refs on original leaves stay on the primary resulting leaf; the first continuation in todo order is primary. Other mutable refs follow their commits. Tags and remote-tracking refs stay unchanged, and new unreferenced leaves are pinned.
 - A checkout conflict uses tix's standard suspended-conflict flow; concurrent ref changes abort the update.
+- Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
 -->
 "#;
 
+const STATE_START: &str = "<!-- tix-rebase-state-v1\n";
+const STATE_END: &str = "-->";
+const STATE_CLOSE: &str = "\n-->";
+
 pub(crate) struct Commit {
     pub id: ObjectId,
     pub parents: Vec<ObjectId>,
     pub info: String,
 }
 
+#[derive(Debug)]
 pub(crate) struct Prepared {
-    pub editor: std::ffi::OsString,
     pub document: Vec<u8>,
+    pub apply_unchanged: bool,
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum OntoKind {
+    UpdatedBase,
+    Onto,
+}
+
+struct State {
     base: ObjectId,
+    onto: ObjectId,
+    tips: Vec<ObjectId>,
     scope: Vec<ObjectId>,
     marker_required: bool,
     checkout_allowed: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
-    pub apply_unchanged: bool,
+}
+
+#[derive(Debug)]
+pub(crate) struct Parsed {
+    pub plan: rebase::Plan,
+    pub tips: Vec<ObjectId>,
 }
 
 struct Section {
@@ -55,8 +77,9 @@ pub(crate) fn prepare(
     onto: ObjectId,
     commits: &[Commit],
     head: Option<ObjectId>,
+    resolved_tips: &[ObjectId],
+    onto_kind: OntoKind,
 ) -> Result<Prepared> {
-    let editor = repo.editor().context("no Git editor is available")?;
     repo.find_commit(base)
         .context("could not find the selected rebase base")?;
     repo.find_commit(onto).context("could not find the rebase target")?;
@@ -107,10 +130,32 @@ pub(crate) fn prepare(
     } else {
         format!("# Rebase from `{source}` onto `{}`", short(repo, onto)?)
     };
-    let mut document = b"<!-- Rebase help is at the bottom of this file. -->\n\n".to_vec();
+    let state = State {
+        base,
+        onto,
+        tips: if resolved_tips.is_empty() {
+            tips
+        } else {
+            resolved_tips.to_vec()
+        },
+        scope: scope.clone(),
+        marker_required,
+        checkout_allowed: repo.workdir().is_some(),
+        expected_refs,
+    };
+    let mut document = b"<!-- Rebase help is at the bottom of this file. -->\n".to_vec();
+    write_state(&mut document, &state);
+    document.push(b'\n');
     document.extend_from_slice(title.as_bytes());
     document.extend_from_slice(b"\n\n");
-    let anchor_kind = if base == onto { "base" } else { "updated-base" };
+    let anchor_kind = if base == onto {
+        "base"
+    } else {
+        match onto_kind {
+            OntoKind::UpdatedBase => "updated-base",
+            OntoKind::Onto => "onto",
+        }
+    };
     let anchor_title = anchor_title(repo, onto)?;
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
@@ -125,27 +170,96 @@ pub(crate) fn prepare(
         for id in &section.commits {
             let commit = by_id[id];
             let verb = if Some(*id) == head { "@pick" } else { "pick" };
+            let states = commit_states(repo, *id)?;
             document.extend_from_slice(
-                format!("`{verb} {}` {}\n", short(repo, *id)?, escape_markdown(&commit.info)).as_bytes(),
+                format!(
+                    "`{verb} {}` {states}{}\n",
+                    short(repo, *id)?,
+                    escape_markdown(&commit.info)
+                )
+                .as_bytes(),
             );
         }
     }
     if sections.is_empty() {
         write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
     }
-    document.extend_from_slice(HELP);
+    document.extend_from_slice(HELP.as_bytes());
     Ok(Prepared {
-        editor,
         document,
-        base: onto,
-        scope,
-        marker_required,
-        checkout_allowed: repo.workdir().is_some(),
-        expected_refs,
         apply_unchanged,
     })
 }
 
+fn write_state(out: &mut Vec<u8>, state: &State) {
+    out.extend_from_slice(STATE_START.as_bytes());
+    out.extend_from_slice(format!("base {}\nonto {}\n", state.base, state.onto).as_bytes());
+    for tip in &state.tips {
+        out.extend_from_slice(format!("tip {tip}\n").as_bytes());
+    }
+    for id in &state.scope {
+        out.extend_from_slice(format!("scope {id}\n").as_bytes());
+    }
+    out.extend_from_slice(
+        format!(
+            "marker-required {}\ncheckout-allowed {}\n",
+            state.marker_required, state.checkout_allowed
+        )
+        .as_bytes(),
+    );
+    for reference in &state.expected_refs {
+        let name = gix::quote::ansi_c::quote(reference.name.as_bstr());
+        out.extend_from_slice(
+            format!(
+                "ref {} {} {}\n",
+                reference.old,
+                reference.follows_tip,
+                name.to_str_lossy()
+            )
+            .as_bytes(),
+        );
+    }
+    out.extend_from_slice(STATE_END.as_bytes());
+    out.push(b'\n');
+}
+
+fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+    let commit = repo
+        .find_commit(id)
+        .context("could not load a commit state for the rebase todo")?
+        .decode()
+        .context("could not decode a commit state for the rebase todo")?
+        .into_owned()
+        .context("could not own a commit state for the rebase todo")?;
+    let pending = commit.extra_headers.iter().any(|(name, _)| name == "tix-rebase-parent");
+    let mut empty_signature = false;
+    let mut signature = false;
+    for (name, value) in &commit.extra_headers {
+        if name != "gpgsig" && name != "gpgsig-sha256" {
+            continue;
+        }
+        if value.is_empty() {
+            empty_signature = true;
+        } else {
+            signature = true;
+        }
+    }
+    let mut out = Vec::with_capacity(3);
+    if pending {
+        out.push("↻");
+    }
+    if empty_signature {
+        out.push("◌");
+    }
+    if signature {
+        out.push("◐");
+    }
+    if !empty_signature && !signature {
+        out.push("○");
+    }
+    Ok(format!("{} ", out.join(" ")))
+}
+
 fn anchor_title(repo: &gix::Repository, id: ObjectId) -> Result<String> {
     let message = repo
         .find_commit(id)
@@ -228,9 +342,134 @@ fn escape_markdown(input: &str) -> String {
     out
 }
 
-pub(crate) fn parse(repo: &gix::Repository, prepared: Prepared, edited: &[u8]) -> Result<rebase::Plan> {
+fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
+    let Some(start) = input.find(STATE_START) else {
+        if input.contains("<!-- tix-rebase-state-") {
+            anyhow::bail!("the rebase todo uses an unsupported state version");
+        }
+        return Ok(None);
+    };
+    let body = &input[start + STATE_START.len()..];
+    let end = body
+        .find(STATE_CLOSE)
+        .context("the rebase state anchor is not closed")?;
+    if body[end + STATE_CLOSE.len()..].contains(STATE_START) {
+        anyhow::bail!("the rebase todo contains more than one state anchor");
+    }
+    let mut base = None;
+    let mut onto = None;
+    let mut tips = Vec::new();
+    let mut scope = Vec::new();
+    let mut marker_required = None;
+    let mut checkout_allowed = None;
+    let mut expected_refs = Vec::new();
+    for line in body[..end].lines() {
+        let (key, value) = line.split_once(' ').context("a rebase state line has no value")?;
+        match key {
+            "base" => {
+                if base.replace(ObjectId::from_hex(value.as_bytes())?).is_some() {
+                    anyhow::bail!("the rebase state has more than one base");
+                }
+            }
+            "onto" => {
+                if onto.replace(ObjectId::from_hex(value.as_bytes())?).is_some() {
+                    anyhow::bail!("the rebase state has more than one onto target");
+                }
+            }
+            "tip" => tips.push(ObjectId::from_hex(value.as_bytes())?),
+            "scope" => scope.push(ObjectId::from_hex(value.as_bytes())?),
+            "marker-required" => {
+                if marker_required.replace(value.parse()?).is_some() {
+                    anyhow::bail!("the rebase state repeats marker-required");
+                }
+            }
+            "checkout-allowed" => {
+                if checkout_allowed.replace(value.parse()?).is_some() {
+                    anyhow::bail!("the rebase state repeats checkout-allowed");
+                }
+            }
+            "ref" => {
+                let (old, value) = value.split_once(' ').context("a captured ref has no follow mode")?;
+                let (follows_tip, name) = value.split_once(' ').context("a captured ref has no name")?;
+                let old = ObjectId::from_hex(old.as_bytes())?;
+                let follows_tip = follows_tip.parse()?;
+                let encoded_name = name.as_bytes().as_bstr();
+                let (name, consumed) = gix::quote::ansi_c::undo(encoded_name)
+                    .map_err(gix::Exn::into_error)
+                    .context("could not unquote a captured ref name")?;
+                if !encoded_name[consumed..].trim().is_empty() {
+                    anyhow::bail!("a captured ref name has trailing data");
+                }
+                let name = gix::refs::FullName::try_from(name.as_ref()).context("a captured ref name is invalid")?;
+                expected_refs.push(rebase::ExpectedRef {
+                    name,
+                    old,
+                    new: old,
+                    follows_tip,
+                });
+            }
+            _ => anyhow::bail!("unsupported rebase state field {key:?}"),
+        }
+    }
+    let state = State {
+        base: base.context("the rebase state has no base")?,
+        onto: onto.context("the rebase state has no onto target")?,
+        tips,
+        scope,
+        marker_required: marker_required.context("the rebase state has no marker requirement")?,
+        checkout_allowed: checkout_allowed.context("the rebase state has no checkout capability")?,
+        expected_refs,
+    };
+    validate_state(repo, &state)?;
+    Ok(Some(state))
+}
+
+fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
+    repo.find_commit(state.base)
+        .context("could not find the recorded rebase base")?;
+    repo.find_commit(state.onto)
+        .context("could not find the recorded rebase target")?;
+    let scope: HashSet<_> = state.scope.iter().copied().collect();
+    if scope.len() != state.scope.len() {
+        anyhow::bail!("the rebase state contains duplicate scope commits");
+    }
+    if state.tips.iter().copied().collect::<HashSet<_>>().len() != state.tips.len() {
+        anyhow::bail!("the rebase state contains duplicate tips");
+    }
+    let mut refs = HashSet::new();
+    for reference in &state.expected_refs {
+        if !refs.insert(reference.name.as_bstr()) {
+            anyhow::bail!("the rebase state contains duplicate refs");
+        }
+        if !scope.contains(&reference.old) {
+            anyhow::bail!("a captured ref does not point into the rebase scope");
+        }
+    }
+    for tip in &state.tips {
+        repo.find_commit(*tip).context("could not find a recorded rebase tip")?;
+    }
+    for id in &state.scope {
+        let commit = repo
+            .find_commit(*id)
+            .context("could not find a recorded scope commit")?;
+        let parent = commit
+            .parent_ids()
+            .next()
+            .map(gix::Id::detach)
+            .context("a recorded scope commit has no parent")?;
+        if parent != state.base && !scope.contains(&parent) {
+            anyhow::bail!("a recorded scope commit is disconnected from the rebase base");
+        }
+    }
+    Ok(())
+}
+
+pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Parsed>> {
     let input = std::str::from_utf8(edited).context("the rebase todo is not UTF-8")?;
-    let scope: HashSet<_> = prepared.scope.iter().copied().collect();
+    let Some(state) = parse_state(repo, input)? else {
+        return Ok(None);
+    };
+    let scope: HashSet<_> = state.scope.iter().copied().collect();
     let mut picked = HashMap::<ObjectId, usize>::new();
     let mut steps = Vec::new();
     let mut cursor = None;
@@ -294,7 +533,7 @@ pub(crate) fn parse(repo: &gix::Repository, prepared: Prepared, edited: &[u8]) -
             if marker_count > 1 {
                 anyhow::bail!("the rebase todo contains more than one @ marker");
             }
-            if !prepared.checkout_allowed {
+            if !state.checkout_allowed || repo.workdir().is_none() {
                 anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
             }
         }
@@ -339,16 +578,19 @@ pub(crate) fn parse(repo: &gix::Repository, prepared: Prepared, edited: &[u8]) -
     if sections > 1 && !section_has_commit {
         anyhow::bail!("the last fork section contains no commits");
     }
-    if prepared.marker_required && marker_count != 1 {
+    if state.marker_required && marker_count != 1 {
         anyhow::bail!("the current checkout marker must be retained");
     }
-    Ok(rebase::Plan {
-        base: prepared.base,
-        scope: prepared.scope,
-        steps,
-        checkout,
-        expected_refs: prepared.expected_refs,
-    })
+    Ok(Some(Parsed {
+        plan: rebase::Plan {
+            base: state.onto,
+            scope: state.scope,
+            steps,
+            checkout,
+            expected_refs: state.expected_refs,
+        },
+        tips: state.tips,
+    }))
 }
 
 fn resolve_commit(repo: &gix::Repository, value: &str) -> Result<ObjectId> {
@@ -408,14 +650,36 @@ mod tests {
         ))
     }
 
+    fn prepare_test(
+        repo: &gix::Repository,
+        base: ObjectId,
+        onto: ObjectId,
+        commits: &[Commit],
+        head: Option<ObjectId>,
+    ) -> Result<Prepared> {
+        prepare(repo, base, onto, commits, head, &[], OntoKind::UpdatedBase)
+    }
+
+    fn parse_plan(repo: &gix::Repository, document: &[u8]) -> Result<rebase::Plan> {
+        Ok(parse(repo, document)?.context("the test todo was cancelled")?.plan)
+    }
+
+    fn with_state(prepared: &Prepared, commands: &str) -> Vec<u8> {
+        let document = std::str::from_utf8(&prepared.document).expect("generated todo is UTF-8");
+        let start = document.find(STATE_START).expect("generated todo has state");
+        let end = document[start..].find(STATE_CLOSE).expect("generated state is closed") + start + STATE_CLOSE.len();
+        format!("{}\n{commands}", &document[start..end]).into_bytes()
+    }
+
     #[test]
     fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         assert!(!prepared.apply_unchanged);
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
+        assert!(document.contains(STATE_START), "the todo carries its transaction state");
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
         assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
@@ -430,6 +694,50 @@ mod tests {
             "complete instructions follow the editable todo"
         );
         assert!(document.ends_with("-->\n"), "all trailing help is one Markdown comment");
+        assert!(
+            document.contains("○"),
+            "unsigned commits carry the documented status symbol"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn state_round_trips_non_utf8_ref_names_and_controls_cancellation() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, _tip, _commits) = commits(&repo)?;
+        let name = gix::refs::FullName::try_from(BString::from(vec![
+            b'r', b'e', b'f', b's', b'/', b'h', b'e', b'a', b'd', b's', b'/', 0xff,
+        ]))?;
+        let state = State {
+            base,
+            onto: base,
+            tips: vec![middle],
+            scope: vec![middle],
+            marker_required: false,
+            checkout_allowed: true,
+            expected_refs: vec![rebase::ExpectedRef {
+                name: name.clone(),
+                old: middle,
+                new: middle,
+                follows_tip: true,
+            }],
+        };
+        let mut document = Vec::new();
+        write_state(&mut document, &state);
+        let document = String::from_utf8(document)?;
+        assert!(
+            document.contains(r#""refs/heads/\377""#),
+            "non-UTF-8 names use Git quoting"
+        );
+        let parsed = parse_state(&repo, &document)?.context("state is present")?;
+        assert_eq!(parsed.expected_refs[0].name, name, "quoted names round-trip losslessly");
+
+        assert!(parse(&repo, b"")?.is_none(), "empty input cancels");
+        assert!(parse(&repo, b"pick deadbeef")?.is_none(), "removing the anchor cancels");
+        assert!(
+            parse(&repo, b"<!-- tix-rebase-state-v2\n-->").is_err(),
+            "an unsupported present anchor is rejected"
+        );
         Ok(())
     }
 
@@ -463,13 +771,13 @@ mod tests {
                 info: "middle".into(),
             },
         ];
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         assert!(
             prepared.apply_unchanged,
             "pending commits make an unchanged todo actionable"
         );
         let document = prepared.document.clone();
-        let plan = parse(&repo, prepared, &document)?;
+        let plan = parse_plan(&repo, &document)?;
         let graph = super::super::loaded_graph(&repo)?;
         rebase::perform_plan(&repo, &graph, plan)?.complete()?;
 
@@ -506,14 +814,14 @@ mod tests {
             },
         );
 
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
         assert!(
             document.contains(&format!("## fork {}\n", middle.to_hex_with_len(7))),
             "a fork within the editable tree has no external-anchor annotation"
         );
-        let plan = parse(&repo, prepared, document.as_bytes())?;
+        let plan = parse_plan(&repo, document.as_bytes())?;
         assert_eq!(plan.steps.len(), 3, "display annotations do not alter the plan");
         Ok(())
     }
@@ -531,7 +839,7 @@ mod tests {
             .add("refs/notes/commits", onto, "anchor note")
             .map_err(gix::Exn::into_error)?;
 
-        let prepared = prepare(&repo, base, onto, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, onto, &commits, Some(tip))?;
         assert!(
             prepared.apply_unchanged,
             "moving the base makes an unchanged editor document actionable"
@@ -558,7 +866,7 @@ mod tests {
             "only the new update target is labelled"
         );
 
-        let plan = parse(&repo, prepared, document.as_bytes())?;
+        let plan = parse_plan(&repo, document.as_bytes())?;
         assert_eq!(plan.base, onto);
         assert_eq!(plan.steps[0].parent, rebase::PlanParent::Existing(onto));
         let graph = super::super::loaded_graph(&repo)?;
@@ -579,7 +887,7 @@ mod tests {
     fn parses_reordering_forks_empty_commits_and_a_moved_checkout() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
             "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -587,10 +895,11 @@ mod tests {
             tip.to_hex_with_len(7),
             middle.to_hex_with_len(7),
         );
-        let err = parse(&repo, prepared, edited.as_bytes()).expect_err("two checkout markers are invalid");
+        let edited = with_state(&prepared, &edited);
+        let err = parse(&repo, &edited).expect_err("two checkout markers are invalid");
         assert!(format!("{err:#}").contains("more than one @"));
 
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
             "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
             base.to_hex_with_len(7),
@@ -598,7 +907,8 @@ mod tests {
             tip.to_hex_with_len(7),
             middle.to_hex_with_len(7),
         );
-        let plan = parse(&repo, prepared, edited.as_bytes())?;
+        let edited = with_state(&prepared, &edited);
+        let plan = parse_plan(&repo, &edited)?;
         assert_eq!(plan.steps.len(), 3);
         assert_eq!(plan.checkout, Some(2));
         assert_eq!(plan.steps[2].parent, rebase::PlanParent::Step(0));
@@ -610,13 +920,15 @@ mod tests {
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
-        let prepared = prepare(&repo, base, base, &commits, Some(tip))?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = format!("## fork {}\n", base.to_hex_with_len(7));
-        let err = parse(&repo, prepared, edited.as_bytes()).expect_err("HEAD must be moved before its pick is dropped");
+        let edited = with_state(&prepared, &edited);
+        let err = parse(&repo, &edited).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
 
-        let prepared = prepare(&repo, base, base, &commits, None)?;
-        let plan = parse(&repo, prepared, edited.as_bytes())?;
+        let prepared = prepare_test(&repo, base, base, &commits, None)?;
+        let edited = with_state(&prepared, &format!("## fork {}\n", base.to_hex_with_len(7)));
+        let plan = parse_plan(&repo, &edited)?;
         assert!(
             plan.steps.is_empty(),
             "all picks may be dropped when no marker is required"
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index ac593dbcdff..e547e192027 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -147,6 +147,24 @@ impl PartialOrd for GenThenTime {
 }
 
 impl HistoryGraph {
+    pub(crate) fn for_commits(repo: &gix::Repository, ids: &[ObjectId]) -> Result<Self> {
+        let mut graph = HistoryGraph::default();
+        let shallow: HashSet<_> = repo
+            .shallow_commits()
+            .context("could not read shallow commits")?
+            .into_iter()
+            .flat_map(|commits| commits.iter().copied().collect::<Vec<_>>())
+            .collect();
+        let commit_graph = repo
+            .commit_graph_if_enabled()
+            .context("could not open commit-graph for rebase")?;
+        let mut buf = Vec::new();
+        for id in ids {
+            graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, *id, &mut buf)?;
+        }
+        Ok(graph)
+    }
+
     fn intern(&mut self, id: ObjectId) -> Result<CommitIndex> {
         if let Some(index) = self.by_id.get(&id) {
             return Ok(*index);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a822d317c2f..0a638edfd8e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3178,15 +3178,25 @@ fn rebase_history(
     head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
 ) -> Result<Option<edit::rebase::Perform>> {
-    let prepared = {
+    let (prepared, editor) = {
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;
         repository.object_cache_size(None);
-        edit::todo::prepare(&repository, base, onto, &commits, head)?
+        let editor = repository.editor().context("no Git editor is available")?;
+        let prepared = edit::todo::prepare(
+            &repository,
+            base,
+            onto,
+            &commits,
+            head,
+            &[],
+            edit::todo::OntoKind::UpdatedBase,
+        )?;
+        (prepared, editor)
     };
     let edited = edit::edit_document(
         terminal,
-        &prepared.editor,
+        &editor,
         &prepared.document,
         &format!("tix-rebase-{}.md", std::process::id()),
         enhanced_keyboard,
@@ -3199,8 +3209,10 @@ fn rebase_history(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing rebase")?;
     repository.object_cache_size(None);
-    let plan = edit::todo::parse(&repository, prepared, &edited)?;
-    edit::rebase::perform_plan(&repository, graph, plan).map(Some)
+    let Some(parsed) = edit::todo::parse(&repository, &edited)? else {
+        return Ok(None);
+    };
+    edit::rebase::perform_plan(&repository, graph, parsed.plan).map(Some)
 }
 
 #[derive(Clone, Copy)]

From 97351de081e7215c84a36d20b39fc506742253ea Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 06:44:08 +0200
Subject: [PATCH 101/282] feat: squash commits in tix rebase todos

---
 gix-tix/spec.md                 |  37 ++-
 gix-tix/src/app.rs              |  23 ++
 gix-tix/src/command/rebase.rs   |  16 +-
 gix-tix/src/edit/rebase.rs      | 416 +++++++++++++++++++++++++++++---
 gix-tix/src/edit/time_travel.rs |  19 --
 gix-tix/src/edit/todo.rs        |  74 +++++-
 gix-tix/src/lib.rs              |  28 +--
 7 files changed, 520 insertions(+), 93 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6649715d6b7..bb9c8503080 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -566,11 +566,24 @@ space first; changes blocks adapt within the remaining history width.
   heading is `## fork <id> (updated-base) <title>`, with the Markdown-escaped
   title exactly as shown in history, including `[A]` and `[N]`. The hidden branch
   itself is not moved.
-- Pick lines may be reordered or removed. Fork headings may target an earlier
-  pick or any existing commit, so adding and removing headings creates and joins
-  branches. `empty <title>` inserts an empty commit. Markdown code spans and
-  equivalent plain commands are accepted; display text after a pick ID is
+- Pick lines may be reordered or removed. `squash <id>` folds an existing
+  non-merge commit into the preceding `pick` or `empty` in the same fork; it may
+  carry `@`, and fork headings naming any folded ID resolve to the combined
+  result. A fork cannot begin with `squash`. Fork headings may otherwise target
+  an earlier pick or any existing commit, so adding and removing headings creates
+  and joins branches. `empty <title>` inserts an empty commit. Markdown code
+  spans and equivalent plain commands are accepted; display text after an ID is
   informational.
+- Squash groups are materialized eagerly on every fork by applying their source
+  deltas in todo order. The result retains the first member's author, author
+  time, encoding, extra headers, and message, receives the operation's committer,
+  and is signed once. Before every later full message, a permanent
+  `# <short-id> <subject>` line identifies its source. Distinct raw authors of
+  later commits are appended in first-seen order as `Co-authored-by` trailers,
+  excluding the first author and identities already named by a valid such
+  trailer in any source message. Name and email pairs are compared without
+  mailmap. All folded IDs and mutable refs map to the one resulting commit;
+  resources owned by a later folded review commit are removed.
 - The first line points to complete self-documenting help at the bottom. All
   instructions are enclosed in Markdown comments so only headings and command
   lines participate in the editable plan.
@@ -583,14 +596,18 @@ space first; changes blocks adapt within the remaining history width.
   lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
   unverified signature, and `○` for an unsigned commit. Applicable states may be
   combined without changing plan semantics.
-- `@pick` or `@empty` chooses the post-rebase checkout. When the current worktree
+- `@pick`, `@squash`, or `@empty` chooses the post-rebase checkout. When the current worktree
   `HEAD` is in the editable region, exactly one generated `@` must remain; without
   one, zero or one may be added. A checkout marker is invalid without a worktree.
-- Only the ancestry ending at `@` is eagerly cherry-picked and re-signed. Other
-  resulting stacks retain their trees, receive pending-rebase markers, and
-  invalidate old signatures for later time travel. With no `@`, the entire edit
-  is lazy. The existing suspended-conflict acceptance path handles eager
-  conflicts; bare repositories reject a conflict without persisting it.
+- Only the ancestry ending at `@` and any squash groups are eagerly cherry-picked
+  and re-signed. Other resulting stacks retain their trees, receive pending-rebase
+  markers, and invalidate old signatures for later time travel. With no `@`,
+  ordinary steps remain lazy while squash groups are still materialized.
+  Any conflict while applying a history todo aborts the entire in-memory
+  transaction without writing objects, refs, index, or worktree state. The TUI
+  selects the original offending commit and marks it with a transient blinking
+  red `C`; command-line apply reports that commit as an error. Suspended conflict
+  checkout remains available only to direct edits and time travel.
 - Mutable refs captured on original leaves stay tips: after their commit is
   rewritten or dropped, they follow the first continuation in todo order to its
   resulting leaf. Other mutable refs remain bound to their rewritten commit.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 05c02e5ac9a..f51d1f416f1 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -587,6 +587,19 @@ impl App {
         self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
     }
 
+    pub(crate) fn mark_todo_rebase_conflict(&mut self, id: ObjectId) {
+        tracing::warn!(commit_id = %id, "todo rebase aborted on conflict");
+        self.pending_rebase_conflict = Some(id);
+        self.leave_message(format!(
+            "rebase aborted · conflict at {} · repository unchanged",
+            id.to_hex_with_len(7)
+        ));
+    }
+
+    pub(crate) fn has_rebase_conflict(&self) -> bool {
+        self.pending_rebase_conflict.is_some()
+    }
+
     pub(crate) fn clear_rebase_conflict(&mut self) {
         self.pending_rebase_conflict = None;
         self.message = None;
@@ -2742,6 +2755,16 @@ mod tests {
         assert!(!app.time_travel_shortcut_visible());
         app.clear_rebase_conflict();
         assert!(app.time_travel_shortcut_visible());
+
+        app.mark_todo_rebase_conflict(id(1));
+        assert!(app.has_rebase_conflict());
+        assert!(
+            app.message
+                .as_deref()
+                .is_some_and(|message| message.contains("repository unchanged")),
+            "an aborted todo explains that no state was materialized"
+        );
+        app.clear_rebase_conflict();
     }
 
     #[test]
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index b15075c7384..b0ccb140fb7 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -235,7 +235,7 @@ fn apply_document(repo: gix::Repository, document: &[u8]) -> Result<()> {
     let bare = repo.is_bare();
     let tips = parsed.tips;
     match rebase::perform_plan(&repo, &graph, parsed.plan)? {
-        rebase::Perform::Complete(outcome) => {
+        rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
             if let Some(selected) = outcome.selected {
                 let notice =
@@ -246,16 +246,10 @@ fn apply_document(repo: gix::Repository, document: &[u8]) -> Result<()> {
             }
             Ok(())
         }
-        rebase::Perform::Conflict(conflict) => {
-            let revisions = mapped_revisions(&tips, |id| conflict.map(id));
-            let (notice, commit) =
-                edit::time_travel::Conflict::from_rebase(&repository_path, bare, conflict, &revisions, false)?
-                    .accept()?;
-            anyhow::bail!(
-                "{notice}; resolve conflicts at {} and amend the result",
-                commit.to_hex_with_len(7)
-            )
-        }
+        rebase::PlanPerform::Conflict(original) => anyhow::bail!(
+            "rebase aborted without changes: conflict while applying {}",
+            original.to_hex_with_len(7)
+        ),
     }
 }
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 65fcca660a5..b04e08d2419 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -9,6 +9,7 @@ use gix::{
     ObjectId,
     bstr::{BStr, BString, ByteSlice},
     objs::Write,
+    prelude::ObjectIdExt,
     refs::{
         Category, Target,
         transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
@@ -85,6 +86,7 @@ pub(crate) enum PlanCommit {
 pub(crate) struct PlanStep {
     pub parent: PlanParent,
     pub commit: PlanCommit,
+    pub squash: Vec<ObjectId>,
 }
 
 #[derive(Debug)]
@@ -104,6 +106,21 @@ pub(crate) struct Plan {
     pub expected_refs: Vec<ExpectedRef>,
 }
 
+pub(crate) enum PlanPerform {
+    Complete(Outcome),
+    Conflict(ObjectId),
+}
+
+impl PlanPerform {
+    #[cfg(test)]
+    pub(crate) fn complete(self) -> Result<Outcome> {
+        match self {
+            PlanPerform::Complete(outcome) => Ok(outcome),
+            PlanPerform::Conflict(id) => anyhow::bail!("rebase plan conflicts at {id}"),
+        }
+    }
+}
+
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
@@ -142,10 +159,6 @@ impl Conflict {
         self.original
     }
 
-    pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
-        self.prepared.rewritten.get(&id).copied().unwrap_or(Some(id))
-    }
-
     pub(crate) fn persist(mut self) -> Result<PersistedConflict> {
         self.prepared.finish()?;
         Ok(PersistedConflict {
@@ -629,7 +642,7 @@ pub(super) fn finish_review(
 }
 
 #[tracing::instrument(skip_all, fields(base = %plan.base, steps = plan.steps.len()))]
-pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut plan: Plan) -> Result<Perform> {
+pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut plan: Plan) -> Result<PlanPerform> {
     let mut repo = repo.clone();
     let signing = repo
         .commit_signing_options_if_enabled()
@@ -651,7 +664,11 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
     let scope: HashSet<_> = plan.scope.iter().copied().collect();
     let mut picked = HashSet::new();
     for step in &plan.steps {
-        if let PlanCommit::Pick(id) = step.commit {
+        let ids = match step.commit {
+            PlanCommit::Pick(id) => Some(id).into_iter().chain(step.squash.iter().copied()),
+            PlanCommit::Empty(_) => None.into_iter().chain(step.squash.iter().copied()),
+        };
+        for id in ids {
             if !scope.contains(&id) || !picked.insert(id) {
                 anyhow::bail!("a rebase plan contains an invalid or duplicate pick");
             }
@@ -675,7 +692,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
 
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
     let mut produced = Vec::with_capacity(plan.steps.len());
-    let mut conflict = None;
+    let mut delete_refs = Vec::new();
     for (index, step) in plan.steps.iter().enumerate() {
         let parent = match step.parent {
             PlanParent::Existing(id) => {
@@ -684,7 +701,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
             }
             PlanParent::Step(parent) => *produced.get(parent).context("a fork points to a later commit")?,
         };
-        let eager = eager.contains(&index) && conflict.is_none();
+        let eager = eager.contains(&index) || !step.squash.is_empty();
         let mut commit = match &step.commit {
             PlanCommit::Pick(id) => repo
                 .find_commit(*id)
@@ -717,17 +734,46 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         } else {
             Tree::LeaveAsIsAndMark
         };
-        let mut new_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
-            TreeRewrite::Conflict { tree, conflicts } => {
-                new_conflict = Some((tree, conflicts));
-                tree
+            TreeRewrite::Conflict { .. } => {
+                let PlanCommit::Pick(original) = step.commit else {
+                    unreachable!("empty commits cannot conflict")
+                };
+                return Ok(PlanPerform::Conflict(original));
             }
         };
+        let mut squashed = Vec::with_capacity(step.squash.len());
+        for id in &step.squash {
+            let source = repo
+                .find_commit(*id)
+                .context("could not find a squashed commit")?
+                .decode()
+                .context("could not decode a squashed commit")?
+                .into_owned()
+                .context("could not own a squashed commit")?;
+            let graph_parents = graph.parents_of(*id).context("a squashed commit is incomplete")?;
+            let recorded_parent = has_marker(&source).then(|| marked_parent(&source)).transpose()?;
+            let replay_parents = recorded_parent.map_or_else(
+                || graph_parents.clone(),
+                |parent| parent.into_iter().collect::<Vec<_>>(),
+            );
+            squashed.push((*id, source, replay_parents));
+        }
+        if !squashed.is_empty() {
+            squash_message(&repo, &mut commit, &squashed)?;
+            for (id, source, replay_parents) in &squashed {
+                let old_base = parent_tree(&repo, replay_parents.first().copied())?;
+                commit.tree = match cherry_pick_tree_outcome(&repo, old_base, commit.tree, source.tree)? {
+                    TreeRewrite::Complete(tree) => tree,
+                    TreeRewrite::Conflict { .. } => return Ok(PlanPerform::Conflict(*id)),
+                };
+                delete_refs.extend(super::review::deletions(&repo, source)?);
+            }
+        }
         commit.parents = [parent].into_iter().collect();
         commit.committer = committer.clone();
-        let state = if eager && new_conflict.is_none() {
+        let state = if eager {
             CommitState::Unmarked(Signature::RedoIfNeeded)
         } else {
             CommitState::Pending {
@@ -738,17 +784,13 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         if let PlanCommit::Pick(old_id) = step.commit {
             rewritten.insert(old_id, Some(new_id));
         }
-        produced.push(new_id);
-        if let Some((tree, conflicts)) = new_conflict {
-            let PlanCommit::Pick(original) = step.commit else {
-                unreachable!("empty commits cannot conflict")
-            };
-            conflict = Some((original, tree, conflicts, new_id));
+        for old_id in &step.squash {
+            rewritten.insert(*old_id, Some(new_id));
         }
+        produced.push(new_id);
     }
 
     let dropped: Vec<_> = plan.scope.iter().copied().filter(|id| !picked.contains(id)).collect();
-    let mut delete_refs = Vec::new();
     for id in &dropped {
         let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
         delete_refs.extend(super::review::deletions(&repo, &commit)?);
@@ -817,7 +859,11 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         }
     }
     let selected = plan.checkout.map(|index| produced[index]);
-    let marked = plan.steps.iter().enumerate().any(|(index, _)| !eager.contains(&index)) || conflict.is_some();
+    let marked = plan
+        .steps
+        .iter()
+        .enumerate()
+        .any(|(index, step)| !eager.contains(&index) && step.squash.is_empty());
     let mut prepared = Prepared {
         repo,
         root: Some(plan.base),
@@ -831,16 +877,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         pins,
         delete_refs,
     };
-    match conflict {
-        Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
-            prepared,
-            conflicts,
-            tree,
-            commit,
-            original,
-        })),
-        None => Ok(Perform::Complete(prepared.finish()?)),
-    }
+    Ok(PlanPerform::Complete(prepared.finish()?))
 }
 
 impl Prepared {
@@ -1077,6 +1114,88 @@ enum TreeRewrite {
     },
 }
 
+fn squash_message(
+    repo: &gix::Repository,
+    commit: &mut gix::objs::Commit,
+    squashed: &[(ObjectId, gix::objs::Commit, Vec<ObjectId>)],
+) -> Result<()> {
+    let mut known = HashSet::<(BString, BString)>::new();
+    collect_co_authors(&commit.message, &mut known);
+    for (_, source, _) in squashed {
+        collect_co_authors(&source.message, &mut known);
+    }
+    known.insert(author_identity(&commit.author));
+    let mut additional = Vec::new();
+    for (_, source, _) in squashed {
+        let author = author_identity(&source.author);
+        if known.insert(author.clone()) {
+            additional.push(author);
+        }
+    }
+
+    let mut message = commit.message.to_vec();
+    for (id, source, _) in squashed {
+        while message.last().is_some_and(|byte| matches!(byte, b'\n' | b'\r')) {
+            message.pop();
+        }
+        let short = id
+            .attach(repo)
+            .shorten()
+            .context("could not shorten a squashed commit ID")?;
+        message.extend_from_slice(b"\n\n# ");
+        message.extend_from_slice(short.to_string().as_bytes());
+        message.push(b' ');
+        message.extend_from_slice(
+            gix::objs::commit::MessageRef::from_bytes(&source.message)
+                .summary()
+                .as_ref(),
+        );
+        message.extend_from_slice(b"\n\n");
+        message.extend_from_slice(&source.message);
+    }
+    if !additional.is_empty() {
+        let has_trailers = gix::objs::commit::MessageRef::from_bytes(&message)
+            .body()
+            .is_some_and(|body| body.trailers().next().is_some());
+        while message.last().is_some_and(|byte| matches!(byte, b'\n' | b'\r')) {
+            message.pop();
+        }
+        message.extend_from_slice(if has_trailers { b"\n" } else { b"\n\n" });
+        for (name, email) in additional {
+            message.extend_from_slice(b"Co-authored-by: ");
+            message.extend_from_slice(&name);
+            message.extend_from_slice(b" <");
+            message.extend_from_slice(&email);
+            message.extend_from_slice(b">\n");
+        }
+    }
+    commit.message = message.into();
+    Ok(())
+}
+
+fn author_identity(author: &gix::actor::Signature) -> (BString, BString) {
+    (
+        author.name.trim().to_owned().into(),
+        author.email.trim().to_owned().into(),
+    )
+}
+
+fn collect_co_authors(message: &[u8], out: &mut HashSet<(BString, BString)>) {
+    let Some(body) = gix::objs::commit::MessageRef::from_bytes(message).body() else {
+        return;
+    };
+    for trailer in body.trailers().co_authored_by() {
+        let mut value: &[u8] = trailer.value.as_ref();
+        let Ok(identity) = gix::actor::IdentityRef::from_bytes_consuming(&mut value) else {
+            continue;
+        };
+        if value.trim().is_empty() {
+            let identity = identity.trim();
+            out.insert((identity.name.to_owned(), identity.email.to_owned()));
+        }
+    }
+}
+
 fn rewritten_tree(
     repo: &gix::Repository,
     commit: &gix::objs::Commit,
@@ -1879,6 +1998,59 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_conflicting_todo_aborts_at_the_original_commit_without_observable_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let objects_before = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["count-objects", "-v"])
+            .output()?
+            .stdout;
+
+        let PlanPerform::Conflict(original) = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
+                }],
+                checkout: Some(0),
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        else {
+            return Err("the conflicting todo should abort before persistence".into());
+        };
+        assert_eq!(original, tip, "the diagnostic identifies the source delta");
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "refs, index, checkout, and worktree remain unchanged"
+        );
+        assert_eq!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["count-objects", "-v"])
+                .output()?
+                .stdout,
+            objects_before,
+            "the discarded object-memory transaction writes no objects"
+        );
+        Ok(())
+    }
+
     #[test]
     fn a_todo_rebase_eagerly_replays_only_the_checkout_ancestry_and_keeps_the_branch_at_the_leaf()
     -> gix_testtools::Result {
@@ -1901,14 +2073,17 @@ mod tests {
                     PlanStep {
                         parent: PlanParent::Existing(base),
                         commit: PlanCommit::Pick(tip),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(0),
                         commit: PlanCommit::Pick(middle),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(1),
                         commit: PlanCommit::Empty("checkpoint".into()),
+                        squash: Vec::new(),
                     },
                 ],
                 checkout: Some(0),
@@ -1981,6 +2156,105 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_todo_squash_materializes_one_commit_and_maps_every_source_to_it() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let tip_tree = repo.find_commit(tip)?.tree_id()?.detach();
+
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(middle),
+                    squash: vec![tip],
+                }],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        .complete()?;
+        let combined = outcome.map(middle).context("the first commit is retained")?;
+        assert_eq!(outcome.map(tip), Some(combined), "both source IDs map to one commit");
+        let commit = repo.find_commit(combined)?.decode()?.into_owned()?;
+        assert_eq!(commit.parents.as_slice(), [base]);
+        assert_eq!(commit.tree, tip_tree, "all source tree changes are present");
+        assert_eq!(commit.author.name, b"author".as_bstr());
+        assert_eq!(commit.committer.name, b"rebasing committer".as_bstr());
+        assert!(!has_marker(&commit), "squash is eager even without a checkout marker");
+        assert_eq!(
+            commit.message,
+            format!("middle\n\n# {} tip\n\ntip\n", tip.to_hex_with_len(7)).as_bytes(),
+            "the source title permanently identifies the appended full message"
+        );
+        assert_eq!(
+            repo.head_id()?.detach(),
+            combined,
+            "the branch follows the combined tip"
+        );
+        assert_eq!(
+            repo.find_reference("refs/patches/middle")?.id().detach(),
+            combined,
+            "a ref on the first source follows the combined commit"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn squash_messages_add_distinct_raw_authors_after_permanent_source_sections() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let mut first = repo.find_commit(base)?.decode()?.into_owned()?;
+        first.author.name = "Alice".into();
+        first.author.email = "alice@example.com".into();
+        first.message = "first title\n\nfirst body".into();
+
+        let mut bob = repo.find_commit(base)?.decode()?.into_owned()?;
+        bob.author.name = "Bob".into();
+        bob.author.email = "bob@example.com".into();
+        bob.message = "bob title\n\nbob body".into();
+        let mut carol = repo.find_commit(middle)?.decode()?.into_owned()?;
+        carol.author.name = "Carol".into();
+        carol.author.email = "carol@example.com".into();
+        carol.message = "carol title\n\nCo-authored-by: Bob <bob@example.com>".into();
+        let mut repeated_carol = repo.find_commit(tip)?.decode()?.into_owned()?;
+        repeated_carol.author = carol.author.clone();
+        repeated_carol.message = "carol follow-up".into();
+
+        squash_message(
+            &repo,
+            &mut first,
+            &[
+                (base, bob, Vec::new()),
+                (middle, carol, Vec::new()),
+                (tip, repeated_carol, Vec::new()),
+            ],
+        )?;
+        assert_eq!(
+            first.message,
+            format!(
+                "first title\n\nfirst body\n\n# {} bob title\n\nbob title\n\nbob body\n\n# {} carol title\n\ncarol title\n\nCo-authored-by: Bob <bob@example.com>\n\n# {} carol follow-up\n\ncarol follow-up\n\nCo-authored-by: Carol <carol@example.com>\n",
+                base.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+                tip.to_hex_with_len(7)
+            )
+            .as_bytes(),
+            "existing trailers suppress duplicates and repeated raw authors appear once"
+        );
+        Ok(())
+    }
+
     #[test]
     fn tip_refs_follow_the_primary_continuation_and_other_leaves_are_pinned() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -2006,14 +2280,17 @@ mod tests {
                     PlanStep {
                         parent: PlanParent::Existing(base),
                         commit: PlanCommit::Pick(tip),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(0),
                         commit: PlanCommit::Pick(middle),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(0),
                         commit: PlanCommit::Empty("side".into()),
+                        squash: Vec::new(),
                     },
                 ],
                 checkout: Some(0),
@@ -2058,10 +2335,12 @@ mod tests {
                     PlanStep {
                         parent: PlanParent::Existing(base),
                         commit: PlanCommit::Pick(middle),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(0),
                         commit: PlanCommit::Empty("replacement tip".into()),
+                        squash: Vec::new(),
                     },
                 ],
                 checkout: None,
@@ -2110,10 +2389,12 @@ mod tests {
                     PlanStep {
                         parent: PlanParent::Existing(onto),
                         commit: PlanCommit::Pick(middle),
+                        squash: Vec::new(),
                     },
                     PlanStep {
                         parent: PlanParent::Step(0),
                         commit: PlanCommit::Pick(tip),
+                        squash: Vec::new(),
                     },
                 ],
                 checkout: Some(1),
@@ -2163,6 +2444,7 @@ mod tests {
                 steps: vec![PlanStep {
                     parent: PlanParent::Existing(base),
                     commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
                 }],
                 checkout: None,
                 expected_refs,
@@ -2208,6 +2490,7 @@ mod tests {
                 steps: vec![PlanStep {
                     parent: PlanParent::Existing(base),
                     commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
                 }],
                 checkout: None,
                 expected_refs,
@@ -2266,6 +2549,7 @@ mod tests {
                 steps: vec![PlanStep {
                     parent: PlanParent::Existing(base),
                     commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
                 }],
                 checkout: None,
                 expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
@@ -2282,4 +2566,74 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn squashing_a_later_review_commit_removes_its_resources() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let old_middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+        let old_tip_tree = repo.find_commit(old_tip)?.tree_id()?.detach();
+        let mut middle = repo.find_commit(old_middle)?.decode()?.into_owned()?;
+        middle
+            .extra_headers
+            .push(("tix-rebase".into(), "onto refs/worktree/tix/review/1".into()));
+        let middle = repo.write_object(&middle)?.detach();
+        let mut tip = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        tip.parents = [middle].into_iter().collect();
+        let tip = repo.write_object(&tip)?.detach();
+        repo.reference(
+            "refs/worktree/tix/review/1",
+            old_middle,
+            PreviousValue::MustNotExist,
+            "test review resource",
+        )?;
+        repo.reference(
+            "refs/worktree/tix/review/stashes/1",
+            old_tip,
+            PreviousValue::MustNotExist,
+            "test review stash resource",
+        )?;
+        repo.reference(
+            "refs/heads/main",
+            tip,
+            PreviousValue::ExistingMustMatch(Target::Object(old_tip)),
+            "prepare review history",
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                    squash: vec![middle],
+                }],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        .complete()?;
+        let combined = outcome.map(tip).context("the first member remains")?;
+        assert_eq!(outcome.map(middle), Some(combined));
+        assert_eq!(
+            repo.find_commit(combined)?.tree_id()?.detach(),
+            old_tip_tree,
+            "reordered source deltas are composed into the combined tree"
+        );
+        assert!(
+            repo.try_find_reference("refs/worktree/tix/review/1")?.is_none(),
+            "the consumed review resource is removed"
+        );
+        assert!(
+            repo.try_find_reference("refs/worktree/tix/review/stashes/1")?.is_none(),
+            "the consumed review stash is removed"
+        );
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 8e2323d1516..0af4eb823ea 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -41,25 +41,6 @@ pub(crate) struct Conflict {
 }
 
 impl Conflict {
-    pub(crate) fn from_rebase(
-        repository_path: &Path,
-        bare: bool,
-        rebase: super::rebase::Conflict,
-        revisions: &[OsString],
-        include_worktrees: bool,
-    ) -> Result<Self> {
-        open_repository(repository_path, bare, false)?
-            .workdir()
-            .context("a conflicting rebase requires a worktree")?;
-        Ok(Conflict {
-            rebase,
-            repository_path: repository_path.to_owned(),
-            bare,
-            revisions: revisions.to_vec(),
-            include_worktrees,
-        })
-    }
-
     pub(crate) fn original(&self) -> ObjectId {
         self.rebase.original()
     }
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 3e4a2969967..9c1198e0059 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -16,13 +16,14 @@ const HELP: &str = r#"
 
 - Each fork section lists a stack from its oldest commit to its newest. Blank lines are ignored.
 - `pick <id>` keeps a commit. Delete its line to drop it, or move the line to reorder it. Each listed commit may be picked only once.
+- `squash <id>` folds a commit into the preceding command in the same fork. Its full message is retained with a source heading, and additional authors become `Co-authored-by` trailers.
 - `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
-- Prefix `pick` or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
+- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
 - Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Mutable refs on original leaves stay on the primary resulting leaf; the first continuation in todo order is primary. Other mutable refs follow their commits. Tags and remote-tracking refs stay unchanged, and new unreferenced leaves are pinned.
-- A checkout conflict uses tix's standard suspended-conflict flow; concurrent ref changes abort the update.
+- A todo conflict aborts without changing the repository and marks the offending commit in the history view; concurrent ref changes also abort the update.
 - Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
 -->
 "#;
@@ -471,12 +472,13 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
     };
     let scope: HashSet<_> = state.scope.iter().copied().collect();
     let mut picked = HashMap::<ObjectId, usize>::new();
-    let mut steps = Vec::new();
+    let mut steps = Vec::<rebase::PlanStep>::new();
     let mut cursor = None;
     let mut checkout = None;
     let mut marker_count = 0;
     let mut sections = 0;
     let mut section_has_commit = false;
+    let mut section_last_step = None;
     let mut in_comment = false;
 
     for raw in input.lines() {
@@ -514,6 +516,7 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
             });
             sections += 1;
             section_has_commit = false;
+            section_last_step = None;
             continue;
         }
 
@@ -537,6 +540,25 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
                 anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
             }
         }
+        if verb == "squash" {
+            let index = section_last_step.context("a squash must follow a command in the same fork")?;
+            let id = resolve_commit(
+                repo,
+                value.split_whitespace().next().context("a squash needs a commit ID")?,
+            )?;
+            if !scope.contains(&id) {
+                anyhow::bail!("a squash is outside the editable history");
+            }
+            if picked.insert(id, index).is_some() {
+                anyhow::bail!("a commit is picked more than once");
+            }
+            steps[index].squash.push(id);
+            if marked {
+                checkout = Some(index);
+            }
+            section_has_commit = true;
+            continue;
+        }
         let parent = cursor.context("the first todo command must follow a fork heading")?;
         let commit = match verb {
             "pick" => {
@@ -565,8 +587,13 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
         if let rebase::PlanCommit::Pick(id) = commit {
             picked.insert(id, index);
         }
-        steps.push(rebase::PlanStep { parent, commit });
+        steps.push(rebase::PlanStep {
+            parent,
+            commit,
+            squash: Vec::new(),
+        });
         cursor = Some(rebase::PlanParent::Step(index));
+        section_last_step = Some(index);
         if marked {
             checkout = Some(index);
         }
@@ -916,6 +943,45 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn squash_folds_into_the_previous_command_and_may_carry_checkout() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let edited = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\npick {}\n`@squash {}` ignored display metadata\n\n## fork {}\nempty side\n",
+                base.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+            ),
+        );
+        let plan = parse_plan(&repo, &edited)?;
+        assert_eq!(plan.steps.len(), 2, "squash does not produce another commit");
+        assert_eq!(plan.steps[0].squash, [tip]);
+        assert_eq!(plan.checkout, Some(0), "the squash marker selects the folded result");
+        assert_eq!(
+            plan.steps[1].parent,
+            rebase::PlanParent::Step(0),
+            "the squashed ID resolves to the folded result as a fork target"
+        );
+
+        let invalid = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\n@squash {}\npick {}\n",
+                base.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+            ),
+        );
+        let err = parse(&repo, &invalid).expect_err("a fork cannot begin with squash");
+        assert!(format!("{err:#}").contains("same fork"));
+        Ok(())
+    }
+
     #[test]
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 0a638edfd8e..efb0ba6bf20 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1585,6 +1585,11 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        if key_pressed && pending_rebase_conflict.is_none() && app.has_rebase_conflict() {
+            app.clear_rebase_conflict();
+            dirty = true;
+            urgent = true;
+        }
         if key_pressed && pending_rebase_conflict.is_some() {
             if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
                 let conflict = pending_rebase_conflict
@@ -2031,7 +2036,7 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(Some(edit::rebase::Perform::Complete(outcome))) => {
+                        Ok(Some(edit::rebase::PlanPerform::Complete(outcome))) => {
                             let checkout = outcome.selected;
                             let notice = checkout
                                 .map(|selected| {
@@ -2059,22 +2064,9 @@ fn event_loop(
                                 }
                             }
                         }
-                        Ok(Some(edit::rebase::Perform::Conflict(conflict))) => {
-                            match edit::time_travel::Conflict::from_rebase(
-                                &repository_path,
-                                repository_is_bare,
-                                conflict,
-                                &revisions,
-                                worktrees,
-                            ) {
-                                Ok(conflict) => {
-                                    let original = conflict.original();
-                                    app.arm_rebase_conflict(original);
-                                    app.select_commit(original);
-                                    pending_rebase_conflict = Some(conflict);
-                                }
-                                Err(err) => app.leave_message(format!("rebase conflict: {err:#}")),
-                            }
+                        Ok(Some(edit::rebase::PlanPerform::Conflict(original))) => {
+                            app.mark_todo_rebase_conflict(original);
+                            app.select_commit(original);
                         }
                         Ok(None) => app.leave_message("no rebase performed: the todo was unchanged"),
                         Err(err) => app.leave_message(format!("rebase: {err:#}")),
@@ -3177,7 +3169,7 @@ fn rebase_history(
     commits: Vec<edit::todo::Commit>,
     head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
-) -> Result<Option<edit::rebase::Perform>> {
+) -> Result<Option<edit::rebase::PlanPerform>> {
     let (prepared, editor) = {
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before rebasing")?;

From 50858878988e883ae80a978f961a4c5a9bf6461a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 06:58:42 +0200
Subject: [PATCH 102/282] fix: place tix rebase state after todo help

---
 gix-tix/spec.md          |  9 +++++----
 gix-tix/src/edit/todo.rs | 14 +++++++++-----
 2 files changed, 14 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bb9c8503080..a5b69bdef64 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -584,14 +584,15 @@ space first; changes blocks adapt within the remaining history width.
   trailer in any source message. Name and email pairs are compared without
   mailmap. All folded IDs and mutable refs map to the one resulting commit;
   resources owned by a later folded review commit are removed.
-- The first line points to complete self-documenting help at the bottom. All
-  instructions are enclosed in Markdown comments so only headings and command
-  lines participate in the editable plan.
+- The first line points to complete self-documenting help after the editable
+  todo. All instructions are enclosed in Markdown comments so only headings and
+  command lines participate in the editable plan.
 - A versioned Markdown state comment makes the document independently
   applicable in a later process. It records full base, target, scope and tip IDs,
   checkout requirements, and compare-and-swap state for mutable refs. Ref names
   use Git-compatible C-style quoting so arbitrary ref bytes round-trip. Missing
-  state cancels; present invalid state never reaches repository mutation.
+  state cancels; present invalid state never reaches repository mutation. The
+  state comment follows the complete help at the end of the document.
 - Pick lines use display-only state symbols documented in the footer: `↻` for a
   lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
   unverified signature, and `○` for an unsigned commit. Applicable states may be
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 9c1198e0059..b6f9fec1003 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -144,9 +144,7 @@ pub(crate) fn prepare(
         checkout_allowed: repo.workdir().is_some(),
         expected_refs,
     };
-    let mut document = b"<!-- Rebase help is at the bottom of this file. -->\n".to_vec();
-    write_state(&mut document, &state);
-    document.push(b'\n');
+    let mut document = b"<!-- Rebase help follows the editable todo. -->\n".to_vec();
     document.extend_from_slice(title.as_bytes());
     document.extend_from_slice(b"\n\n");
     let anchor_kind = if base == onto {
@@ -186,6 +184,7 @@ pub(crate) fn prepare(
         write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
     }
     document.extend_from_slice(HELP.as_bytes());
+    write_state(&mut document, &state);
     Ok(Prepared {
         document,
         apply_unchanged,
@@ -705,7 +704,7 @@ mod tests {
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         assert!(!prepared.apply_unchanged);
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.starts_with("<!-- Rebase help is at the bottom of this file. -->"));
+        assert!(document.starts_with("<!-- Rebase help follows the editable todo. -->"));
         assert!(document.contains(STATE_START), "the todo carries its transaction state");
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
         assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
@@ -720,7 +719,12 @@ mod tests {
             document.find("# Rebase todo help").expect("help is present") > tip,
             "complete instructions follow the editable todo"
         );
-        assert!(document.ends_with("-->\n"), "all trailing help is one Markdown comment");
+        assert!(
+            document.find(STATE_START).expect("state is present")
+                > document.find("# Rebase todo help").expect("help is present"),
+            "transaction state follows the complete help"
+        );
+        assert!(document.ends_with("-->\n"), "the trailing state is a Markdown comment");
         assert!(
             document.contains("○"),
             "unsigned commits carry the documented status symbol"

From 4882d0ce44dddbd039c0de566a562893d54c4f6c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 07:23:25 +0200
Subject: [PATCH 103/282] feat: show progress while applying tix rebase todos

---
 gix-tix/spec.md            |   7 ++
 gix-tix/src/edit/rebase.rs | 178 ++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs         |  85 +++++++++++++++++-
 gix-tix/src/ui.rs          |  77 +++++++++++++++-
 4 files changed, 334 insertions(+), 13 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a5b69bdef64..e48559ab6ec 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -609,6 +609,13 @@ space first; changes blocks adapt within the remaining history width.
   selects the original offending commit and marks it with a transient blinking
   red `C`; command-line apply reports that commit as an error. Suspended conflict
   checkout remains available only to direct edits and time travel.
+- Interactive todo application runs on a scoped worker so the terminal can
+  remain renderable without cloning the cached history graph. If application is
+  still running after 300 ms, a modal gauge shows processed versus total todo
+  source commits and live cherry-pick and signature counts with their cumulative
+  durations. `pick`, `squash`, and `empty` commands each contribute to the total;
+  squash sources advance separately while their combined commit is signed once.
+  Fast operations and command-line `tix rebase apply` do not show progress.
 - Mutable refs captured on original leaves stay tips: after their commit is
   rewritten or dropped, they follow the first continuation in todo order to its
   resulting leaf. Other mutable refs remain bound to their rewritten commit.
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index b04e08d2419..fee7b38a9ff 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -2,6 +2,7 @@ use std::{
     collections::{HashMap, HashSet},
     path::PathBuf,
     process::Command,
+    time::{Duration, Instant},
 };
 
 use anyhow::{Context, Result};
@@ -106,6 +107,25 @@ pub(crate) struct Plan {
     pub expected_refs: Vec<ExpectedRef>,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) struct PlanProgress {
+    pub total: usize,
+    pub processed: usize,
+    pub cherry_picked: usize,
+    pub signed: usize,
+    pub cherry_pick_time: Duration,
+    pub signing_time: Duration,
+}
+
+impl PlanProgress {
+    fn new(plan: &Plan) -> Self {
+        PlanProgress {
+            total: plan.steps.len() + plan.steps.iter().map(|step| step.squash.len()).sum::<usize>(),
+            ..PlanProgress::default()
+        }
+    }
+}
+
 pub(crate) enum PlanPerform {
     Complete(Outcome),
     Conflict(ObjectId),
@@ -641,8 +661,19 @@ pub(super) fn finish_review(
     prepared.finish()
 }
 
+pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: Plan) -> Result<PlanPerform> {
+    perform_plan_with_progress(repo, graph, plan, |_| {})
+}
+
 #[tracing::instrument(skip_all, fields(base = %plan.base, steps = plan.steps.len()))]
-pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut plan: Plan) -> Result<PlanPerform> {
+pub(crate) fn perform_plan_with_progress(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    mut plan: Plan,
+    mut report: impl FnMut(PlanProgress),
+) -> Result<PlanPerform> {
+    let mut progress = PlanProgress::new(&plan);
+    report(progress);
     let mut repo = repo.clone();
     let signing = repo
         .commit_signing_options_if_enabled()
@@ -734,6 +765,7 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         } else {
             Tree::LeaveAsIsAndMark
         };
+        let cherry_pick_started = (eager && matches!(step.commit, PlanCommit::Pick(_))).then(Instant::now);
         commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
             TreeRewrite::Conflict { .. } => {
@@ -743,6 +775,14 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
                 return Ok(PlanPerform::Conflict(original));
             }
         };
+        if let Some(started) = cherry_pick_started {
+            progress.cherry_picked += 1;
+            progress.cherry_pick_time += started.elapsed();
+        }
+        if matches!(step.commit, PlanCommit::Pick(_)) {
+            progress.processed += 1;
+            report(progress);
+        }
         let mut squashed = Vec::with_capacity(step.squash.len());
         for id in &step.squash {
             let source = repo
@@ -764,10 +804,15 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
             squash_message(&repo, &mut commit, &squashed)?;
             for (id, source, replay_parents) in &squashed {
                 let old_base = parent_tree(&repo, replay_parents.first().copied())?;
+                let started = Instant::now();
                 commit.tree = match cherry_pick_tree_outcome(&repo, old_base, commit.tree, source.tree)? {
                     TreeRewrite::Complete(tree) => tree,
                     TreeRewrite::Conflict { .. } => return Ok(PlanPerform::Conflict(*id)),
                 };
+                progress.cherry_picked += 1;
+                progress.cherry_pick_time += started.elapsed();
+                progress.processed += 1;
+                report(progress);
                 delete_refs.extend(super::review::deletions(&repo, source)?);
             }
         }
@@ -780,7 +825,15 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
                 original_parent: recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
             }
         };
-        let new_id = write_commit(&repo, commit, state, signing.clone())?;
+        let (new_id, signing_time) = write_commit_timed(&repo, commit, state, signing.clone())?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        if matches!(step.commit, PlanCommit::Empty(_)) {
+            progress.processed += 1;
+        }
+        report(progress);
         if let PlanCommit::Pick(old_id) = step.commit {
             rewritten.insert(old_id, Some(new_id));
         }
@@ -877,6 +930,15 @@ pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, mut pla
         pins,
         delete_refs,
     };
+    tracing::info!(
+        total = progress.total,
+        processed = progress.processed,
+        cherry_picked = progress.cherry_picked,
+        signed = progress.signed,
+        cherry_pick_ms = progress.cherry_pick_time.as_millis(),
+        signing_ms = progress.signing_time.as_millis(),
+        "prepared rebase plan"
+    );
     Ok(PlanPerform::Complete(prepared.finish()?))
 }
 
@@ -1315,10 +1377,19 @@ pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
 
 fn write_commit(
     repo: &gix::Repository,
-    mut commit: gix::objs::Commit,
+    commit: gix::objs::Commit,
     state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<ObjectId> {
+    Ok(write_commit_timed(repo, commit, state, signing)?.0)
+}
+
+fn write_commit_timed(
+    repo: &gix::Repository,
+    mut commit: gix::objs::Commit,
+    state: CommitState,
+    signing: Option<gix::objs::commit::signature::Options>,
+) -> Result<(ObjectId, Option<Duration>)> {
     let signature = match state {
         CommitState::Unmarked(signature) => {
             marker(&mut commit, false, None);
@@ -1331,8 +1402,14 @@ fn write_commit(
     };
     let had_signature = commit.extra_headers.iter().any(|(name, _)| is_signature(name));
     commit.extra_headers.retain(|(name, _)| !is_signature(name));
+    let mut signing_time = None;
     commit = match (signature, signing) {
-        (Signature::RedoIfNeeded, Some(options)) => commit.sign(options).context("could not sign rebased commit")?,
+        (Signature::RedoIfNeeded, Some(options)) => {
+            let started = Instant::now();
+            let signed = commit.sign(options).context("could not sign rebased commit")?;
+            signing_time = Some(started.elapsed());
+            signed
+        }
         (Signature::InvalidateExisting, Some(_)) if had_signature => {
             let field = gix::objs::commit::signature_field_name(commit.tree.kind());
             commit.extra_headers.push((field.into(), BString::default()));
@@ -1341,10 +1418,12 @@ fn write_commit(
         (Signature::Remove, _) => commit,
         _ => commit,
     };
-    Ok(repo
-        .write_object(&commit)
-        .context("could not prepare rebased commit")?
-        .detach())
+    Ok((
+        repo.write_object(&commit)
+            .context("could not prepare rebased commit")?
+            .detach(),
+        signing_time,
+    ))
 }
 
 fn is_signature(name: &BString) -> bool {
@@ -2063,7 +2142,8 @@ mod tests {
         let old_middle_tree = repo.find_commit(middle)?.tree_id()?.detach();
         let expected_refs = capture_refs(&repo, &[middle, tip], &[tip])?;
 
-        let outcome = perform_plan(
+        let mut progress = Vec::new();
+        let outcome = perform_plan_with_progress(
             &repo,
             &graph,
             Plan {
@@ -2089,8 +2169,18 @@ mod tests {
                 checkout: Some(0),
                 expected_refs,
             },
+            |update| progress.push(update),
         )?
         .complete()?;
+        let progress = progress.last().context("rebase progress is reported")?;
+        assert_eq!(progress.total, 3, "every todo command contributes to the total");
+        assert_eq!(progress.processed, 3, "eager, lazy, and empty commands are processed");
+        assert_eq!(progress.cherry_picked, 1, "only the checkout ancestry is eager");
+        assert_eq!(progress.signed, 0, "signing is counted only when configured");
+        assert!(
+            progress.cherry_pick_time > Duration::ZERO,
+            "cherry-pick time accumulates"
+        );
         let new_tip = outcome.map(tip).context("the picked tip is retained")?;
         let new_middle = outcome.map(middle).context("the picked middle is retained")?;
         assert_eq!(
@@ -2166,7 +2256,8 @@ mod tests {
         let tip = repo.head_id()?.detach();
         let tip_tree = repo.find_commit(tip)?.tree_id()?.detach();
 
-        let outcome = perform_plan(
+        let mut progress = Vec::new();
+        let outcome = perform_plan_with_progress(
             &repo,
             &graph,
             Plan {
@@ -2180,8 +2271,14 @@ mod tests {
                 checkout: None,
                 expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
+            |update| progress.push(update),
         )?
         .complete()?;
+        let progress = progress.last().context("squash progress is reported")?;
+        assert_eq!(progress.total, 2, "both squash source commits contribute to the total");
+        assert_eq!(progress.processed, 2);
+        assert_eq!(progress.cherry_picked, 2, "both source trees are replayed eagerly");
+        assert_eq!(progress.signed, 0, "the fixture has no signer configured");
         let combined = outcome.map(middle).context("the first commit is retained")?;
         assert_eq!(outcome.map(tip), Some(combined), "both source IDs map to one commit");
         let commit = repo.find_commit(combined)?.decode()?.into_owned()?;
@@ -2208,6 +2305,67 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_squash_group_reports_one_configured_signature() -> gix_testtools::Result {
+        if !gix_testtools::signature::program_available("ssh-keygen") {
+            return Ok(());
+        }
+        let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "user.name=rebasing committer".to_owned(),
+                "user.email=rebasing@example.com".to_owned(),
+                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
+                "commit.gpgSign=true".to_owned(),
+                "gpg.format=ssh".to_owned(),
+                format!("user.signingKey={}", key.display()),
+                format!(
+                    "gpg.ssh.allowedSignersFile={}",
+                    gix_testtools::signature::fixture("ssh-allowed-signers").display()
+                ),
+            ]),
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let mut updates = Vec::new();
+
+        let outcome = perform_plan_with_progress(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(middle),
+                    squash: vec![tip],
+                }],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+            |progress| updates.push(progress),
+        )?
+        .complete()?;
+        let progress = updates.last().context("signed progress is reported")?;
+        assert_eq!(progress.total, 2);
+        assert_eq!(progress.processed, 2);
+        assert_eq!(progress.cherry_picked, 2);
+        assert_eq!(progress.signed, 1, "the combined result is signed only once");
+        assert!(progress.signing_time > Duration::ZERO, "signing time accumulates");
+        assert!(
+            repo.find_commit(outcome.map(middle).context("the squash result is retained")?)?
+                .verify_signature()?
+                .expect("the squash result is signed")
+                .is_valid(),
+            "the reported signature is valid"
+        );
+        Ok(())
+    }
+
     #[test]
     fn squash_messages_add_distinct_raw_authors_after_permanent_source_sections() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index efb0ba6bf20..47bb07564fb 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -52,6 +52,7 @@ use ratatui::{backend::CrosstermBackend, text::Line};
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
+const REBASE_PROGRESS_DELAY: Duration = Duration::from_millis(300);
 const HISTORY_STATUS_DELAY: Duration = Duration::from_millis(500);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
@@ -3204,7 +3205,83 @@ fn rebase_history(
     let Some(parsed) = edit::todo::parse(&repository, &edited)? else {
         return Ok(None);
     };
-    edit::rebase::perform_plan(&repository, graph, parsed.plan).map(Some)
+    run_rebase_plan(terminal, repository.into_sync(), graph, parsed.plan).map(Some)
+}
+
+enum RebaseWorkerEvent {
+    Progress(edit::rebase::PlanProgress),
+    Complete(Result<edit::rebase::PlanPerform>),
+}
+
+fn run_rebase_plan(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository: gix::ThreadSafeRepository,
+    graph: &HistoryGraph,
+    plan: edit::rebase::Plan,
+) -> Result<edit::rebase::PlanPerform> {
+    std::thread::scope(|scope| {
+        let (sender, receiver) = mpsc::sync_channel(1);
+        let worker = scope.spawn(move || {
+            let mut repository = repository.to_thread_local();
+            repository.object_cache_size(None);
+            let result = edit::rebase::perform_plan_with_progress(&repository, graph, plan, |progress| {
+                let _ = sender.try_send(RebaseWorkerEvent::Progress(progress));
+            });
+            let _ = sender.send(RebaseWorkerEvent::Complete(result));
+        });
+        let started = Instant::now();
+        let mut last_draw = started;
+        let mut latest = None;
+        let mut rendered = None;
+        let result = loop {
+            let now = Instant::now();
+            let timeout = if now.duration_since(started) < REBASE_PROGRESS_DELAY {
+                Some(REBASE_PROGRESS_DELAY.saturating_sub(now.duration_since(started)))
+            } else if latest != rendered {
+                Some(FRAME_INTERVAL.saturating_sub(now.duration_since(last_draw)))
+            } else {
+                None
+            };
+            let event = match timeout {
+                Some(timeout) => match receiver.recv_timeout(timeout) {
+                    Ok(event) => Some(event),
+                    Err(mpsc::RecvTimeoutError::Timeout) => None,
+                    Err(mpsc::RecvTimeoutError::Disconnected) => {
+                        break Err(anyhow::anyhow!("rebase worker stopped unexpectedly"));
+                    }
+                },
+                None => match receiver.recv() {
+                    Ok(event) => Some(event),
+                    Err(_) => break Err(anyhow::anyhow!("rebase worker stopped unexpectedly")),
+                },
+            };
+            match event {
+                Some(RebaseWorkerEvent::Progress(progress)) => latest = Some(progress),
+                Some(RebaseWorkerEvent::Complete(result)) => break result,
+                None => {}
+            }
+            let now = Instant::now();
+            if rebase_progress_visible(now.duration_since(started))
+                && latest != rendered
+                && now.duration_since(last_draw) >= FRAME_INTERVAL
+            {
+                let progress = latest.expect("a changed progress snapshot is available");
+                if let Err(err) = terminal.draw(|frame| ui::draw_rebase_progress(frame, progress)) {
+                    break Err(err).context("could not draw rebase progress");
+                }
+                rendered = latest;
+                last_draw = now;
+            }
+        };
+        if worker.join().is_err() {
+            return Err(anyhow::anyhow!("rebase worker panicked"));
+        }
+        result
+    })
+}
+
+fn rebase_progress_visible(elapsed: Duration) -> bool {
+    elapsed >= REBASE_PROGRESS_DELAY
 }
 
 #[derive(Clone, Copy)]
@@ -5486,4 +5563,10 @@ mod tests {
         );
         assert!(take_due(&mut deadline, last_event + REF_EVENT_IDLE));
     }
+
+    #[test]
+    fn rebase_progress_appears_at_three_hundred_milliseconds() {
+        assert!(!rebase_progress_visible(Duration::from_millis(299)));
+        assert!(rebase_progress_visible(REBASE_PROGRESS_DELAY));
+    }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7f88b30e6c4..5075006489b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1,10 +1,10 @@
 use gix::bstr::{BStr, BString, ByteSlice};
 use ratatui::{
     Frame,
-    layout::{Constraint, Layout, Margin, Rect},
+    layout::{Alignment, Constraint, Layout, Margin, Rect},
     style::{Color, Modifier, Style},
     text::{Line, Span, Text},
-    widgets::{Block, Borders, Clear, Paragraph, Wrap},
+    widgets::{Block, Borders, Clear, Gauge, Paragraph, Wrap},
 };
 
 use crate::{
@@ -22,6 +22,53 @@ const FILESYSTEM_NOTIFICATION_COLOR: Color = Color::Rgb(255, 165, 0);
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
+pub(crate) fn draw_rebase_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::PlanProgress) {
+    let area = frame.area();
+    frame.render_widget(Clear, area);
+    let width = area.width.min(72);
+    let height = area.height.min(4);
+    let progress_area = Rect::new(
+        area.x + area.width.saturating_sub(width) / 2,
+        area.y + area.height.saturating_sub(height) / 2,
+        width,
+        height,
+    );
+    let rows = Layout::vertical([Constraint::Length(1); 4]).split(progress_area);
+    frame.render_widget(
+        Paragraph::new("Rebasing commits")
+            .alignment(Alignment::Center)
+            .style(Style::default().add_modifier(Modifier::BOLD)),
+        rows[0],
+    );
+    let ratio = if progress.total == 0 {
+        1.0
+    } else {
+        progress.processed.min(progress.total) as f64 / progress.total as f64
+    };
+    frame.render_widget(
+        Gauge::default()
+            .ratio(ratio)
+            .label(format!("{} / {} commits", progress.processed, progress.total))
+            .gauge_style(Style::default().fg(Color::LightBlue)),
+        rows[1],
+    );
+    frame.render_widget(
+        Paragraph::new(format!(
+            "cherry-picked {} · {:.1?}",
+            progress.cherry_picked, progress.cherry_pick_time
+        ))
+        .alignment(Alignment::Center)
+        .style(Style::default().fg(Color::LightYellow)),
+        rows[2],
+    );
+    frame.render_widget(
+        Paragraph::new(format!("signed {} · {:.1?}", progress.signed, progress.signing_time))
+            .alignment(Alignment::Center)
+            .style(Style::default().fg(Color::Green)),
+        rows[3],
+    );
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 struct ChangesPaneArea {
     pane: ChangePane,
@@ -1973,6 +2020,32 @@ mod tests {
         assert!(spans[1].style.add_modifier.contains(Modifier::DIM));
     }
 
+    #[test]
+    fn renders_rebase_progress_with_operation_counts_and_times() -> Result<(), Box<dyn std::error::Error>> {
+        let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
+        terminal.draw(|frame| {
+            draw_rebase_progress(
+                frame,
+                crate::edit::rebase::PlanProgress {
+                    total: 100,
+                    processed: 42,
+                    cherry_picked: 31,
+                    signed: 28,
+                    cherry_pick_time: std::time::Duration::from_millis(1234),
+                    signing_time: std::time::Duration::from_millis(45),
+                },
+            );
+        })?;
+        assert_eq!(rendered_line(&terminal, 2).trim(), "Rebasing commits");
+        assert!(
+            rendered_line(&terminal, 3).contains("42 / 100 commits"),
+            "the gauge labels current and total source commits"
+        );
+        assert_eq!(rendered_line(&terminal, 4).trim(), "cherry-picked 31 · 1.2s");
+        assert_eq!(rendered_line(&terminal, 5).trim(), "signed 28 · 45.0ms");
+        Ok(())
+    }
+
     #[test]
     fn counts_commits_until_the_graph_is_complete_then_tracks_the_selected_row() {
         let mut app = App::new(3);

From 8833d56050a39fb32d713648a0e7a8b8878cd43e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 10:00:56 +0200
Subject: [PATCH 104/282] feat: continue tix rebase todos through conflicts

Keep todo conflicts fully in memory by default, while allowing the TUI and an explicit CLI flag to materialize the partial result with an ordinary unmerged index.

Serialize the remaining editable operation as a self-contained continuation todo, retain unapplied squash sources, move only final references, and resume from the resolved index without hidden sequencer state.
---
 gix-tix/spec.md                 |  28 +++-
 gix-tix/src/app.rs              |  19 ---
 gix-tix/src/command.rs          |  17 +++
 gix-tix/src/command/rebase.rs   | 185 +++++++++++++++++++++++--
 gix-tix/src/edit/rebase.rs      | 233 ++++++++++++++++++++++++++++----
 gix-tix/src/edit/time_travel.rs |  17 +++
 gix-tix/src/edit/todo.rs        | 194 ++++++++++++++++++++++++--
 gix-tix/src/lib.rs              | 223 +++++++++++++++++++++++++++++-
 8 files changed, 840 insertions(+), 76 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e48559ab6ec..d2ca104c6d8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -28,6 +28,12 @@ without trading responsiveness for metadata that is not visible.
 - `tix rebase apply [FILE]` applies such a plan from a file, or from standard
   input when `FILE` is omitted or `-`. Removing its state comment or emptying the
   document cancels successfully; malformed or unsupported state is an error.
+- By default, a todo conflict changes nothing. Explicit
+  `--materialize-conflicts [CONTINUE]` accepts the partial result, checks out the
+  conflicting commit with an unmerged index, and writes a fresh editable
+  continuation todo to `CONTINUE`, or stdout when `-` is used. A terminal stdout
+  is refused. Materialization exits unsuccessfully so scripts cannot mistake the
+  incomplete rebase for completion.
 - Editor-launching commands honor Git's normal editor selection and
   `GIT_EDITOR` overrides it.
 - Revisions must resolve and peel to commits. Invalid or non-commit visible
@@ -604,11 +610,23 @@ space first; changes blocks adapt within the remaining history width.
   and re-signed. Other resulting stacks retain their trees, receive pending-rebase
   markers, and invalidate old signatures for later time travel. With no `@`,
   ordinary steps remain lazy while squash groups are still materialized.
-  Any conflict while applying a history todo aborts the entire in-memory
-  transaction without writing objects, refs, index, or worktree state. The TUI
-  selects the original offending commit and marks it with a transient blinking
-  red `C`; command-line apply reports that commit as an error. Suspended conflict
-  checkout remains available only to direct edits and time travel.
+  Any conflict while applying a history todo first remains entirely in memory.
+  The TUI projects the partial result, selects the actual conflicting result, and
+  marks it with a blinking red `C`; predicted ref decorations remain at their
+  repository positions. `<enter>` accepts the partial result, moves already-final
+  refs, checks out the conflicting tree with an unmerged index, and retains an
+  in-memory continuation plan. Any other key discards the preview without writes.
+  Once the index has no unresolved stages, `<enter>` continues; another conflict
+  repeats the same choice.
+- Command-line apply reports a conflict without changes unless
+  `--materialize-conflicts` was explicitly supplied. Its continuation document
+  uses the full null object ID for the command whose tree must come from the
+  resolved index. Already produced commits use their new IDs, completed drops and
+  squash sources disappear, unapplied squash sources remain, and the remaining
+  todo stays editable. Applying it
+  requires only that `HEAD` names a commit and the index has no unresolved stages;
+  the index tree, including additional staged changes, becomes the resolved tree.
+  There is no hidden sequencer state or separate continue/abort command.
 - Interactive todo application runs on a scoped worker so the terminal can
   remain renderable without cloning the cached history graph. If application is
   still running after 300 ms, a modal gauge shows processed versus total todo
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index f51d1f416f1..3cd8953404b 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -587,15 +587,6 @@ impl App {
         self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
     }
 
-    pub(crate) fn mark_todo_rebase_conflict(&mut self, id: ObjectId) {
-        tracing::warn!(commit_id = %id, "todo rebase aborted on conflict");
-        self.pending_rebase_conflict = Some(id);
-        self.leave_message(format!(
-            "rebase aborted · conflict at {} · repository unchanged",
-            id.to_hex_with_len(7)
-        ));
-    }
-
     pub(crate) fn has_rebase_conflict(&self) -> bool {
         self.pending_rebase_conflict.is_some()
     }
@@ -2755,16 +2746,6 @@ mod tests {
         assert!(!app.time_travel_shortcut_visible());
         app.clear_rebase_conflict();
         assert!(app.time_travel_shortcut_visible());
-
-        app.mark_todo_rebase_conflict(id(1));
-        assert!(app.has_rebase_conflict());
-        assert!(
-            app.message
-                .as_deref()
-                .is_some_and(|message| message.contains("repository unchanged")),
-            "an aborted todo explains that no state was materialized"
-        );
-        app.clear_rebase_conflict();
     }
 
     #[test]
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index dcae8d8fbef..0da79c5c25f 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -207,6 +207,23 @@ mod tests {
                 .command,
             Some(Command::Rebase(rebase::Command::Apply(_)))
         ));
+        let parsed = Cli::try_parse_from([
+            "tix",
+            "rebase",
+            "apply",
+            "--materialize-conflicts",
+            "continue.md",
+            "todo.md",
+        ])
+        .expect("conflict materialization output parses");
+        let Some(Command::Rebase(rebase::Command::Apply(args))) = parsed.platform.command else {
+            panic!("rebase apply was expected")
+        };
+        assert_eq!(
+            args.materialize_conflicts.as_deref(),
+            Some(std::path::Path::new("continue.md"))
+        );
+        assert_eq!(args.file.as_deref(), Some(std::path::Path::new("todo.md")));
         assert!(
             Cli::command()
                 .render_help()
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index b0ccb140fb7..5d36761d01e 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -1,7 +1,7 @@
 use std::{
     collections::HashMap,
     ffi::{OsStr, OsString},
-    io::{Read, Write},
+    io::{IsTerminal, Read, Write},
     path::{Path, PathBuf},
     sync::atomic::AtomicBool,
 };
@@ -21,6 +21,9 @@ pub(super) enum Command {
     #[command(disable_help_flag = true)]
     Todo(Todo),
     /// Apply a self-contained rebase todo from FILE or standard input.
+    #[command(
+        after_long_help = "Conflicts change nothing by default. To opt in, write the continuation only when needed:\n  tix rebase apply --materialize-conflicts todo.continue.md todo.md\nResolve the index, then run:\n  tix rebase apply todo.continue.md\nUse --materialize-conflicts=- to write a continuation to non-terminal stdout."
+    )]
     Apply(Apply),
 }
 
@@ -48,9 +51,12 @@ pub(super) struct Todo {
 
 #[derive(Debug, clap::Args)]
 pub(super) struct Apply {
+    /// On conflict, materialize it and write a continuation todo to FILE, or stdout if omitted or '-'.
+    #[arg(long, value_name = "CONTINUE", num_args = 0..=1, default_missing_value = "-")]
+    pub(super) materialize_conflicts: Option<PathBuf>,
     /// Todo file to apply; omit or use '-' to read standard input.
     #[arg(value_name = "FILE")]
-    file: Option<PathBuf>,
+    pub(super) file: Option<PathBuf>,
 }
 
 pub(super) fn run(repo: gix::Repository, command: Command) -> Result<()> {
@@ -76,7 +82,7 @@ fn todo(repo: gix::Repository, args: Todo) -> Result<()> {
         &format!("tix-rebase-{}.md", std::process::id()),
     )?
     .unwrap_or(prepared.document);
-    apply_document(repo, &edited)
+    apply_document(repo, &edited, None)
 }
 
 fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
@@ -222,10 +228,10 @@ fn apply(repo: gix::Repository, args: Apply) -> Result<()> {
                 std::fs::read(path).with_context(|| format!("could not read rebase todo at {}", path.display()))?;
         }
     }
-    apply_document(repo, &document)
+    apply_document(repo, &document, args.materialize_conflicts.as_deref())
 }
 
-fn apply_document(repo: gix::Repository, document: &[u8]) -> Result<()> {
+fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts: Option<&Path>) -> Result<()> {
     let Some(parsed) = todo::parse(&repo, document)? else {
         println!("no rebase performed: the todo was cancelled");
         return Ok(());
@@ -246,10 +252,54 @@ fn apply_document(repo: gix::Repository, document: &[u8]) -> Result<()> {
             }
             Ok(())
         }
-        rebase::PlanPerform::Conflict(original) => anyhow::bail!(
-            "rebase aborted without changes: conflict while applying {}",
-            original.to_hex_with_len(7)
-        ),
+        rebase::PlanPerform::Conflict(conflict) => {
+            let Some(destination) = materialize_conflicts else {
+                anyhow::bail!(
+                    "rebase aborted without changes: conflict while applying {}; pass --materialize-conflicts to opt in",
+                    conflict.original().to_hex_with_len(7)
+                );
+            };
+            if destination == Path::new("-") && std::io::stdout().is_terminal() {
+                anyhow::bail!(
+                    "rebase aborted without changes: refusing to materialize a conflict without a continuation output file"
+                );
+            }
+            let plan = conflict.continuation_plan();
+            let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
+            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips)?.document;
+            let revisions = mapped_revisions(&tips, |id| conflict.map(id));
+            if destination == Path::new("-") {
+                let mut stdout = std::io::stdout().lock();
+                stdout
+                    .write_all(&continuation)
+                    .and_then(|_| stdout.flush())
+                    .context("could not write the continuation rebase todo")?;
+            } else {
+                let mut output = std::fs::OpenOptions::new()
+                    .write(true)
+                    .create_new(true)
+                    .open(destination)
+                    .with_context(|| {
+                        format!("could not create continuation rebase todo at {}", destination.display())
+                    })?;
+                output.write_all(&continuation).with_context(|| {
+                    format!("could not write continuation rebase todo at {}", destination.display())
+                })?;
+            }
+            let materialized =
+                edit::time_travel::materialize_plan_conflict(conflict, &repository_path, bare, &revisions, false);
+            let (notice, _) = match materialized {
+                Ok(materialized) => materialized,
+                Err(err) => {
+                    if destination != Path::new("-") {
+                        let _ = std::fs::remove_file(destination);
+                    }
+                    return Err(err);
+                }
+            };
+            eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
+            anyhow::bail!("rebase stopped at a materialized conflict")
+        }
     }
 }
 
@@ -263,6 +313,7 @@ fn mapped_revisions(tips: &[ObjectId], mut map: impl FnMut(ObjectId) -> Option<O
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::process::Command;
 
     fn repository() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -322,4 +373,120 @@ mod tests {
         assert!(format!("{err:#}").contains("at least one -h/--hide"));
         Ok(())
     }
+
+    #[test]
+    fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "commit.gpgSign=false".to_owned(),
+                "user.name=todo author".to_owned(),
+                "user.email=todo@example.com".to_owned(),
+            ]),
+        )?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let prepared = todo::prepare(
+            &repo,
+            base,
+            base,
+            &[
+                todo::Commit {
+                    id: tip,
+                    parents: vec![middle],
+                    info: "tip".into(),
+                },
+                todo::Commit {
+                    id: middle,
+                    parents: vec![base],
+                    info: "middle".into(),
+                },
+            ],
+            Some(tip),
+            &[tip],
+            todo::OntoKind::Onto,
+        )?;
+        let generated = std::str::from_utf8(&prepared.document)?;
+        let state = &generated[generated
+            .find("<!-- tix-rebase-state-v1")
+            .expect("generated state is present")..];
+        let edited = format!(
+            "## fork {}\n`@pick {}` tip\n\n{state}",
+            base.to_hex_with_len(7),
+            tip.to_hex_with_len(7)
+        );
+        let output_dir = gix_testtools::tempfile::tempdir()?;
+        let output = output_dir.path().join("continue.md");
+        let err = apply_document(repo, edited.as_bytes(), Some(&output)).expect_err("the conflict stops the command");
+        assert!(format!("{err:#}").contains("materialized conflict"));
+        let continuation = std::fs::read(&output)?;
+        assert!(
+            continuation
+                .windows(40)
+                .any(|window| window.iter().all(|byte| *byte == b'0')),
+            "the conflicting command is represented by the full null object ID"
+        );
+        let unresolved = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["diff", "--name-only", "--diff-filter=U"])
+            .output()?;
+        assert!(unresolved.status.success());
+        assert_eq!(
+            unresolved.stdout, b"file\n",
+            "materialization writes the unmerged index"
+        );
+
+        std::fs::write(fixture.path().join("file"), b"resolved\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "file"])
+                .status()?
+                .success()
+        );
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "commit.gpgSign=false".to_owned(),
+                "user.name=todo author".to_owned(),
+                "user.email=todo@example.com".to_owned(),
+            ]),
+        )?;
+        apply_document(repo, &continuation, None)?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["diff", "--name-only", "--diff-filter=U"])
+                .output()?
+                .stdout
+                .is_empty(),
+            "the continuation consumes the resolved index"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn successful_apply_does_not_create_a_continuation_file() -> gix_testtools::Result {
+        let (_fixture, repo) = repository()?;
+        let prepared = prepare(
+            &repo,
+            &Todo {
+                help: None,
+                hide: vec!["HEAD~2".into()],
+                onto: None,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )?;
+        let output_dir = gix_testtools::tempfile::tempdir()?;
+        let output = output_dir.path().join("unused.md");
+        apply_document(repo, &prepared.document, Some(&output))?;
+        assert!(!output.exists(), "continuation output is created only after a conflict");
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index fee7b38a9ff..4701f446770 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -80,6 +80,7 @@ pub(crate) enum PlanParent {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum PlanCommit {
     Pick(ObjectId),
+    Resolved(ObjectId),
     Empty(BString),
 }
 
@@ -90,15 +91,16 @@ pub(crate) struct PlanStep {
     pub squash: Vec<ObjectId>,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub(crate) struct ExpectedRef {
     pub name: gix::refs::FullName,
     pub old: ObjectId,
+    pub target: ObjectId,
     pub new: ObjectId,
     pub follows_tip: bool,
 }
 
-#[derive(Debug)]
+#[derive(Clone, Debug)]
 pub(crate) struct Plan {
     pub base: ObjectId,
     pub scope: Vec<ObjectId>,
@@ -128,7 +130,7 @@ impl PlanProgress {
 
 pub(crate) enum PlanPerform {
     Complete(Outcome),
-    Conflict(ObjectId),
+    Conflict(PlanConflict),
 }
 
 impl PlanPerform {
@@ -136,11 +138,98 @@ impl PlanPerform {
     pub(crate) fn complete(self) -> Result<Outcome> {
         match self {
             PlanPerform::Complete(outcome) => Ok(outcome),
-            PlanPerform::Conflict(id) => anyhow::bail!("rebase plan conflicts at {id}"),
+            PlanPerform::Conflict(conflict) => anyhow::bail!("rebase plan conflicts at {}", conflict.original()),
         }
     }
 }
 
+pub(crate) struct PlanConflict {
+    conflict: Conflict,
+    plan: Plan,
+    produced: Vec<ObjectId>,
+    rewritten: HashMap<ObjectId, Option<ObjectId>>,
+    conflict_step: usize,
+    continuation_start: usize,
+    remaining_squash: Vec<Vec<ObjectId>>,
+    final_refs: HashSet<gix::refs::FullName>,
+}
+
+impl PlanConflict {
+    pub(crate) fn original(&self) -> ObjectId {
+        self.conflict.original()
+    }
+
+    pub(crate) fn commit(&self) -> ObjectId {
+        self.conflict.commit
+    }
+
+    pub(crate) fn produced(&self) -> &[ObjectId] {
+        &self.produced
+    }
+
+    pub(crate) fn repository(&self) -> &gix::Repository {
+        &self.conflict.prepared.repo
+    }
+
+    pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
+        self.rewritten.get(&id).copied().unwrap_or(Some(id))
+    }
+
+    pub(crate) fn continuation_plan(&self) -> Plan {
+        let expected_refs = self
+            .plan
+            .expected_refs
+            .iter()
+            .filter(|expected| !self.final_refs.contains(&expected.name))
+            .map(|expected| ExpectedRef {
+                name: expected.name.clone(),
+                old: expected.old,
+                target: expected.new,
+                new: expected.new,
+                follows_tip: expected.follows_tip,
+            })
+            .collect();
+        let mut scope = self.produced[self.continuation_start..].to_vec();
+        scope.extend(self.remaining_squash.iter().flatten().copied());
+        let base = match self.plan.steps[self.continuation_start].parent {
+            PlanParent::Existing(id) => id,
+            PlanParent::Step(parent) => self.produced[parent],
+        };
+        Plan {
+            base,
+            scope,
+            steps: self
+                .plan
+                .steps
+                .iter()
+                .enumerate()
+                .skip(self.continuation_start)
+                .map(|(index, step)| PlanStep {
+                    parent: match step.parent {
+                        PlanParent::Existing(id) => PlanParent::Existing(id),
+                        PlanParent::Step(parent) if parent < self.continuation_start => {
+                            PlanParent::Existing(self.produced[parent])
+                        }
+                        PlanParent::Step(parent) => PlanParent::Step(parent - self.continuation_start),
+                    },
+                    commit: if index == self.conflict_step {
+                        PlanCommit::Resolved(self.produced[index])
+                    } else {
+                        PlanCommit::Pick(self.produced[index])
+                    },
+                    squash: self.remaining_squash[index].clone(),
+                })
+                .collect(),
+            checkout: self.plan.checkout.map(|index| index - self.continuation_start),
+            expected_refs,
+        }
+    }
+
+    pub(crate) fn into_conflict(self) -> Conflict {
+        self.conflict
+    }
+}
+
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
@@ -256,6 +345,7 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
             out.push(ExpectedRef {
                 name: reference.name().to_owned(),
                 old,
+                target: old,
                 new: old,
                 follows_tip: tips.contains(&old),
             });
@@ -269,6 +359,7 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
         out.push(ExpectedRef {
             name: head.name().to_owned(),
             old,
+            target: old,
             new: old,
             follows_tip: tips.contains(&old),
         });
@@ -696,7 +787,7 @@ pub(crate) fn perform_plan_with_progress(
     let mut picked = HashSet::new();
     for step in &plan.steps {
         let ids = match step.commit {
-            PlanCommit::Pick(id) => Some(id).into_iter().chain(step.squash.iter().copied()),
+            PlanCommit::Pick(id) | PlanCommit::Resolved(id) => Some(id).into_iter().chain(step.squash.iter().copied()),
             PlanCommit::Empty(_) => None.into_iter().chain(step.squash.iter().copied()),
         };
         for id in ids {
@@ -724,6 +815,7 @@ pub(crate) fn perform_plan_with_progress(
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
     let mut produced = Vec::with_capacity(plan.steps.len());
     let mut delete_refs = Vec::new();
+    let mut conflict = None;
     for (index, step) in plan.steps.iter().enumerate() {
         let parent = match step.parent {
             PlanParent::Existing(id) => {
@@ -732,7 +824,7 @@ pub(crate) fn perform_plan_with_progress(
             }
             PlanParent::Step(parent) => *produced.get(parent).context("a fork points to a later commit")?,
         };
-        let eager = eager.contains(&index) || !step.squash.is_empty();
+        let eager = conflict.is_none() && (eager.contains(&index) || !step.squash.is_empty());
         let mut commit = match &step.commit {
             PlanCommit::Pick(id) => repo
                 .find_commit(*id)
@@ -741,6 +833,28 @@ pub(crate) fn perform_plan_with_progress(
                 .context("could not decode a picked commit")?
                 .into_owned()
                 .context("could not own a picked commit")?,
+            PlanCommit::Resolved(_) => {
+                let mut commit = repo
+                    .head()?
+                    .peel_to_commit()
+                    .context("could not resolve the conflicted HEAD commit")?
+                    .decode()
+                    .context("could not decode the conflicted HEAD commit")?
+                    .into_owned()
+                    .context("could not own the conflicted HEAD commit")?;
+                let index = repo
+                    .index_or_empty()
+                    .context("could not load the resolved conflict index")?;
+                if index
+                    .entries()
+                    .iter()
+                    .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+                {
+                    anyhow::bail!("the conflict index still has unresolved entries");
+                }
+                commit.tree = super::create::index_tree(&repo, &index)?;
+                commit
+            }
             PlanCommit::Empty(title) => gix::objs::Commit {
                 tree: parent_tree(&repo, Some(parent))?,
                 parents: [parent].into_iter().collect(),
@@ -752,7 +866,9 @@ pub(crate) fn perform_plan_with_progress(
             },
         };
         let graph_parents = match step.commit {
-            PlanCommit::Pick(id) => graph.parents_of(id).context("a picked commit is incomplete")?,
+            PlanCommit::Pick(id) | PlanCommit::Resolved(id) => {
+                graph.parents_of(id).context("a picked commit is incomplete")?
+            }
             PlanCommit::Empty(_) => vec![parent],
         };
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
@@ -765,21 +881,24 @@ pub(crate) fn perform_plan_with_progress(
         } else {
             Tree::LeaveAsIsAndMark
         };
-        let cherry_pick_started = (eager && matches!(step.commit, PlanCommit::Pick(_))).then(Instant::now);
+        let cherry_pick_started =
+            (eager && matches!(step.commit, PlanCommit::Pick(_) | PlanCommit::Resolved(_))).then(Instant::now);
+        let mut step_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
-            TreeRewrite::Conflict { .. } => {
-                let PlanCommit::Pick(original) = step.commit else {
+            TreeRewrite::Conflict { tree, conflicts } => {
+                let (PlanCommit::Pick(original) | PlanCommit::Resolved(original)) = step.commit else {
                     unreachable!("empty commits cannot conflict")
                 };
-                return Ok(PlanPerform::Conflict(original));
+                step_conflict = Some((original, tree, conflicts, None));
+                tree
             }
         };
-        if let Some(started) = cherry_pick_started {
+        if let Some(started) = cherry_pick_started.filter(|_| step_conflict.is_none()) {
             progress.cherry_picked += 1;
             progress.cherry_pick_time += started.elapsed();
         }
-        if matches!(step.commit, PlanCommit::Pick(_)) {
+        if matches!(step.commit, PlanCommit::Pick(_) | PlanCommit::Resolved(_)) {
             progress.processed += 1;
             report(progress);
         }
@@ -800,25 +919,35 @@ pub(crate) fn perform_plan_with_progress(
             );
             squashed.push((*id, source, replay_parents));
         }
-        if !squashed.is_empty() {
-            squash_message(&repo, &mut commit, &squashed)?;
-            for (id, source, replay_parents) in &squashed {
+        if !squashed.is_empty() && conflict.is_none() && step_conflict.is_none() {
+            let mut applied = 0;
+            for (squash_index, (id, source, replay_parents)) in squashed.iter().enumerate() {
                 let old_base = parent_tree(&repo, replay_parents.first().copied())?;
                 let started = Instant::now();
                 commit.tree = match cherry_pick_tree_outcome(&repo, old_base, commit.tree, source.tree)? {
                     TreeRewrite::Complete(tree) => tree,
-                    TreeRewrite::Conflict { .. } => return Ok(PlanPerform::Conflict(*id)),
+                    TreeRewrite::Conflict { tree, conflicts } => {
+                        step_conflict = Some((*id, tree, conflicts, Some(squash_index)));
+                        tree
+                    }
                 };
+                applied += 1;
+                if step_conflict.is_some() {
+                    break;
+                }
                 progress.cherry_picked += 1;
                 progress.cherry_pick_time += started.elapsed();
                 progress.processed += 1;
                 report(progress);
                 delete_refs.extend(super::review::deletions(&repo, source)?);
             }
+            squash_message(&repo, &mut commit, &squashed[..applied])?;
         }
         commit.parents = [parent].into_iter().collect();
         commit.committer = committer.clone();
-        let state = if eager {
+        let state = if step_conflict.is_some() {
+            CommitState::Unmarked(Signature::InvalidateExisting)
+        } else if eager {
             CommitState::Unmarked(Signature::RedoIfNeeded)
         } else {
             CommitState::Pending {
@@ -834,13 +963,20 @@ pub(crate) fn perform_plan_with_progress(
             progress.processed += 1;
         }
         report(progress);
-        if let PlanCommit::Pick(old_id) = step.commit {
+        if let PlanCommit::Pick(old_id) | PlanCommit::Resolved(old_id) = step.commit {
             rewritten.insert(old_id, Some(new_id));
         }
         for old_id in &step.squash {
             rewritten.insert(*old_id, Some(new_id));
         }
         produced.push(new_id);
+        if let Some((original, tree, conflicts, squash_index)) = step_conflict {
+            let remaining_squash = squash_index.map_or_else(
+                || step.squash.clone(),
+                |squash_index| step.squash[squash_index + 1..].to_vec(),
+            );
+            conflict = Some((original, tree, conflicts, new_id, index, remaining_squash));
+        }
     }
 
     let dropped: Vec<_> = plan.scope.iter().copied().filter(|id| !picked.contains(id)).collect();
@@ -881,7 +1017,7 @@ pub(crate) fn perform_plan_with_progress(
     }
     for expected in &mut plan.expected_refs {
         let mut target = rewritten
-            .get(&expected.old)
+            .get(&expected.target)
             .copied()
             .flatten()
             .context("a captured reference target disappeared from the rebase plan")?;
@@ -924,9 +1060,9 @@ pub(crate) fn perform_plan_with_progress(
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected,
-        rewritten,
+        rewritten: rewritten.clone(),
         committer,
-        expected_refs: Some(plan.expected_refs),
+        expected_refs: Some(plan.expected_refs.clone()),
         pins,
         delete_refs,
     };
@@ -939,7 +1075,52 @@ pub(crate) fn perform_plan_with_progress(
         signing_ms = progress.signing_time.as_millis(),
         "prepared rebase plan"
     );
-    Ok(PlanPerform::Complete(prepared.finish()?))
+    let Some((original, tree, conflicts, commit, conflict_step, conflict_remaining_squash)) = conflict else {
+        return Ok(PlanPerform::Complete(prepared.finish()?));
+    };
+
+    let continuation_start = plan
+        .checkout
+        .filter(|index| *index < conflict_step)
+        .map_or(conflict_step, |_| 0);
+    let affected_steps: HashSet<_> = (continuation_start..plan.steps.len()).collect();
+    let affected_ids: HashSet<_> = affected_steps.iter().map(|index| produced[*index]).collect();
+    let final_refs: Vec<_> = plan
+        .expected_refs
+        .iter()
+        .filter(|expected| !affected_ids.contains(&expected.new))
+        .cloned()
+        .collect();
+    let final_ref_names = final_refs.iter().map(|expected| expected.name.clone()).collect();
+    let mut remaining_squash = vec![Vec::new(); plan.steps.len()];
+    remaining_squash[conflict_step] = conflict_remaining_squash;
+    for (index, step) in plan.steps.iter().enumerate().skip(conflict_step + 1) {
+        remaining_squash[index].clone_from(&step.squash);
+    }
+    prepared.selected = None;
+    prepared.reset_index = false;
+    prepared.rewritten = final_refs
+        .iter()
+        .map(|expected| (expected.old, Some(expected.new)))
+        .collect();
+    prepared.expected_refs = Some(final_refs);
+    prepared.pins.retain(|id| !affected_ids.contains(id));
+    Ok(PlanPerform::Conflict(PlanConflict {
+        conflict: Conflict {
+            prepared,
+            conflicts,
+            tree,
+            commit,
+            original,
+        },
+        plan,
+        produced,
+        rewritten,
+        conflict_step,
+        continuation_start,
+        remaining_squash,
+        final_refs: final_ref_names,
+    }))
 }
 
 impl Prepared {
@@ -1618,7 +1799,7 @@ fn update_refs(
         });
     }
     if edits.is_empty() {
-        anyhow::bail!("no mutable reference points to an affected commit");
+        return Ok(Vec::new());
     }
     let mut time = gix::date::parse::TimeBuf::default();
     repo.edit_references_as(edits, Some(committer.to_ref(&mut time)))
@@ -2093,7 +2274,7 @@ mod tests {
             .output()?
             .stdout;
 
-        let PlanPerform::Conflict(original) = perform_plan(
+        let PlanPerform::Conflict(conflict) = perform_plan(
             &repo,
             &graph,
             Plan {
@@ -2111,7 +2292,7 @@ mod tests {
         else {
             return Err("the conflicting todo should abort before persistence".into());
         };
-        assert_eq!(original, tip, "the diagnostic identifies the source delta");
+        assert_eq!(conflict.original(), tip, "the diagnostic identifies the source delta");
         assert_eq!(
             gix_testtools::repository::snapshot(fixture.path())?,
             before,
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 0af4eb823ea..86e580280e4 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -61,6 +61,23 @@ impl Conflict {
     }
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %conflict.original()))]
+pub(crate) fn materialize_plan_conflict(
+    conflict: super::rebase::PlanConflict,
+    repository_path: &Path,
+    bare: bool,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(String, ObjectId)> {
+    let original = conflict.original();
+    let mut conflict = conflict.into_conflict().persist()?;
+    let notice = move_head(repository_path, bare, conflict.commit, revisions, include_worktrees)?
+        .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
+    conflict.write_index()?;
+    tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
+    Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
+}
+
 pub(crate) fn checkout_without_replay(
     repository_path: &Path,
     bare: bool,
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index b6f9fec1003..297db520ac5 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -23,7 +23,7 @@ const HELP: &str = r#"
 - Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
 - Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Mutable refs on original leaves stay on the primary resulting leaf; the first continuation in todo order is primary. Other mutable refs follow their commits. Tags and remote-tracking refs stay unchanged, and new unreferenced leaves are pinned.
-- A todo conflict aborts without changing the repository and marks the offending commit in the history view; concurrent ref changes also abort the update.
+- A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
 - Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
 -->
 "#;
@@ -58,6 +58,8 @@ struct State {
     marker_required: bool,
     checkout_allowed: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
+    resolved: Option<ObjectId>,
+    continuation_sources: Vec<ObjectId>,
 }
 
 #[derive(Debug)]
@@ -143,6 +145,8 @@ pub(crate) fn prepare(
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
         expected_refs,
+        resolved: None,
+        continuation_sources: Vec::new(),
     };
     let mut document = b"<!-- Rebase help follows the editable todo. -->\n".to_vec();
     document.extend_from_slice(title.as_bytes());
@@ -191,6 +195,96 @@ pub(crate) fn prepare(
     })
 }
 
+pub(crate) fn prepare_continuation(
+    repo: &gix::Repository,
+    plan: &rebase::Plan,
+    tips: Vec<ObjectId>,
+) -> Result<Prepared> {
+    let resolved = plan.steps.iter().find_map(|step| match step.commit {
+        rebase::PlanCommit::Resolved(id) => Some(id),
+        _ => None,
+    });
+    let state = State {
+        base: plan.base,
+        onto: plan.base,
+        tips,
+        scope: plan.scope.clone(),
+        marker_required: plan.checkout.is_some(),
+        checkout_allowed: repo.workdir().is_some(),
+        expected_refs: plan.expected_refs.clone(),
+        resolved,
+        continuation_sources: plan.steps.iter().flat_map(|step| step.squash.iter().copied()).collect(),
+    };
+    let mut document = b"<!-- Rebase help follows the editable todo. -->\n# Continue materialized rebase\n\n".to_vec();
+    for (index, step) in plan.steps.iter().enumerate() {
+        let continues = matches!(step.parent, rebase::PlanParent::Step(parent) if parent + 1 == index);
+        if !continues {
+            if index > 0 {
+                document.push(b'\n');
+            }
+            let parent = match step.parent {
+                rebase::PlanParent::Existing(id) => id,
+                rebase::PlanParent::Step(parent) => match plan.steps[parent].commit {
+                    rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => id,
+                    rebase::PlanCommit::Empty(_) => {
+                        anyhow::bail!("a continuation fork cannot target an unwritten empty commit")
+                    }
+                },
+            };
+            let base_title = (parent == plan.base)
+                .then(|| anchor_title(repo, parent))
+                .transpose()?
+                .unwrap_or_default();
+            write_fork_heading(
+                &mut document,
+                repo,
+                parent,
+                (parent == plan.base).then_some(("base", base_title.as_str())),
+            )?;
+        }
+        let marker = if plan.checkout == Some(index) { "@" } else { "" };
+        match step.commit {
+            rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => {
+                let value = if matches!(step.commit, rebase::PlanCommit::Resolved(_)) {
+                    ObjectId::null(id.kind()).to_string()
+                } else {
+                    short(repo, id)?
+                };
+                let title = anchor_title(repo, id)?;
+                document.extend_from_slice(
+                    format!(
+                        "`{marker}pick {value}` {}{}\n",
+                        commit_states(repo, id)?,
+                        escape_markdown(&title)
+                    )
+                    .as_bytes(),
+                );
+            }
+            rebase::PlanCommit::Empty(ref title) => {
+                document.extend_from_slice(format!("`{marker}empty {}`\n", title.to_str_lossy()).as_bytes());
+            }
+        }
+        for id in &step.squash {
+            let title = anchor_title(repo, *id)?;
+            document.extend_from_slice(
+                format!(
+                    "`squash {}` {}{}\n",
+                    short(repo, *id)?,
+                    commit_states(repo, *id)?,
+                    escape_markdown(&title)
+                )
+                .as_bytes(),
+            );
+        }
+    }
+    document.extend_from_slice(HELP.as_bytes());
+    write_state(&mut document, &state);
+    Ok(Prepared {
+        document,
+        apply_unchanged: true,
+    })
+}
+
 fn write_state(out: &mut Vec<u8>, state: &State) {
     out.extend_from_slice(STATE_START.as_bytes());
     out.extend_from_slice(format!("base {}\nonto {}\n", state.base, state.onto).as_bytes());
@@ -211,14 +305,21 @@ fn write_state(out: &mut Vec<u8>, state: &State) {
         let name = gix::quote::ansi_c::quote(reference.name.as_bstr());
         out.extend_from_slice(
             format!(
-                "ref {} {} {}\n",
+                "ref {} {} {} {}\n",
                 reference.old,
+                reference.target,
                 reference.follows_tip,
                 name.to_str_lossy()
             )
             .as_bytes(),
         );
     }
+    if let Some(id) = state.resolved {
+        out.extend_from_slice(format!("resolved {id}\n").as_bytes());
+    }
+    for id in &state.continuation_sources {
+        out.extend_from_slice(format!("continuation-source {id}\n").as_bytes());
+    }
     out.extend_from_slice(STATE_END.as_bytes());
     out.push(b'\n');
 }
@@ -363,6 +464,8 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
     let mut marker_required = None;
     let mut checkout_allowed = None;
     let mut expected_refs = Vec::new();
+    let mut resolved = None;
+    let mut continuation_sources = Vec::new();
     for line in body[..end].lines() {
         let (key, value) = line.split_once(' ').context("a rebase state line has no value")?;
         match key {
@@ -389,9 +492,11 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
                 }
             }
             "ref" => {
-                let (old, value) = value.split_once(' ').context("a captured ref has no follow mode")?;
-                let (follows_tip, name) = value.split_once(' ').context("a captured ref has no name")?;
+                let (old, value) = value.split_once(' ').context("a captured ref has no target")?;
+                let (target, value) = value.split_once(' ').context("a captured ref has no follow mode")?;
                 let old = ObjectId::from_hex(old.as_bytes())?;
+                let target = ObjectId::from_hex(target.as_bytes())?;
+                let (follows_tip, name) = value.split_once(' ').context("a captured ref has no name")?;
                 let follows_tip = follows_tip.parse()?;
                 let encoded_name = name.as_bytes().as_bstr();
                 let (name, consumed) = gix::quote::ansi_c::undo(encoded_name)
@@ -404,10 +509,17 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
                 expected_refs.push(rebase::ExpectedRef {
                     name,
                     old,
+                    target,
                     new: old,
                     follows_tip,
                 });
             }
+            "resolved" => {
+                if resolved.replace(ObjectId::from_hex(value.as_bytes())?).is_some() {
+                    anyhow::bail!("the rebase state repeats its resolved conflict");
+                }
+            }
+            "continuation-source" => continuation_sources.push(ObjectId::from_hex(value.as_bytes())?),
             _ => anyhow::bail!("unsupported rebase state field {key:?}"),
         }
     }
@@ -419,6 +531,8 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
         marker_required: marker_required.context("the rebase state has no marker requirement")?,
         checkout_allowed: checkout_allowed.context("the rebase state has no checkout capability")?,
         expected_refs,
+        resolved,
+        continuation_sources,
     };
     validate_state(repo, &state)?;
     Ok(Some(state))
@@ -430,6 +544,7 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
     repo.find_commit(state.onto)
         .context("could not find the recorded rebase target")?;
     let scope: HashSet<_> = state.scope.iter().copied().collect();
+    let continuation_sources: HashSet<_> = state.continuation_sources.iter().copied().collect();
     if scope.len() != state.scope.len() {
         anyhow::bail!("the rebase state contains duplicate scope commits");
     }
@@ -441,8 +556,8 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
         if !refs.insert(reference.name.as_bstr()) {
             anyhow::bail!("the rebase state contains duplicate refs");
         }
-        if !scope.contains(&reference.old) {
-            anyhow::bail!("a captured ref does not point into the rebase scope");
+        if !scope.contains(&reference.target) {
+            anyhow::bail!("a captured ref does not logically point into the rebase scope");
         }
     }
     for tip in &state.tips {
@@ -457,10 +572,16 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
             .next()
             .map(gix::Id::detach)
             .context("a recorded scope commit has no parent")?;
-        if parent != state.base && !scope.contains(&parent) {
+        if parent != state.base && !scope.contains(&parent) && !continuation_sources.contains(id) {
             anyhow::bail!("a recorded scope commit is disconnected from the rebase base");
         }
     }
+    if state.resolved.is_some_and(|id| !scope.contains(&id)) {
+        anyhow::bail!("the resolved conflict is outside the rebase scope");
+    }
+    if !continuation_sources.is_subset(&scope) {
+        anyhow::bail!("a continuation source is outside the rebase scope");
+    }
     Ok(())
 }
 
@@ -561,17 +682,30 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
         let parent = cursor.context("the first todo command must follow a fork heading")?;
         let commit = match verb {
             "pick" => {
-                let id = resolve_commit(
-                    repo,
-                    value.split_whitespace().next().context("a pick needs a commit ID")?,
-                )?;
+                let value = value.split_whitespace().next().context("a pick needs a commit ID")?;
+                let resolved_id = state.resolved;
+                let full_null = resolved_id.is_some_and(|id| {
+                    value.len() == id.kind().len_in_bytes() * 2 && value.bytes().all(|byte| byte == b'0')
+                });
+                let (id, resolved) = if full_null {
+                    (
+                        resolved_id.context("a null pick has no materialized conflict state")?,
+                        true,
+                    )
+                } else {
+                    (resolve_commit(repo, value)?, false)
+                };
                 if !scope.contains(&id) {
                     anyhow::bail!("a pick is outside the editable history");
                 }
                 if picked.contains_key(&id) {
                     anyhow::bail!("a commit is picked more than once");
                 }
-                rebase::PlanCommit::Pick(id)
+                if resolved {
+                    rebase::PlanCommit::Resolved(id)
+                } else {
+                    rebase::PlanCommit::Pick(id)
+                }
             }
             "empty" => {
                 let title = if value.trim().is_empty() { tail } else { value.trim() };
@@ -583,7 +717,7 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
             _ => anyhow::bail!("unsupported rebase todo command {verb:?}"),
         };
         let index = steps.len();
-        if let rebase::PlanCommit::Pick(id) = commit {
+        if let rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) = commit {
             picked.insert(id, index);
         }
         steps.push(rebase::PlanStep {
@@ -749,9 +883,12 @@ mod tests {
             expected_refs: vec![rebase::ExpectedRef {
                 name: name.clone(),
                 old: middle,
+                target: middle,
                 new: middle,
                 follows_tip: true,
             }],
+            resolved: None,
+            continuation_sources: Vec::new(),
         };
         let mut document = Vec::new();
         write_state(&mut document, &state);
@@ -986,6 +1123,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn continuation_todos_round_trip_the_resolved_index_and_remaining_squashes() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, _) = commits(&repo)?;
+        let prepared = prepare_continuation(
+            &repo,
+            &rebase::Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![rebase::PlanStep {
+                    parent: rebase::PlanParent::Existing(base),
+                    commit: rebase::PlanCommit::Resolved(middle),
+                    squash: vec![tip],
+                }],
+                checkout: Some(0),
+                expected_refs: Vec::new(),
+            },
+            vec![middle],
+        )?;
+        let document = String::from_utf8(prepared.document.clone())?;
+        assert!(document.contains(&"0".repeat(40)), "the conflict uses the full null ID");
+        assert!(
+            document.contains(&format!("`squash {}`", tip.to_hex_with_len(7))),
+            "unapplied squash sources remain editable"
+        );
+        let plan = parse_plan(&repo, &prepared.document)?;
+        assert!(matches!(plan.steps[0].commit, rebase::PlanCommit::Resolved(id) if id == middle));
+        assert_eq!(plan.steps[0].squash, [tip]);
+        Ok(())
+    }
+
     #[test]
     fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 47bb07564fb..68bf8e9ccaf 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -977,6 +977,8 @@ fn event_loop(
     let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
     let mut pending_rebase_conflict: Option<edit::time_travel::Conflict> = None;
+    let mut pending_todo_rebase_conflict: Option<edit::rebase::PlanConflict> = None;
+    let mut pending_todo_rebase_plan: Option<edit::rebase::Plan> = None;
     let result: Result<Option<Duration>> = (|| loop {
         if let Some(mut recovered) =
             recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
@@ -1586,7 +1588,11 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
-        if key_pressed && pending_rebase_conflict.is_none() && app.has_rebase_conflict() {
+        if key_pressed
+            && pending_rebase_conflict.is_none()
+            && pending_todo_rebase_conflict.is_none()
+            && app.has_rebase_conflict()
+        {
             app.clear_rebase_conflict();
             dirty = true;
             urgent = true;
@@ -1641,6 +1647,107 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        if key_pressed && pending_todo_rebase_conflict.is_some() {
+            if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
+                let conflict = pending_todo_rebase_conflict
+                    .take()
+                    .expect("a pending todo conflict was checked before accepting it");
+                let plan = conflict.continuation_plan();
+                match edit::time_travel::materialize_plan_conflict(
+                    conflict,
+                    &repository_path,
+                    repository_is_bare,
+                    &revisions,
+                    worktrees,
+                ) {
+                    Ok((notice, id)) => {
+                        pending_todo_rebase_plan = Some(plan);
+                        app.begin_conflict_resolution();
+                        app.leave_message(format!("{notice}; resolve the index, then press <enter>"));
+                        app.select_commit_after_refresh(id);
+                    }
+                    Err(err) => {
+                        app.clear_rebase_conflict();
+                        app.leave_message(format!("conflict checkout: {err:#}"));
+                    }
+                }
+                invalidate_worktree_changes(&mut worktree_changes);
+                refresh_pending = true;
+                dirty = true;
+                urgent = true;
+                continue;
+            }
+            let conflict = pending_todo_rebase_conflict
+                .take()
+                .expect("a pending todo conflict was checked before discarding it");
+            tracing::info!(commit_id = %conflict.original(), ?action, "discarded suspended todo rebase conflict");
+            app.clear_rebase_conflict();
+            refresh_pending = true;
+            dirty = true;
+            urgent = true;
+        }
+        if key_pressed
+            && action == Some(Action::OpenDiff)
+            && app.changes_focus.is_none()
+            && pending_todo_rebase_plan.is_some()
+        {
+            let plan = pending_todo_rebase_plan
+                .take()
+                .expect("a pending continuation plan was checked before resuming it");
+            let result = (|| {
+                let mut repository = open_repository(&repository_path, repository_is_bare, false)
+                    .context("could not reopen repository to continue the rebase")?;
+                repository.object_cache_size(None);
+                let graph = HistoryGraph::for_commits(&repository, &plan.scope)?;
+                run_rebase_plan(terminal, repository.into_sync(), &graph, plan.clone())
+            })();
+            match result {
+                Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
+                    let notice = outcome
+                        .selected
+                        .map(|selected| {
+                            edit::time_travel::checkout_without_replay(
+                                &repository_path,
+                                repository_is_bare,
+                                selected,
+                                &revisions,
+                                worktrees,
+                            )
+                        })
+                        .transpose()
+                        .map(Option::flatten);
+                    app.clear_rebase_conflict();
+                    app.set_worktree_conflicted(false);
+                    app.leave_message(
+                        notice
+                            .unwrap_or_else(|err| Some(format!("rebase applied, checkout failed: {err:#}")))
+                            .unwrap_or_else(|| "rebased history".into()),
+                    );
+                    refresh_pending = true;
+                }
+                Ok(edit::rebase::PlanPerform::Conflict(conflict)) => {
+                    let id = conflict.commit();
+                    preview_todo_rebase_conflict(
+                        &mut app,
+                        &conflict,
+                        &authors,
+                        &ref_snapshot.view_tips,
+                        &ref_snapshot.hidden_tips,
+                    )?;
+                    app.arm_rebase_conflict(id);
+                    app.select_commit(id);
+                    pending_todo_rebase_conflict = Some(conflict);
+                }
+                Err(err) => {
+                    pending_todo_rebase_plan = Some(plan);
+                    app.leave_message(format!("continue rebase: {err:#}"));
+                }
+            }
+            invalidate_worktree_changes(&mut worktree_changes);
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         let Some(action) = action else {
             continue;
         };
@@ -2065,9 +2172,18 @@ fn event_loop(
                                 }
                             }
                         }
-                        Ok(Some(edit::rebase::PlanPerform::Conflict(original))) => {
-                            app.mark_todo_rebase_conflict(original);
-                            app.select_commit(original);
+                        Ok(Some(edit::rebase::PlanPerform::Conflict(conflict))) => {
+                            let id = conflict.commit();
+                            preview_todo_rebase_conflict(
+                                &mut app,
+                                &conflict,
+                                &authors,
+                                &ref_snapshot.view_tips,
+                                &ref_snapshot.hidden_tips,
+                            )?;
+                            app.arm_rebase_conflict(id);
+                            app.select_commit(id);
+                            pending_todo_rebase_conflict = Some(conflict);
                         }
                         Ok(None) => app.leave_message("no rebase performed: the todo was unchanged"),
                         Err(err) => app.leave_message(format!("rebase: {err:#}")),
@@ -3208,6 +3324,55 @@ fn rebase_history(
     run_rebase_plan(terminal, repository.into_sync(), graph, parsed.plan).map(Some)
 }
 
+fn preview_todo_rebase_conflict(
+    app: &mut App,
+    conflict: &edit::rebase::PlanConflict,
+    authors: &SharedAuthors,
+    view_tips: &[gix::ObjectId],
+    hidden_tips: &[gix::ObjectId],
+) -> Result<()> {
+    let repo = conflict.repository();
+    let mut rows = Vec::with_capacity(conflict.produced().len());
+    let mut attributions = Vec::new();
+    for id in conflict.produced().iter().rev().copied() {
+        let commit = repo
+            .find_commit(id)
+            .context("could not load an in-memory rebase result")?;
+        let parent_ids = commit.parent_ids().map(gix::Id::detach).collect();
+        let (metadata, mut row_attributions) = history::load_metadata(repo, id, authors)?;
+        let attribution_start = attributions.len();
+        let attribution_len = metadata.attributions.len();
+        attributions.append(&mut row_attributions);
+        rows.push(app::Commit {
+            id,
+            parent_ids,
+            committer_time: metadata.committer_time,
+            author: metadata.author,
+            attributions: attribution_start..attribution_start + attribution_len,
+            title: metadata.title,
+            metadata_loaded: true,
+            has_agent_marker: metadata.has_agent_marker,
+            is_review: metadata.is_review,
+            signature: metadata.signature,
+        });
+    }
+    let view_tips = view_tips.iter().filter_map(|id| conflict.map(*id)).collect::<Vec<_>>();
+    let hidden_tips = hidden_tips
+        .iter()
+        .filter_map(|id| conflict.map(*id))
+        .collect::<Vec<_>>();
+    if let Some(rows) = app.start_refresh(
+        app::LoadedCommits { rows, attributions },
+        &view_tips,
+        &hidden_tips,
+        false,
+    ) {
+        let (rows, graph, elapsed) = app::compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, elapsed);
+    }
+    Ok(())
+}
+
 enum RebaseWorkerEvent {
     Progress(edit::rebase::PlanProgress),
     Complete(Result<edit::rebase::PlanPerform>),
@@ -5569,4 +5734,54 @@ mod tests {
         assert!(!rebase_progress_visible(Duration::from_millis(299)));
         assert!(rebase_progress_visible(REBASE_PROGRESS_DELAY));
     }
+
+    #[test]
+    fn todo_conflict_preview_selects_the_partial_result_in_memory() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = gix::open_opts(
+            fixture.path(),
+            gix::open::Options::isolated().config_overrides([
+                "commit.gpgSign=false".to_owned(),
+                "user.name=preview author".to_owned(),
+                "user.email=preview@example.com".to_owned(),
+            ]),
+        )?;
+        let graph = edit::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let edit::rebase::PlanPerform::Conflict(conflict) = edit::rebase::perform_plan(
+            &repo,
+            &graph,
+            edit::rebase::Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![edit::rebase::PlanStep {
+                    parent: edit::rebase::PlanParent::Existing(base),
+                    commit: edit::rebase::PlanCommit::Pick(tip),
+                    squash: Vec::new(),
+                }],
+                checkout: Some(0),
+                expected_refs: edit::rebase::capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        )?
+        else {
+            return Err("the reordered history should conflict".into());
+        };
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let mut app = App::new(usize::MAX);
+        preview_todo_rebase_conflict(&mut app, &conflict, &authors, &[tip], &[])?;
+        app.arm_rebase_conflict(conflict.commit());
+        app.select_commit(conflict.commit());
+
+        assert_eq!(
+            app.rows
+                .get(app.selected.expect("the conflict is selected"))
+                .map(|row| row.id),
+            Some(conflict.commit()),
+            "the displayed red-C row is the prepared result, not its original source"
+        );
+        Ok(())
+    }
 }

From e6e9c4bc0d5fc6db8051de6e8b3af3fe412d3728 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 10:11:24 +0200
Subject: [PATCH 105/282] fix: make the tix information menu reachable

Stop requesting and interpreting standalone Shift events, removing the held-Shift ancestry and author-preview mode that could intercept Shift-/ before it became ?. Accept both enhanced-keyboard encodings of that shortcut while preserving ordinary shifted commands.

Keep all status actions following ? inside its expanded group through commit diff navigation, with quit alone outside the group. Update the behavioral specification and cover collapsed and expanded footer layouts.
---
 gix-tix/spec.md    |  35 ++----
 gix-tix/src/app.rs | 257 ++-------------------------------------------
 gix-tix/src/lib.rs |  53 +++-------
 gix-tix/src/ui.rs  | 223 +++++++++------------------------------
 4 files changed, 86 insertions(+), 482 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index d2ca104c6d8..2fc2de57f53 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -73,11 +73,12 @@ without trading responsiveness for metadata that is not visible.
   that connect visible history to hidden history remain as boundary rows.
 - Boundary rows retain graph styling but use terminal-default colors, are dimmed,
   and can be selected, paged to, restored as a selection, copied, and inspected.
-  They cannot be reworded, forgotten, or signature-verified, and Shift navigation
-  continues to skip them. They may be used for time travel or as the parent of an
-  independent fork commit. A boundary whose visible
-  descendants contain no merge commit offers the history-rebase editor, including
-  when those descendants fork into multiple linear stacks.
+  They cannot be reworded, forgotten, or signature-verified. During review-base
+  selection, only an eligible base boundary remains selectable among hidden rows.
+  They may be used for time travel or as the parent of an independent fork commit.
+  A boundary whose visible descendants contain no merge commit offers the
+  history-rebase editor, including when those descendants fork into multiple
+  linear stacks.
 - If a boundary has exactly one leaf among its visible descendants, selecting it
   uses the boundary-to-leaf tree comparison for the changes block and selection
   diff-stat. Forks which merge back into one leaf qualify; multiple surviving
@@ -126,7 +127,7 @@ without trading responsiveness for metadata that is not visible.
   never invert an adjacent character.
 - A compared merge parent is cyan, including its commit marker, and its hash is
   inverted.
-- Rows outside active Shift reachability are dimmed. When a changes block has
+- Rows outside active review-base reachability are dimmed. When a changes block has
   focus, history is dimmed but its contextual selection information and main
   status line remain prominent.
 
@@ -172,7 +173,7 @@ without trading responsiveness for metadata that is not visible.
 | `Ctrl-u`/`Ctrl-d` | Move half a page. |
 | `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
-| `?` | Toggle the view-information key group. Its actions remain direct shortcuts. |
+| `?` | Toggle the information key group. Its actions remain direct shortcuts. |
 | `[` | Toggle graph/metadata alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Toggle committer dates. |
@@ -194,7 +195,9 @@ without trading responsiveness for metadata that is not visible.
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
 for signature verification, alignment, message, and changes actions, but these
-actions retain their direct shortcuts while the group is closed. The footer
+actions retain their direct shortcuts while the group is closed. While expanded,
+the group visually contains every following status action through `<enter> diff`,
+including pane switching and navigation; quit remains outside it. The footer
 underlines the `v` in `view`; while active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
@@ -244,22 +247,6 @@ The Enter key is written as `<enter>` throughout.
   remain in the ordinary index/worktree conflict workflow. Nested trees use the
   nearest review-root ancestor.
 
-### Held Shift ancestry mode
-
-- On terminals that report modifier press and release events, pressing Shift in
-  focused history anchors navigation at the selected commit. Releasing Shift
-  restores ordinary navigation.
-- `j` and `k` then visit only commits reachable through the selected rail; other
-  rows are dimmed.
-- A non-merge anchor follows all of its ancestry. A merge anchor initially uses
-  its second parent, excluding first-parent ancestry except shared fork points.
-- `h` and `l` cycle the merge anchor's parents instead of panning. The chosen
-  parent is numbered beside the junction marker. Later merges on the chosen rail
-  traverse all their parents normally.
-- Reachability is computed only after traversal and lane computation complete.
-  Shift is ignored while another changes block has focus or while the terminal
-  itself is unfocused.
-
 ## Overlay views
 
 Overlay views paint over history without changing metadata alignment. Selection
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 3cd8953404b..9c37ba49d1e 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -313,7 +313,6 @@ pub(crate) enum Action {
     Copy,
     CopyPath(BString),
     CopyAuthor,
-    PreviewAuthorCopy(bool),
     ForceQuit,
     Quit,
 }
@@ -415,10 +414,8 @@ pub(crate) struct App {
     commit_page: usize,
     commit_max: usize,
     pub(crate) show_selection_tail: bool,
-    pub preview_author_copy: bool,
     reachability_anchor: Option<ObjectId>,
     review_tip: Option<ObjectId>,
-    junction_parent: Option<usize>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
@@ -453,7 +450,6 @@ pub(crate) struct App {
     select_top_after_refresh: bool,
     pub(crate) signature_failures: usize,
     signature_verification_running: bool,
-    pub(crate) manual_refresh: bool,
     pub(crate) selection_relation: Option<SelectionRelation>,
     hidden_branch_updates: HashMap<ObjectId, (usize, ObjectId)>,
 }
@@ -506,10 +502,8 @@ impl App {
             commit_page: 1,
             commit_max: 0,
             show_selection_tail: true,
-            preview_author_copy: false,
             reachability_anchor: None,
             review_tip: None,
-            junction_parent: None,
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
@@ -544,7 +538,6 @@ impl App {
             select_top_after_refresh: false,
             signature_failures: 0,
             signature_verification_running: false,
-            manual_refresh: false,
             selection_relation: None,
             hidden_branch_updates: HashMap::new(),
         }
@@ -840,14 +833,14 @@ impl App {
             Action::ScrollLeft => {
                 if self.changes_focus.is_some() {
                     self.pan_changes(false);
-                } else if !self.cycle_junction_parent(false) {
+                } else {
                     self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
                 }
             }
             Action::ScrollRight => {
                 if self.changes_focus.is_some() {
                     self.pan_changes(true);
-                } else if !self.cycle_junction_parent(true) {
+                } else {
                     self.horizontal_offset = self
                         .horizontal_offset
                         .saturating_add(self.horizontal_page)
@@ -963,9 +956,6 @@ impl App {
             }
             Action::ToggleChangesFocus if self.changes_mode.is_some() => {
                 self.cycle_changes_focus();
-                if self.changes_focus.is_some() {
-                    self.clear_preview_author_copy();
-                }
                 self.focus_feedback = Some(match self.changes_focus {
                     Some(ChangePane::Tree) => "tree changes",
                     Some(ChangePane::Worktree) => "worktree changes",
@@ -1071,7 +1061,6 @@ impl App {
                 let tip = self.rows[self.selected.expect("review requires a selection")].id;
                 self.review_tip = Some(tip);
                 self.reachability_anchor = Some(tip);
-                self.junction_parent = None;
                 self.compute_reachable_rows();
                 self.leave_message("review base · j/k select ancestor · <enter> start · Esc cancel");
             }
@@ -1103,16 +1092,6 @@ impl App {
             Action::ForceQuit => return vec![Effect::Quit],
             Action::Cancel if self.review_tip.is_some() => self.clear_review_selection(),
             Action::Cancel | Action::Quit if self.changes_focus.is_some() => self.focus_history(),
-            Action::PreviewAuthorCopy(_) if self.review_tip.is_some() || self.changes_focus.is_some() => {}
-            Action::PreviewAuthorCopy(value) => {
-                if value && !self.preview_author_copy {
-                    self.reachability_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
-                    self.compute_reachable_rows();
-                } else if !value {
-                    self.clear_preview_author_copy();
-                }
-                self.preview_author_copy = value;
-            }
             Action::Cancel if self.state == State::Loading => {
                 self.state = State::Cancelling;
                 return vec![Effect::Cancel];
@@ -1414,7 +1393,7 @@ impl App {
         self.pending_initial_selection = None;
         self.selection_after_refresh = None;
         self.update_worktree_head_descendants();
-        self.clear_preview_author_copy();
+        self.clear_review_selection();
         self.signature_failures = 0;
         self.signature_verification_running = false;
     }
@@ -1449,17 +1428,9 @@ impl App {
         self.ensure_changes_visible();
     }
 
-    fn clear_preview_author_copy(&mut self) {
-        self.preview_author_copy = false;
-        self.reachability_anchor = None;
-        self.junction_parent = None;
-        self.reachable_rows = None;
-    }
-
     fn clear_review_selection(&mut self) {
         self.review_tip = None;
         self.reachability_anchor = None;
-        self.junction_parent = None;
         self.reachable_rows = None;
     }
 
@@ -1546,28 +1517,6 @@ impl App {
         }
     }
 
-    fn cycle_junction_parent(&mut self, forward: bool) -> bool {
-        if self.state != State::Complete || self.review_tip.is_some() {
-            return false;
-        }
-        let Some(parent_count) = self
-            .reachability_anchor
-            .and_then(|anchor| self.rows.iter().find(|row| row.id == anchor))
-            .map(|row| row.parent_ids.len())
-            .filter(|count| *count > 1)
-        else {
-            return false;
-        };
-        let current = self.junction_parent.unwrap_or(1);
-        self.junction_parent = Some(if forward {
-            (current + 1) % parent_count
-        } else {
-            (current + parent_count - 1) % parent_count
-        });
-        self.compute_reachable_rows();
-        true
-    }
-
     fn compute_reachable_rows(&mut self) {
         if self.state != State::Complete {
             self.reachable_rows = None;
@@ -1577,30 +1526,12 @@ impl App {
             self.reachable_rows = None;
             return;
         };
-        let Some(anchor_index) = self.rows.iter().position(|row| row.id == anchor) else {
+        if !self.rows.iter().any(|row| row.id == anchor) {
             self.reachable_rows = Some(vec![false; self.rows.len()]);
             return;
-        };
-        let parent_count = self.rows[anchor_index].parent_ids.len();
-        let start = if self.review_tip.is_some() {
-            self.junction_parent = None;
-            anchor
-        } else if parent_count > 1 {
-            let parent = self.junction_parent.get_or_insert(1);
-            if *parent >= parent_count {
-                *parent = 1;
-            }
-            self.rows[anchor_index]
-                .parent_ids
-                .get(*parent)
-                .copied()
-                .expect("the selected junction parent exists")
-        } else {
-            self.junction_parent = None;
-            anchor
-        };
-        let mut pending = HashSet::from([start]);
-        let mut reachable: Vec<_> = self
+        }
+        let mut pending = HashSet::from([anchor]);
+        let reachable: Vec<_> = self
             .rows
             .iter()
             .map(|row| {
@@ -1611,21 +1542,9 @@ impl App {
                 reachable
             })
             .collect();
-        if start != anchor {
-            reachable[anchor_index] = true;
-        }
         self.reachable_rows = Some(reachable);
     }
 
-    pub(crate) fn junction_parent(&self, index: usize) -> Option<usize> {
-        let row = self.rows.get(index)?;
-        if self.reachability_anchor == Some(row.id) {
-            self.junction_parent.map(|parent| parent + 1)
-        } else {
-            None
-        }
-    }
-
     pub(crate) fn is_row_reachable(&self, index: usize) -> bool {
         self.reachable_rows
             .as_ref()
@@ -2882,39 +2801,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn shift_limits_jk_to_the_selected_commits_ancestors() {
-        let mut app = App::new(5);
-        app.extend_commits(vec![
-            row_with_parents(5, &[3]),
-            row_with_parents(4, &[2]),
-            row_with_parents(3, &[1]),
-            row_with_parents(2, &[1]),
-            row(1),
-        ]);
-        complete(&mut app);
-        app.selected = app.rows.iter().position(|row| row.id == id(5));
-
-        app.update(Action::PreviewAuthorCopy(true));
-        let reachable: Vec<_> = app
-            .rows
-            .iter()
-            .enumerate()
-            .filter(|(index, _)| app.is_row_reachable(*index))
-            .map(|(_, row)| row.id)
-            .collect();
-        assert_eq!(reachable, [id(5), id(3), id(1)]);
-
-        app.update(Action::MoveDown);
-        assert_eq!(app.rows[app.selected.expect("an ancestor is selected")].id, id(3));
-        app.update(Action::MoveDown);
-        assert_eq!(app.rows[app.selected.expect("an ancestor is selected")].id, id(1));
-
-        app.update(Action::PreviewAuthorCopy(false));
-        app.update(Action::MoveUp);
-        assert_eq!(app.rows[app.selected.expect("normal navigation is restored")].id, id(2));
-    }
-
     #[test]
     fn review_selects_only_a_strict_ancestor_before_starting() {
         let mut app = App::new(10);
@@ -2957,53 +2843,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn changes_focus_clears_and_ignores_shift() {
-        let mut app = App::new(2);
-        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
-        complete(&mut app);
-
-        app.update(Action::PreviewAuthorCopy(true));
-        assert!(app.preview_author_copy && app.reachable_rows.is_some());
-
-        show_tree_changes(&mut app);
-        app.update(Action::ToggleChangesFocus);
-        assert!(
-            app.changes_focus == Some(ChangePane::Tree) && !app.preview_author_copy && app.reachable_rows.is_none(),
-            "entering the changes pane clears transient history navigation"
-        );
-
-        app.update(Action::PreviewAuthorCopy(true));
-        assert!(
-            !app.preview_author_copy && app.reachable_rows.is_none(),
-            "the inactive history pane ignores Shift"
-        );
-    }
-
-    #[test]
-    fn shift_defers_reachability_until_the_graph_is_complete() {
-        let mut app = App::new(4);
-        app.extend_commits(vec![row_with_parents(4, &[3, 2]), row_with_parents(3, &[1])]);
-
-        app.update(Action::PreviewAuthorCopy(true));
-        assert!(
-            app.reachable_rows.is_none(),
-            "pressing Shift while traversing does not compute reachability"
-        );
-        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
-        assert!(
-            app.reachable_rows.is_none(),
-            "later traversal batches do not recompute reachability"
-        );
-
-        complete(&mut app);
-        assert!(
-            app.reachable_rows.is_some(),
-            "graph completion computes reachability once"
-        );
-        assert_eq!(app.junction_parent(0), Some(2));
-    }
-
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);
@@ -3567,11 +3406,9 @@ mod tests {
         );
         complete(&mut app);
         assert_eq!(app.update(Action::ToggleHidden), vec![Effect::Reload(true)]);
-        drop(app.update(Action::PreviewAuthorCopy(true)));
         app.reload(true);
         assert!(app.rows.is_empty(), "reloading drops rows from the previous view");
         assert!(app.show_hidden);
-        assert!(!app.preview_author_copy, "reloading clears transient Shift state");
         assert_eq!(app.state, State::Loading);
         assert!(
             app.update(Action::ToggleHidden).is_empty(),
@@ -3682,86 +3519,6 @@ mod tests {
         assert_eq!(app.update(Action::Cancel), vec![Effect::Cancel]);
     }
 
-    #[test]
-    fn shift_starts_with_a_merges_second_parent_rail() {
-        let mut app = App::new(7);
-        app.extend_commits(vec![
-            row_with_parents(6, &[5, 4]),
-            row_with_parents(5, &[3]),
-            row_with_parents(4, &[2]),
-            row_with_parents(3, &[1]),
-            row_with_parents(2, &[1]),
-            row(1),
-        ]);
-        complete(&mut app);
-        app.selected = app.rows.iter().position(|row| row.id == id(6));
-
-        app.update(Action::PreviewAuthorCopy(true));
-        let reachable: Vec<_> = app
-            .rows
-            .iter()
-            .enumerate()
-            .filter(|(index, _)| app.is_row_reachable(*index))
-            .map(|(_, row)| row.id)
-            .collect();
-        assert_eq!(
-            reachable,
-            [id(6), id(4), id(2), id(1)],
-            "the second parent and its complete ancestry are reachable"
-        );
-    }
-
-    #[test]
-    fn shift_cycles_junction_parents_without_panning() {
-        let mut app = App::new(8);
-        app.extend_commits(vec![
-            row_with_parents(10, &[8, 9, 11]),
-            row_with_parents(8, &[6]),
-            row_with_parents(9, &[7, 6]),
-            row_with_parents(11, &[5]),
-            row_with_parents(7, &[1]),
-            row_with_parents(6, &[1]),
-            row_with_parents(5, &[1]),
-            row(1),
-        ]);
-        complete(&mut app);
-        app.selected = app.rows.iter().position(|row| row.id == id(10));
-        app.set_horizontal_bounds(10, 25);
-
-        app.update(Action::PreviewAuthorCopy(true));
-        let reachable = |app: &App| {
-            app.rows
-                .iter()
-                .enumerate()
-                .filter(|(index, _)| app.is_row_reachable(*index))
-                .map(|(_, row)| row.id)
-                .collect::<HashSet<_>>()
-        };
-        assert_eq!(app.junction_parent(0), Some(2));
-        assert_eq!(
-            reachable(&app),
-            HashSet::from([id(10), id(9), id(7), id(6), id(1)]),
-            "the selected rail traverses every parent of its next junction"
-        );
-
-        app.update(Action::ScrollRight);
-        assert_eq!(app.junction_parent(0), Some(3));
-        assert_eq!(reachable(&app), HashSet::from([id(10), id(11), id(5), id(1)]));
-        app.update(Action::ScrollRight);
-        assert_eq!(app.junction_parent(0), Some(1));
-        assert_eq!(reachable(&app), HashSet::from([id(10), id(8), id(6), id(1)]));
-        app.update(Action::ScrollLeft);
-        assert_eq!(app.junction_parent(0), Some(3));
-        assert_eq!(
-            app.horizontal_offset, 0,
-            "junction selection suppresses horizontal panning"
-        );
-
-        app.update(Action::PreviewAuthorCopy(false));
-        app.update(Action::ScrollRight);
-        assert_eq!(app.horizontal_offset, 10, "releasing Shift restores horizontal panning");
-    }
-
     #[test]
     fn completion_and_copy_effects_use_the_current_selection() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 68bf8e9ccaf..194146fd8d9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -34,7 +34,7 @@ use crossterm::{
     cursor,
     event::{
         self, DisableFocusChange, DisableMouseCapture, EnableFocusChange, EnableMouseCapture, Event as TerminalEvent,
-        KeyCode, KeyEvent, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags, ModifierKeyCode, MouseEventKind,
+        KeyCode, KeyEvent, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags, MouseEventKind,
         PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
     },
     execute,
@@ -830,9 +830,7 @@ fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboa
         execute!(
             backend,
             PushKeyboardEnhancementFlags(
-                KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
-                    | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
-                    | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
+                KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
             )
         )?;
     }
@@ -905,7 +903,6 @@ fn event_loop(
     if recovered_at_startup {
         app.leave_message("worktree removed; using the common repository without worktree changes");
     }
-    app.manual_refresh = ref_watcher.is_none();
     let mut lane_receiver = None;
     let mut refresh_receiver: Option<mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
@@ -1013,7 +1010,6 @@ fn event_loop(
                 }
             };
             ref_watch_set_changed = false;
-            app.manual_refresh = ref_watcher.is_none();
             app.leave_message("worktree removed; using the common repository without worktree changes");
             if history_graph.is_some() {
                 refresh_pending = true;
@@ -1119,7 +1115,6 @@ fn event_loop(
             ref_watcher = None;
             ref_refresh_deadline = None;
             ref_watch_set_changed = false;
-            app.manual_refresh = true;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
@@ -1127,12 +1122,10 @@ fn event_loop(
                 match start_ref_watcher(&repository_path, &common_dir) {
                     Ok(watcher) => {
                         ref_watcher = Some(watcher);
-                        app.manual_refresh = false;
                     }
                     Err(err) => {
                         tracing::warn!(error = %err, "reference watcher rebuild failed");
                         ref_watcher = None;
-                        app.manual_refresh = true;
                         schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
                     }
                 }
@@ -1155,7 +1148,6 @@ fn event_loop(
                     Ok(watcher) => {
                         tracing::info!("reference watcher recovered");
                         ref_watcher = Some(watcher);
-                        app.manual_refresh = false;
                     }
                     Err(err) => {
                         tracing::warn!(error = %err, "reference watcher retry failed");
@@ -1526,7 +1518,6 @@ fn event_loop(
                 focused = false;
                 app.changes_suppressed = false;
                 repeat_deadline = None;
-                drop(app.update(Action::PreviewAuthorCopy(false)));
                 dirty = true;
                 urgent = true;
                 continue;
@@ -4238,18 +4229,10 @@ fn action(key: KeyEvent) -> Option<Action> {
 }
 
 fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, edit_expanded: bool) -> Option<Action> {
-    if key.kind == KeyEventKind::Release
-        && !matches!(
-            key.code,
-            KeyCode::Modifier(ModifierKeyCode::LeftShift | ModifierKeyCode::RightShift)
-        )
-    {
+    if key.kind == KeyEventKind::Release {
         return None;
     }
     match key.code {
-        KeyCode::Modifier(ModifierKeyCode::LeftShift | ModifierKeyCode::RightShift) => {
-            Some(Action::PreviewAuthorCopy(key.kind != KeyEventKind::Release))
-        }
         KeyCode::Tab => Some(Action::ToggleChangesFocus),
         KeyCode::Enter => Some(Action::OpenDiff),
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
@@ -4301,6 +4284,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
+        KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
@@ -5257,6 +5241,19 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('?'), KeyModifiers::SHIFT)),
             Some(Action::ToggleInformation)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('/'), KeyModifiers::SHIFT)),
+            Some(Action::ToggleInformation),
+            "terminals which preserve the base character map Shift-/ to information"
+        );
+        assert_eq!(
+            action(KeyEvent::new(
+                KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftShift),
+                KeyModifiers::SHIFT,
+            )),
+            None,
+            "standalone Shift has no application behavior"
+        );
         for (key, expected) in [
             ('d', Action::ToggleDate),
             ('e', Action::ToggleEmail),
@@ -5331,22 +5328,6 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('Y'), KeyModifiers::SHIFT)),
             Some(Action::CopyAuthor)
         );
-        assert_eq!(
-            action(KeyEvent::new_with_kind(
-                KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftShift),
-                KeyModifiers::SHIFT,
-                KeyEventKind::Press,
-            )),
-            Some(Action::PreviewAuthorCopy(true))
-        );
-        assert_eq!(
-            action(KeyEvent::new_with_kind(
-                KeyCode::Modifier(crossterm::event::ModifierKeyCode::LeftShift),
-                KeyModifiers::NONE,
-                KeyEventKind::Release,
-            )),
-            Some(Action::PreviewAuthorCopy(false))
-        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)),
             Some(Action::ForceQuit)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 5075006489b..57b3de81c60 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -385,10 +385,8 @@ pub(crate) fn draw_with_worktree(
     let align_metadata = app.align_metadata;
     let show_committer_date = app.show_committer_date;
     let name_mode = app.name_mode;
-    let preview_author_copy = app.preview_author_copy;
     let copy_feedback = app.copy_feedback.take();
-    let show_author_name =
-        preview_author_copy || copy_feedback == Some(CopyKind::Author) || name_mode != NameMode::None;
+    let show_author_name = copy_feedback == Some(CopyKind::Author) || name_mode != NameMode::None;
     let show_trailers = name_mode == NameMode::All && app.show_trailers;
     let ref_mode = app.ref_mode;
     let selected = app.selected;
@@ -408,11 +406,10 @@ pub(crate) fn draw_with_worktree(
                     show_emails: app.show_emails,
                     show_trailers,
                     has_notes: !app.notes(row.id).is_empty(),
-                    use_mailmap: app.use_mailmap && !preview_author_copy && copy_feedback != Some(CopyKind::Author),
+                    use_mailmap: app.use_mailmap && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
                     selected: (selected == Some(start + index) && app.show_selection_tail)
                         || compared_parent == Some(row.id),
-                    preview_author_copy,
                     copy_feedback: if selected == Some(start + index) {
                         copy_feedback
                     } else {
@@ -566,32 +563,6 @@ pub(crate) fn draw_with_worktree(
                 head_state,
             );
         }
-        let lane_offset = if align_metadata {
-            graph_offset
-        } else {
-            horizontal_offset
-        };
-        if let (Some(parent), Some(disk)) = (
-            app.junction_parent(start + index),
-            lane.chars().position(|symbol| symbol == '●'),
-        ) && disk >= lane_offset
-        {
-            let number = parent.to_string();
-            let x = disk + 1 - lane_offset;
-            if x < row_area.width as usize {
-                let width = number
-                    .chars()
-                    .count()
-                    .min(lane.chars().count().saturating_sub(disk + 1))
-                    .min(row_area.width as usize - x);
-                if width > 0 {
-                    frame.render_widget(
-                        Paragraph::new(number).style(style),
-                        Rect::new(row_area.x + x as u16, y, width as u16, 1),
-                    );
-                }
-            }
-        }
         if selected && app.show_selection_tail && body.width > 0 {
             let marker_limit = hidden_branch_marker
                 .as_ref()
@@ -939,21 +910,9 @@ pub(crate) fn draw_with_worktree(
     ordered.append(&mut view_prefix_spans);
     ordered.append(&mut edit_prefix_spans);
     ordered.push(Span::raw(" · "));
-    ordered.extend(if app.preview_author_copy {
-        shortcut("copY author", 'Y', true)
-    } else {
-        shortcut("copy", 'y', true)
-    });
+    ordered.extend(shortcut("copy", 'y', true));
     ordered.push(Span::raw(" · "));
-    if app.preview_author_copy && app.manual_refresh {
-        ordered.extend(shortcut(
-            "Refresh",
-            'R',
-            matches!(history_state, State::Complete | State::Cancelled),
-        ));
-    } else {
-        ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
-    }
+    ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     ordered.push(Span::raw(" · "));
     ordered.push(Span::styled("?", Style::default().add_modifier(Modifier::UNDERLINED)));
     if app.information_expanded {
@@ -978,7 +937,6 @@ pub(crate) fn draw_with_worktree(
         ordered.extend(shortcut("message", 'm', app.show_commit));
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
-        ordered.push(Span::raw(")"));
     }
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
@@ -988,6 +946,11 @@ pub(crate) fn draw_with_worktree(
     footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · <enter> diff"));
+    }
+    if app.information_expanded {
+        footer_spans.push(Span::raw(")"));
+    }
+    if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · "));
         footer_spans.extend(shortcut("quit", 'q', true));
     }
@@ -1654,7 +1617,6 @@ struct MetadataOptions {
     use_mailmap: bool,
     ref_mode: RefMode,
     selected: bool,
-    preview_author_copy: bool,
     copy_feedback: Option<CopyKind>,
 }
 
@@ -1676,11 +1638,10 @@ fn metadata_line<'a>(
         use_mailmap,
         ref_mode,
         selected,
-        preview_author_copy,
         copy_feedback,
     } = options;
     let id = row.id.to_hex().to_string();
-    let id_style = if preview_author_copy || copy_feedback == Some(CopyKind::Id) {
+    let id_style = if copy_feedback == Some(CopyKind::Id) {
         Style::default()
     } else {
         color(Color::Magenta).add_modifier(Modifier::BOLD)
@@ -1745,8 +1706,6 @@ fn metadata_line<'a>(
         let author = author_label(row.author, mailmap, use_mailmap, show_emails && !row.author.is_bot());
         let mut author_style = if copy_feedback == Some(CopyKind::Author) {
             Style::default()
-        } else if preview_author_copy {
-            color(Color::Magenta).add_modifier(Modifier::BOLD)
         } else {
             color(Color::Green)
         };
@@ -1856,7 +1815,6 @@ pub(crate) fn todo_metadata(
             use_mailmap: app.use_mailmap,
             ref_mode: app.ref_mode,
             selected: false,
-            preview_author_copy: false,
             copy_feedback: None,
         },
     );
@@ -2798,35 +2756,6 @@ mod tests {
             "the footer reflects the unfiltered view"
         );
 
-        app.manual_refresh = true;
-        app.update(Action::PreviewAuthorCopy(true));
-        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        let row = rendered_row(&terminal);
-        assert!(
-            row.contains("author subject"),
-            "holding Shift reveals the raw author even when names are hidden"
-        );
-        let buffer = terminal.backend().buffer();
-        let hash_x = row.find("0101010").expect("the commit hash is rendered") as u16;
-        let author_x = row.find("author").expect("the author is rendered") as u16;
-        assert_ne!(buffer[(hash_x, 0)].fg, Color::Magenta, "the hash yields its copy color");
-        assert_eq!(
-            buffer[(author_x, 0)].fg,
-            Color::Magenta,
-            "the author takes the copy color"
-        );
-        assert!(
-            rendered_line(&terminal, 1).contains("copY author"),
-            "the footer previews the shifted shortcut"
-        );
-        assert!(
-            rendered_line(&terminal, 1).contains("Refresh"),
-            "the footer previews the shifted refresh shortcut"
-        );
-        assert!(
-            !rendered_line(&terminal, 1).contains(" · refs"),
-            "the shifted refresh shortcut replaces the reference toggle"
-        );
         Ok(())
     }
 
@@ -2917,10 +2846,12 @@ mod tests {
         app.edit_expanded = false;
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let footer = rendered_line(&terminal, 1);
         assert!(
-            rendered_line(&terminal, 1)
-                .starts_with("0 commits · view · edit · copy · refs · ? ([ align · message · changes)"),
-            "the information prefix contains the post-reference view actions"
+            footer.starts_with(
+                    "0 commits · view · edit · copy · refs · ? ([ align · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                ),
+            "the information prefix contains every following action except quit: {footer}"
         );
         Ok(())
     }
@@ -3169,7 +3100,6 @@ mod tests {
             "the hash color returns on the next frame"
         );
 
-        drop(app.update(Action::PreviewAuthorCopy(true)));
         drop(app.update(Action::CopyAuthor));
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let selected_author = rendered_line(&terminal, 0)
@@ -3185,14 +3115,14 @@ mod tests {
         );
         assert_eq!(
             terminal.backend().buffer()[(other_author, 1)].fg,
-            Color::Magenta,
+            Color::Green,
             "author feedback does not affect other rows"
         );
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert_eq!(
             terminal.backend().buffer()[(selected_author, 0)].fg,
-            Color::Magenta,
+            Color::Green,
             "the author color returns on the next frame"
         );
         Ok(())
@@ -3916,6 +3846,40 @@ mod tests {
                 Some(&changes),
             );
         })?;
+        let mut footer_terminal = Terminal::new(TestBackend::new(240, 16))?;
+        footer_terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            rendered_line(&footer_terminal, 15)
+                .contains("? · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff · quit"),
+            "the collapsed information prefix leaves the following actions visible"
+        );
+        app.information_expanded = true;
+        footer_terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            rendered_line(&footer_terminal, 15).contains(
+                "? ([ align · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+            ),
+            "the expanded information prefix contains every following action except quit"
+        );
+        app.information_expanded = false;
 
         assert_eq!(
             terminal.backend().buffer()[(119, 7)].symbol(),
@@ -4681,41 +4645,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn dims_rows_outside_the_shift_reachability_set() -> Result<(), Box<dyn std::error::Error>> {
-        let mut app = App::new(2);
-        app.extend_commits(
-            (1..=2)
-                .map(|n| Commit {
-                    id: gix::ObjectId::Sha1([n; 20]),
-                    parent_ids: Default::default(),
-                    committer_time: gix::date::Time::default(),
-                    author: author(b"author", b"author@example.com"),
-                    attributions: 0..0,
-                    title: format!("subject {n}").into(),
-                    metadata_loaded: true,
-                    has_agent_marker: false,
-                    is_review: false,
-                    signature: SignatureState::Unsigned,
-                })
-                .collect::<Vec<_>>(),
-        );
-        complete(&mut app);
-        app.update(Action::PreviewAuthorCopy(true));
-        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-
-        assert!(
-            !terminal.backend().buffer()[(10, 0)].modifier.contains(Modifier::DIM),
-            "the anchor row remains bright"
-        );
-        assert!(
-            terminal.backend().buffer()[(10, 1)].modifier.contains(Modifier::DIM),
-            "an unreachable row is dimmed"
-        );
-        Ok(())
-    }
-
     #[test]
     fn renders_hidden_boundary_rows_without_colors() -> Result<(), Box<dyn std::error::Error>> {
         let commit = |n: u8| Commit {
@@ -4843,55 +4772,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn shows_the_selected_parent_beside_the_junction_disk() -> Result<(), Box<dyn std::error::Error>> {
-        let commit = |n: u8, parents: &[u8]| Commit {
-            id: gix::ObjectId::Sha1([n; 20]),
-            parent_ids: parents
-                .iter()
-                .map(|parent| gix::ObjectId::Sha1([*parent; 20]))
-                .collect(),
-            committer_time: gix::date::Time::default(),
-            author: author(b"author", b"author@example.com"),
-            attributions: 0..0,
-            title: format!("subject {n}").into(),
-            metadata_loaded: true,
-            has_agent_marker: false,
-            is_review: false,
-            signature: SignatureState::Unsigned,
-        };
-        let mut app = App::new(4);
-        app.extend_commits(vec![
-            commit(4, &[3, 2]),
-            commit(3, &[1]),
-            commit(2, &[1]),
-            commit(1, &[]),
-        ]);
-        complete(&mut app);
-        app.update(Action::PreviewAuthorCopy(true));
-        let mut terminal = Terminal::new(TestBackend::new(80, 5))?;
-
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        let metadata_x = rendered_row(&terminal)
-            .find("0404040")
-            .expect("the junction metadata is visible");
-        assert_eq!(
-            terminal.backend().buffer()[(3, 0)].symbol(),
-            "2",
-            "the initial parent number replaces the connector beside the disk"
-        );
-
-        app.update(Action::ScrollRight);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(terminal.backend().buffer()[(3, 0)].symbol(), "1");
-        assert_eq!(
-            rendered_row(&terminal).find("0404040"),
-            Some(metadata_x),
-            "cycling parents does not shift metadata"
-        );
-        Ok(())
-    }
-
     #[test]
     fn uses_the_tig_palette_without_coloring_the_selection() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
@@ -4952,7 +4832,6 @@ mod tests {
                 use_mailmap: false,
                 ref_mode: RefMode::All,
                 selected: false,
-                preview_author_copy: false,
                 copy_feedback: None,
             },
         );

From 3ecfbf30b339bc40e722814f144d14da3f6a6bca Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 11:26:19 +0200
Subject: [PATCH 106/282] feat: edit references in tix rebase todos

Render mutable local references as standalone todo lines so rebases can move, create, detach, or delete them explicitly. Keep the commit checkout marker alongside an attached branch marker and require both to agree.

Apply checked-out reference moves through the existing worktree transition path, reject deletion from linked worktrees, and defer deleting the current branch until checkout succeeds. Preserve these semantics across suspended conflict continuations and document the todo contract.
---
 gix-tix/spec.md                 |  40 ++-
 gix-tix/src/app.rs              |   5 -
 gix-tix/src/command/rebase.rs   |  15 +-
 gix-tix/src/edit/rebase.rs      | 344 +++++++++++++++++-----
 gix-tix/src/edit/time_travel.rs |  86 +++++-
 gix-tix/src/edit/todo.rs        | 499 +++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs              |  23 +-
 7 files changed, 853 insertions(+), 159 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2fc2de57f53..26d523ca52f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -535,10 +535,12 @@ space first; changes blocks adapt within the remaining history width.
   so it never carries a usable signature. Automatically rebased descendants
   retain their author and receive one configured current committer identity and
   timestamp for the operation.
-- All mutable local refs pointing anywhere into the rewritten set are changed in
-  one compare-and-swap transaction. A checkout failure rolls back already-applied
-  worktree transitions and the ref transaction; newly written unreachable objects
-  may remain for normal Git garbage collection.
+- Ordinary edits retarget mutable local refs pointing into the rewritten set.
+  History todos instead use their explicit reference lines. Ref changes use
+  compare-and-swap transactions; a checkout failure rolls back already-applied
+  worktree transitions and the ref transaction, except that deleting the branch
+  being departed necessarily follows the successful checkout. Newly written
+  unreachable objects may remain for normal Git garbage collection.
 - A suspended conflict temporarily owns a cloned repository with object memory
   while awaiting one confirmation key. Dropping it writes nothing; accepting it
   consumes the repository immediately after persisting and checking out the
@@ -586,13 +588,24 @@ space first; changes blocks adapt within the remaining history width.
   use Git-compatible C-style quoting so arbitrary ref bytes round-trip. Missing
   state cancels; present invalid state never reaches repository mutation. The
   state comment follows the complete help at the end of the document.
+- Standalone `(ref, ref)` lines place direct mutable refs at the preceding fork
+  heading or command result. Multiple consecutive lines share that destination.
+  Existing displayed names may be moved or removed, and new unqualified names
+  create local branches; explicit editable `refs/...` names are also accepted.
+  Short names follow the history display, ambiguous names expand to full names,
+  and Git quoting preserves arbitrary bytes. Tags, remote-tracking refs, general
+  symbolic refs, tix pins, and review resources remain hidden and unchanged.
 - Pick lines use display-only state symbols documented in the footer: `↻` for a
   lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
   unverified signature, and `○` for an unsigned commit. Applicable states may be
   combined without changing plan semantics.
-- `@pick`, `@squash`, or `@empty` chooses the post-rebase checkout. When the current worktree
-  `HEAD` is in the editable region, exactly one generated `@` must remain; without
-  one, zero or one may be added. A checkout marker is invalid without a worktree.
+- `@pick`, `@squash`, or `@empty` chooses the post-rebase commit. A generated
+  todo keeps this marker even when `HEAD` is attached, and additionally marks
+  its local branch as `@branch`. One command marker and one branch marker may
+  coexist only when they resolve to the same result. Removing only the branch
+  marker detaches `HEAD` without deleting the branch; removing the name deletes
+  it. Checkout markers are invalid without a worktree. Todo generation and
+  application reject an unborn `HEAD`.
 - Only the ancestry ending at `@` and any squash groups are eagerly cherry-picked
   and re-signed. Other resulting stacks retain their trees, receive pending-rebase
   markers, and invalidate old signatures for later time travel. With no `@`,
@@ -621,11 +634,14 @@ space first; changes blocks adapt within the remaining history width.
   durations. `pick`, `squash`, and `empty` commands each contribute to the total;
   squash sources advance separately while their combined commit is signed once.
   Fast operations and command-line `tix rebase apply` do not show progress.
-- Mutable refs captured on original leaves stay tips: after their commit is
-  rewritten or dropped, they follow the first continuation in todo order to its
-  resulting leaf. Other mutable refs remain bound to their rewritten commit.
-  All moves use one compare-and-swap transaction; tags and remote-tracking refs
-  remain untouched. Every other resulting leaf gets a direct
+- Displayed mutable refs follow their explicit locations in the edited todo;
+  omission deletes them and newly named refs require nonexistence. Refs checked
+  out by linked worktrees are displayed normally and may move, with their index
+  and worktree updated through the same preflighted transition as other rebases,
+  but may not be deleted. The current worktree's branch may be deleted only when
+  the todo also moves or detaches `HEAD`; deletion is deferred until checkout
+  succeeds. All remaining moves use one compare-and-swap transaction. Every
+  other resulting leaf gets a direct
   `refs/worktree/tix/pins/*` ref, except the checked-out leaf. When `@` moves below
   a referenced leaf, the existing time-travel checkout detaches `HEAD` there while
   the ref stays at the leaf. Concurrent ref edits win by making the transaction
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 9c37ba49d1e..93c90f1e527 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -340,7 +340,6 @@ pub(crate) enum Effect {
         base: ObjectId,
         onto: ObjectId,
         commits: Vec<ObjectId>,
-        head: Option<ObjectId>,
     },
     StartReview {
         tip: ObjectId,
@@ -1040,7 +1039,6 @@ impl App {
                     base,
                     onto: base,
                     commits: self.hidden_descendants(base),
-                    head: self.worktree_head,
                 }];
             }
             Action::RebaseUpdate if self.can_rebase_update() => {
@@ -1049,7 +1047,6 @@ impl App {
                     base,
                     onto: self.hidden_branch_updates[&base].1,
                     commits: self.hidden_descendants(base),
-                    head: self.worktree_head,
                 }];
             }
             Action::Review if self.can_finish_review() => {
@@ -3009,7 +3006,6 @@ mod tests {
                 base: id(1),
                 onto: id(1),
                 commits: vec![id(3), id(2)],
-                head: None,
             }],
             "the todo receives all visible descendants"
         );
@@ -3025,7 +3021,6 @@ mod tests {
                 base: id(1),
                 onto: id(4),
                 commits: vec![id(3), id(2)],
-                head: None,
             }],
             "rebase-update retains the editable scope but changes its root"
         );
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 5d36761d01e..d2a8b35e55b 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -193,8 +193,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
             })
         })
         .collect::<Result<Vec<_>>>()?;
-    let head = repo.head()?.id().map(gix::Id::detach);
-    todo::prepare(repo, base, onto, &commits, head, &resolved_tips, todo::OntoKind::Onto)
+    todo::prepare(repo, base, onto, &commits, &resolved_tips, todo::OntoKind::Onto)
 }
 
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
@@ -244,8 +243,15 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
         rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
             if let Some(selected) = outcome.selected {
-                let notice =
-                    edit::time_travel::checkout_without_replay(&repository_path, bare, selected, &revisions, false)?;
+                let notice = edit::time_travel::checkout_plan(
+                    &repository_path,
+                    bare,
+                    selected,
+                    outcome.checkout_reference.as_ref(),
+                    &outcome.deferred_ref_deletions,
+                    &revisions,
+                    false,
+                )?;
                 println!("{}", notice.unwrap_or_else(|| "rebased history".into()));
             } else {
                 println!("rebased history");
@@ -404,7 +410,6 @@ mod tests {
                     info: "middle".into(),
                 },
             ],
-            Some(tip),
             &[tip],
             todo::OntoKind::Onto,
         )?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 4701f446770..3c902ede858 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -94,10 +94,18 @@ pub(crate) struct PlanStep {
 #[derive(Clone, Debug)]
 pub(crate) struct ExpectedRef {
     pub name: gix::refs::FullName,
-    pub old: ObjectId,
+    pub old: Option<ObjectId>,
     pub target: ObjectId,
-    pub new: ObjectId,
+    pub new: Option<ObjectId>,
     pub follows_tip: bool,
+    pub editable: bool,
+    pub placement: Option<PlanParent>,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct PlanCheckout {
+    pub target: PlanParent,
+    pub reference: Option<gix::refs::FullName>,
 }
 
 #[derive(Clone, Debug)]
@@ -105,7 +113,7 @@ pub(crate) struct Plan {
     pub base: ObjectId,
     pub scope: Vec<ObjectId>,
     pub steps: Vec<PlanStep>,
-    pub checkout: Option<usize>,
+    pub checkout: Option<PlanCheckout>,
     pub expected_refs: Vec<ExpectedRef>,
 }
 
@@ -184,9 +192,17 @@ impl PlanConflict {
             .map(|expected| ExpectedRef {
                 name: expected.name.clone(),
                 old: expected.old,
-                target: expected.new,
+                target: expected.new.expect("continued refs have a target"),
                 new: expected.new,
                 follows_tip: expected.follows_tip,
+                editable: expected.editable,
+                placement: expected.placement.map(|target| match target {
+                    PlanParent::Existing(id) => PlanParent::Existing(id),
+                    PlanParent::Step(index) if index < self.continuation_start => {
+                        PlanParent::Existing(self.produced[index])
+                    }
+                    PlanParent::Step(index) => PlanParent::Step(index - self.continuation_start),
+                }),
             })
             .collect();
         let mut scope = self.produced[self.continuation_start..].to_vec();
@@ -220,7 +236,16 @@ impl PlanConflict {
                     squash: self.remaining_squash[index].clone(),
                 })
                 .collect(),
-            checkout: self.plan.checkout.map(|index| index - self.continuation_start),
+            checkout: self.plan.checkout.as_ref().map(|checkout| PlanCheckout {
+                target: match checkout.target {
+                    PlanParent::Existing(id) => PlanParent::Existing(id),
+                    PlanParent::Step(index) if index < self.continuation_start => {
+                        PlanParent::Existing(self.produced[index])
+                    }
+                    PlanParent::Step(index) => PlanParent::Step(index - self.continuation_start),
+                },
+                reference: checkout.reference.clone(),
+            }),
             expected_refs,
         }
     }
@@ -232,6 +257,8 @@ impl PlanConflict {
 
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
+    pub checkout_reference: Option<gix::refs::FullName>,
+    pub deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
@@ -269,12 +296,13 @@ impl Conflict {
     }
 
     pub(crate) fn persist(mut self) -> Result<PersistedConflict> {
-        self.prepared.finish()?;
+        let outcome = self.prepared.finish()?;
         Ok(PersistedConflict {
             repo: self.prepared.repo,
             conflicts: self.conflicts,
             tree: self.tree,
             commit: self.commit,
+            deferred_ref_deletions: outcome.deferred_ref_deletions,
         })
     }
 }
@@ -284,6 +312,7 @@ pub(crate) struct PersistedConflict {
     conflicts: Vec<gix::merge::tree::Conflict>,
     tree: ObjectId,
     pub(crate) commit: ObjectId,
+    pub(crate) deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
 }
 
 impl PersistedConflict {
@@ -317,6 +346,8 @@ struct Prepared {
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
     committer: gix::actor::Signature,
     expected_refs: Option<Vec<ExpectedRef>>,
+    checkout_reference: Option<gix::refs::FullName>,
+    checkout_after_finish: bool,
     pins: Vec<ObjectId>,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
 }
@@ -344,26 +375,16 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
         if scope.contains(&old) && seen.insert(reference.name().to_owned()) {
             out.push(ExpectedRef {
                 name: reference.name().to_owned(),
-                old,
+                old: Some(old),
                 target: old,
-                new: old,
+                new: Some(old),
                 follows_tip: tips.contains(&old),
+                editable: !reference.name().as_bstr().starts_with(crate::history::PIN_PREFIX)
+                    && !reference.name().as_bstr().starts_with(crate::history::REVIEW_PREFIX),
+                placement: None,
             });
         }
     }
-    if let Some(head) = repo.try_find_reference("HEAD")?
-        && let Some(old) = head.try_id().map(gix::Id::detach)
-        && scope.contains(&old)
-        && seen.insert(head.name().to_owned())
-    {
-        out.push(ExpectedRef {
-            name: head.name().to_owned(),
-            old,
-            target: old,
-            new: old,
-            follows_tip: tips.contains(&old),
-        });
-    }
     Ok(out)
 }
 
@@ -588,6 +609,7 @@ fn perform_inner(
 
     let marked = (!forked && matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants))
         || conflict.is_some();
+    let checkout_after_finish = conflict.is_some();
     let mut prepared = Prepared {
         repo,
         root,
@@ -600,6 +622,8 @@ fn perform_inner(
         rewritten,
         committer,
         expected_refs: None,
+        checkout_reference: None,
+        checkout_after_finish,
         pins: if forked {
             selected.into_iter().collect()
         } else {
@@ -746,6 +770,8 @@ pub(super) fn finish_review(
         rewritten,
         committer,
         expected_refs: None,
+        checkout_reference: None,
+        checkout_after_finish: false,
         pins: Vec::new(),
         delete_refs,
     };
@@ -801,13 +827,13 @@ pub(crate) fn perform_plan_with_progress(
     }
 
     let mut eager = HashSet::new();
-    let mut cursor = plan.checkout;
-    while let Some(index) = cursor {
+    let mut cursor = plan.checkout.as_ref().map(|checkout| checkout.target);
+    while let Some(PlanParent::Step(index)) = cursor {
         if !eager.insert(index) {
             anyhow::bail!("the checkout ancestry contains a cycle");
         }
         cursor = match plan.steps.get(index).context("the checkout step is missing")?.parent {
-            PlanParent::Step(parent) => Some(parent),
+            parent @ PlanParent::Step(_) => Some(parent),
             PlanParent::Existing(_) => None,
         };
     }
@@ -1016,17 +1042,24 @@ pub(crate) fn perform_plan_with_progress(
         primary_children.entry(parent).or_insert(produced[index]);
     }
     for expected in &mut plan.expected_refs {
-        let mut target = rewritten
-            .get(&expected.target)
-            .copied()
-            .flatten()
-            .context("a captured reference target disappeared from the rebase plan")?;
-        if expected.follows_tip {
-            while let Some(child) = primary_children.get(&target) {
-                target = *child;
+        if let Some(target) = expected.placement {
+            expected.new = Some(match target {
+                PlanParent::Existing(id) => id,
+                PlanParent::Step(index) => *produced.get(index).context("a reference points to a missing step")?,
+            });
+        } else if expected.new.is_some() {
+            let mut target = rewritten
+                .get(&expected.target)
+                .copied()
+                .flatten()
+                .unwrap_or(expected.target);
+            if expected.follows_tip {
+                while let Some(child) = primary_children.get(&target) {
+                    target = *child;
+                }
             }
+            expected.new = Some(target);
         }
-        expected.new = target;
     }
 
     let planned_non_leaves: HashSet<_> = plan
@@ -1039,15 +1072,23 @@ pub(crate) fn perform_plan_with_progress(
         .collect();
     let mut pins = Vec::new();
     for (index, id) in produced.iter().copied().enumerate() {
-        if planned_non_leaves.contains(&index) || plan.checkout == Some(index) {
+        if planned_non_leaves.contains(&index)
+            || plan
+                .checkout
+                .as_ref()
+                .is_some_and(|checkout| checkout.target == PlanParent::Step(index))
+        {
             continue;
         }
-        let referenced = plan.expected_refs.iter().any(|expected| expected.new == id);
+        let referenced = plan.expected_refs.iter().any(|expected| expected.new == Some(id));
         if !referenced {
             pins.push(id);
         }
     }
-    let selected = plan.checkout.map(|index| produced[index]);
+    let selected = plan.checkout.as_ref().map(|checkout| match checkout.target {
+        PlanParent::Existing(id) => id,
+        PlanParent::Step(index) => produced[index],
+    });
     let marked = plan
         .steps
         .iter()
@@ -1063,6 +1104,8 @@ pub(crate) fn perform_plan_with_progress(
         rewritten: rewritten.clone(),
         committer,
         expected_refs: Some(plan.expected_refs.clone()),
+        checkout_reference: plan.checkout.as_ref().and_then(|checkout| checkout.reference.clone()),
+        checkout_after_finish: false,
         pins,
         delete_refs,
     };
@@ -1081,14 +1124,18 @@ pub(crate) fn perform_plan_with_progress(
 
     let continuation_start = plan
         .checkout
-        .filter(|index| *index < conflict_step)
+        .as_ref()
+        .and_then(|checkout| match checkout.target {
+            PlanParent::Step(index) if index < conflict_step => Some(index),
+            _ => None,
+        })
         .map_or(conflict_step, |_| 0);
     let affected_steps: HashSet<_> = (continuation_start..plan.steps.len()).collect();
     let affected_ids: HashSet<_> = affected_steps.iter().map(|index| produced[*index]).collect();
     let final_refs: Vec<_> = plan
         .expected_refs
         .iter()
-        .filter(|expected| !affected_ids.contains(&expected.new))
+        .filter(|expected| expected.new.is_none_or(|new| !affected_ids.contains(&new)))
         .cloned()
         .collect();
     let final_ref_names = final_refs.iter().map(|expected| expected.name.clone()).collect();
@@ -1098,10 +1145,12 @@ pub(crate) fn perform_plan_with_progress(
         remaining_squash[index].clone_from(&step.squash);
     }
     prepared.selected = None;
+    prepared.checkout_reference = None;
+    prepared.checkout_after_finish = true;
     prepared.reset_index = false;
     prepared.rewritten = final_refs
         .iter()
-        .map(|expected| (expected.old, Some(expected.new)))
+        .filter_map(|expected| expected.old.map(|old| (old, expected.new)))
         .collect();
     prepared.expected_refs = Some(final_refs);
     prepared.pins.retain(|id| !affected_ids.contains(id));
@@ -1136,7 +1185,12 @@ impl Prepared {
                 .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
         }
 
-        let transitions = worktree_transitions(&self.repo, &self.rewritten, self.skip_worktree_transitions)?;
+        let transitions = worktree_transitions(
+            &self.repo,
+            &self.rewritten,
+            self.expected_refs.as_deref(),
+            self.skip_worktree_transitions,
+        )?;
         let index_reset_from = if self.reset_index { self.root } else { None };
         let index_resets = index_reset_from
             .map(|old| index_resets(&self.repo, &self.rewritten, old))
@@ -1149,6 +1203,24 @@ impl Prepared {
                 transition.new,
             )?;
         }
+        let current_ref = self.repo.head()?.referent_name().map(ToOwned::to_owned);
+        let mut deferred_ref_deletions = Vec::new();
+        if let (Some(expected_refs), Some(current_ref)) = (&mut self.expected_refs, current_ref) {
+            if expected_refs
+                .iter()
+                .any(|expected| expected.name == current_ref && expected.old.is_some() && expected.new.is_none())
+                && (self.repo.workdir().is_none() || (self.selected.is_none() && !self.checkout_after_finish))
+            {
+                anyhow::bail!("cannot delete the checked-out branch without selecting another checkout");
+            }
+            expected_refs.retain(|expected| {
+                let defer = expected.name == current_ref && expected.old.is_some() && expected.new.is_none();
+                if defer {
+                    deferred_ref_deletions.push((expected.name.clone(), expected.old.expect("checked above")));
+                }
+                !defer
+            });
+        }
         let rollback_refs = update_refs(
             &self.repo,
             &self.rewritten,
@@ -1183,6 +1255,8 @@ impl Prepared {
         }
         Ok(Outcome {
             selected: self.selected,
+            checkout_reference: self.checkout_reference.clone(),
+            deferred_ref_deletions,
             rewritten: std::mem::take(&mut self.rewritten),
         })
     }
@@ -1622,6 +1696,7 @@ struct Transition {
 fn worktree_transitions(
     repo: &gix::Repository,
     rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+    expected_refs: Option<&[ExpectedRef]>,
     inserted: bool,
 ) -> Result<Vec<Transition>> {
     if inserted {
@@ -1642,16 +1717,29 @@ fn worktree_transitions(
         if !seen.insert(worktree_repo.git_dir().to_owned()) {
             continue;
         }
-        let Some(old) = worktree_repo
-            .head()
-            .ok()
-            .and_then(|head| head.id().map(gix::Id::detach))
-        else {
+        let Ok(head) = worktree_repo.head() else {
             continue;
         };
-        let Some(new) = rewritten.get(&old).copied() else {
+        let Some(old) = head.id().map(gix::Id::detach) else {
             continue;
         };
+        let planned = head.referent_name().and_then(|name| {
+            expected_refs.and_then(|refs| refs.iter().find(|expected| expected.name.as_bstr() == name.as_bstr()))
+        });
+        let new = match planned {
+            Some(expected) if expected.new.is_none() => {
+                if worktree_repo.git_dir() == repo.git_dir() {
+                    continue;
+                }
+                anyhow::bail!(
+                    "cannot delete {} because another worktree has it checked out",
+                    expected.name.shorten()
+                );
+            }
+            Some(expected) => Some(expected.new),
+            None => rewritten.get(&old).copied(),
+        };
+        let Some(new) = new else { continue };
         if worktree_repo.workdir().is_none() && worktree_repo.is_bare() {
             continue;
         }
@@ -1696,8 +1784,11 @@ fn update_refs(
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
                 continue;
             }
-            edits.push(ref_edit(name.clone(), old, Some(new)));
-            rollback.push(reverse_ref_edit(name, old, Some(new)));
+            if old == new {
+                continue;
+            }
+            edits.push(ref_edit(name.clone(), old, new));
+            rollback.push(ref_edit(name, new, old));
         }
     } else {
         for reference in repo.references()?.all()? {
@@ -1720,16 +1811,16 @@ fn update_refs(
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
                 continue;
             }
-            edits.push(ref_edit(name.clone(), old, *new));
-            rollback.push(reverse_ref_edit(name, old, *new));
+            edits.push(ref_edit(name.clone(), Some(old), *new));
+            rollback.push(ref_edit(name, *new, Some(old)));
         }
         if let Some(head) = repo.try_find_reference("HEAD")?
             && let Some(old) = head.try_id().map(gix::Id::detach)
             && let Some(new) = rewritten.get(&old)
         {
             let name = head.name().to_owned();
-            edits.push(ref_edit(name.clone(), old, *new));
-            rollback.push(reverse_ref_edit(name, old, *new));
+            edits.push(ref_edit(name.clone(), Some(old), *new));
+            rollback.push(ref_edit(name, *new, Some(old)));
         }
     }
     if unborn {
@@ -1850,39 +1941,26 @@ fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
     }
 }
 
-fn reverse_ref_edit(name: gix::refs::FullName, old: ObjectId, new: Option<ObjectId>) -> RefEdit {
-    RefEdit {
-        name,
-        deref: false,
-        change: match new {
-            Some(new) => Change::Update {
-                log: log_change(),
-                expected: PreviousValue::MustExistAndMatch(Target::Object(new)),
-                new: Target::Object(old),
-            },
-            None => Change::Update {
-                log: log_change(),
-                expected: PreviousValue::MustNotExist,
-                new: Target::Object(old),
-            },
-        },
-    }
-}
-
-fn ref_edit(name: gix::refs::FullName, old: ObjectId, new: Option<ObjectId>) -> RefEdit {
+fn ref_edit(name: gix::refs::FullName, old: Option<ObjectId>, new: Option<ObjectId>) -> RefEdit {
     RefEdit {
         name,
         deref: false,
-        change: match new {
-            Some(new) => Change::Update {
+        change: match (old, new) {
+            (Some(old), Some(new)) => Change::Update {
                 log: log_change(),
                 expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
                 new: Target::Object(new),
             },
-            None => Change::Delete {
+            (Some(old), None) => Change::Delete {
                 expected: PreviousValue::MustExistAndMatch(Target::Object(old)),
                 log: RefLog::AndReference,
             },
+            (None, Some(new)) => Change::Update {
+                log: log_change(),
+                expected: PreviousValue::MustNotExist,
+                new: Target::Object(new),
+            },
+            (None, None) => unreachable!("unchanged absent refs are filtered before editing"),
         },
     }
 }
@@ -2285,7 +2363,10 @@ mod tests {
                     commit: PlanCommit::Pick(tip),
                     squash: Vec::new(),
                 }],
-                checkout: Some(0),
+                checkout: Some(PlanCheckout {
+                    target: PlanParent::Step(0),
+                    reference: None,
+                }),
                 expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?
@@ -2347,7 +2428,10 @@ mod tests {
                         squash: Vec::new(),
                     },
                 ],
-                checkout: Some(0),
+                checkout: Some(PlanCheckout {
+                    target: PlanParent::Step(0),
+                    reference: None,
+                }),
                 expected_refs,
             },
             |update| progress.push(update),
@@ -2632,7 +2716,10 @@ mod tests {
                         squash: Vec::new(),
                     },
                 ],
-                checkout: Some(0),
+                checkout: Some(PlanCheckout {
+                    target: PlanParent::Step(0),
+                    reference: None,
+                }),
                 expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?
@@ -2736,7 +2823,10 @@ mod tests {
                         squash: Vec::new(),
                     },
                 ],
-                checkout: Some(1),
+                checkout: Some(PlanCheckout {
+                    target: PlanParent::Step(1),
+                    reference: None,
+                }),
                 expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?
@@ -2804,6 +2894,102 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn checked_out_linked_worktree_refs_move_but_cannot_be_deleted() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let linked_root = gix_testtools::tempfile::tempdir()?;
+        let linked = linked_root.path().join("linked");
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["worktree", "add", "-q", "-b", "linked"])
+                .arg(&linked)
+                .arg("HEAD")
+                .status()?
+                .success(),
+            "the linked worktree is created"
+        );
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let steps = || {
+            vec![
+                PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(middle),
+                    squash: Vec::new(),
+                },
+                PlanStep {
+                    parent: PlanParent::Step(0),
+                    commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
+                },
+            ]
+        };
+
+        let mut deleting = capture_refs(&repo, &[middle, tip], &[tip])?;
+        let linked_ref = deleting
+            .iter_mut()
+            .find(|reference| reference.name.as_bstr() == b"refs/heads/linked")
+            .expect("the linked branch is captured");
+        linked_ref.new = None;
+        let err = match perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: steps(),
+                checkout: None,
+                expected_refs: deleting,
+            },
+        ) {
+            Ok(_) => return Err("a checked-out linked branch was deleted".into()),
+            Err(err) => err,
+        };
+        assert!(
+            format!("{err:#}").contains("another worktree has it checked out"),
+            "the refusal identifies the linked-worktree constraint"
+        );
+
+        let mut moving = capture_refs(&repo, &[middle, tip], &[tip])?;
+        let linked_ref = moving
+            .iter_mut()
+            .find(|reference| reference.name.as_bstr() == b"refs/heads/linked")
+            .expect("the linked branch is captured");
+        linked_ref.new = None;
+        linked_ref.placement = Some(PlanParent::Step(0));
+        let outcome = perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: steps(),
+                checkout: None,
+                expected_refs: moving,
+            },
+        )?
+        .complete()?;
+        assert_eq!(
+            repo.find_reference("refs/heads/linked")?.id().detach(),
+            outcome.map(middle).expect("the middle commit is retained"),
+            "the linked branch moves to its explicit todo destination"
+        );
+        assert!(
+            linked.join("middle").is_file(),
+            "the linked worktree receives the new tree"
+        );
+        assert!(
+            !linked.join("tip").exists(),
+            "files beyond the moved branch are removed"
+        );
+        Ok(())
+    }
+
     #[test]
     fn dropping_a_pick_moves_its_mutable_refs_to_the_nearest_retained_ancestor() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 86e580280e4..0d7dbe88048 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -56,6 +56,7 @@ impl Conflict {
             self.include_worktrees,
         )?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
+        delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
         conflict.write_index()?;
         Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
     }
@@ -73,6 +74,7 @@ pub(crate) fn materialize_plan_conflict(
     let mut conflict = conflict.into_conflict().persist()?;
     let notice = move_head(repository_path, bare, conflict.commit, revisions, include_worktrees)?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
+    delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
     conflict.write_index()?;
     tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
     Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
@@ -88,12 +90,37 @@ pub(crate) fn checkout_without_replay(
     move_head(repository_path, bare, selected, revisions, include_worktrees)
 }
 
+pub(crate) fn checkout_plan(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    reference: Option<&gix::refs::FullName>,
+    deferred_ref_deletions: &[(gix::refs::FullName, ObjectId)],
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<Option<String>> {
+    let notice = move_head_to(repository_path, bare, selected, reference, revisions, include_worktrees)?;
+    delete_deferred_refs(repository_path, bare, deferred_ref_deletions)?;
+    Ok(notice)
+}
+
 fn move_head(
     repository_path: &Path,
     bare: bool,
     selected: ObjectId,
     revisions: &[OsString],
     include_worktrees: bool,
+) -> Result<Option<String>> {
+    move_head_to(repository_path, bare, selected, None, revisions, include_worktrees)
+}
+
+fn move_head_to(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    reference: Option<&gix::refs::FullName>,
+    revisions: &[OsString],
+    include_worktrees: bool,
 ) -> Result<Option<String>> {
     let repository = open_repository(repository_path, bare, false).context("could not open repository for checkout")?;
     let workdir = repository
@@ -105,20 +132,19 @@ fn move_head(
         .id()
         .map(gix::Id::detach)
         .context("cannot time-travel from an unborn HEAD")?;
-    let saved_target = head
-        .referent_name()
-        .map(ToOwned::to_owned)
-        .map_or(Target::Object(head_id), Target::Symbolic);
+    let head_ref = head.referent_name().map(ToOwned::to_owned);
+    let saved_target = head_ref.clone().map_or(Target::Object(head_id), Target::Symbolic);
     drop(head);
-    if selected == head_id {
+    if selected == head_id && head_ref.as_ref() == reference {
         return Ok(None);
     }
     let destination_pin = selected_pin(&repository, selected)?;
     let provisional = create_or_reuse_pin(&repository, saved_target, head_id)?;
     drop(repository);
-    let checkout = match &destination_pin {
-        Some(pin) => checkout_pin(&workdir, pin),
-        None => checkout_detached(&workdir, selected),
+    let checkout = match (reference, &destination_pin) {
+        (Some(reference), _) => checkout_branch(&workdir, reference),
+        (None, Some(pin)) => checkout_pin(&workdir, pin),
+        (None, None) => checkout_detached(&workdir, selected),
     };
     if let Err(checkout) = checkout {
         if provisional.1 {
@@ -134,9 +160,14 @@ fn move_head(
         }
         return Err(checkout);
     }
-    let mut notice = destination_pin.as_ref().map_or_else(
-        || format!("time-travelled to {}", selected.to_hex_with_len(7)),
-        |pin| format!("returned from {}", pin_label(pin)),
+    let mut notice = reference.map_or_else(
+        || {
+            destination_pin.as_ref().map_or_else(
+                || format!("time-travelled to {}", selected.to_hex_with_len(7)),
+                |pin| format!("returned from {}", pin_label(pin)),
+            )
+        },
+        |reference| format!("checked out {}", reference.shorten()),
     );
     let repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
@@ -569,6 +600,39 @@ fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     Ok(())
 }
 
+fn delete_deferred_refs(repository_path: &Path, bare: bool, refs: &[(gix::refs::FullName, ObjectId)]) -> Result<()> {
+    if refs.is_empty() {
+        return Ok(());
+    }
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not reopen repository to finish reference deletions")?;
+    repository
+        .edit_references(refs.iter().map(|(name, old)| RefEdit {
+            name: name.clone(),
+            deref: false,
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(Target::Object(*old)),
+                log: RefLog::AndReference,
+            },
+        }))
+        .context("could not delete the branch HEAD left during rebase")?;
+    Ok(())
+}
+
+fn checkout_branch(workdir: &Path, name: &gix::refs::FullName) -> Result<()> {
+    let branch = name
+        .as_bstr()
+        .strip_prefix(b"refs/heads/")
+        .context("the rebase checkout target is not a local branch")?;
+    checkout(
+        workdir,
+        [
+            OsString::from("--no-guess"),
+            gix::path::from_bstr(branch.as_bstr()).into_owned().into_os_string(),
+        ],
+    )
+}
+
 fn checkout_pin(workdir: &Path, pin: &history::Pin) -> Result<()> {
     match pin.target.try_name() {
         Some(name) => {
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 297db520ac5..4e56dac0f42 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -20,9 +20,9 @@ const HELP: &str = r#"
 - `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
-- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Retain exactly one generated marker; if none was generated, add at most one. A checkout marker requires a worktree.
+- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. Prefix one local branch with `@` to attach HEAD to it. `@command` and `@branch` may coexist only at the same result. Removing only the branch's `@` detaches HEAD without deleting the branch.
 - Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
-- Mutable refs on original leaves stay on the primary resulting leaf; the first continuation in todo order is primary. Other mutable refs follow their commits. Tags and remote-tracking refs stay unchanged, and new unreferenced leaves are pinned.
+- Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
 - Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
 -->
@@ -57,6 +57,7 @@ struct State {
     scope: Vec<ObjectId>,
     marker_required: bool,
     checkout_allowed: bool,
+    edit_refs: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
     resolved: Option<ObjectId>,
     continuation_sources: Vec<ObjectId>,
@@ -79,16 +80,30 @@ pub(crate) fn prepare(
     base: ObjectId,
     onto: ObjectId,
     commits: &[Commit],
-    head: Option<ObjectId>,
     resolved_tips: &[ObjectId],
     onto_kind: OntoKind,
 ) -> Result<Prepared> {
     repo.find_commit(base)
         .context("could not find the selected rebase base")?;
     repo.find_commit(onto).context("could not find the rebase target")?;
+    let head_state = repo.head()?;
+    let head = head_state
+        .id()
+        .map(gix::Id::detach)
+        .context("rebase todos require a born HEAD")?;
+    let head_ref = repo
+        .workdir()
+        .is_some()
+        .then(|| {
+            head_state
+                .referent_name()
+                .filter(|name| name.category() == Some(gix::refs::Category::LocalBranch))
+                .map(ToOwned::to_owned)
+        })
+        .flatten();
     let scope: Vec<_> = commits.iter().map(|commit| commit.id).collect();
     let scope_set: HashSet<_> = scope.iter().copied().collect();
-    let marker_required = head.is_some_and(|head| scope_set.contains(&head));
+    let marker_required = repo.workdir().is_some() && scope_set.contains(&head);
     let mut tips = scope_set.clone();
     for commit in commits {
         for parent in &commit.parents {
@@ -96,7 +111,6 @@ pub(crate) fn prepare(
         }
     }
     let tips = tips.into_iter().collect::<Vec<_>>();
-    let expected_refs = rebase::capture_refs(repo, &scope, &tips)?;
     let has_pending = commits.iter().try_fold(false, |pending, commit| {
         Ok::<_, anyhow::Error>(pending || rebase::is_pending(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
     })?;
@@ -126,6 +140,12 @@ pub(crate) fn prepare(
         sections.push(section);
         sections.extend(branches);
     }
+    let mut ref_points = scope.clone();
+    ref_points.push(onto);
+    ref_points.extend(sections.iter().map(|section| section.parent));
+    ref_points.sort_unstable();
+    ref_points.dedup();
+    let expected_refs = rebase::capture_refs(repo, &ref_points, &tips)?;
 
     let source = short(repo, base)?;
     let title = if base == onto {
@@ -144,6 +164,7 @@ pub(crate) fn prepare(
         scope: scope.clone(),
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
+        edit_refs: true,
         expected_refs,
         resolved: None,
         continuation_sources: Vec::new(),
@@ -170,9 +191,16 @@ pub(crate) fn prepare(
             section.parent,
             (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
         )?;
+        if !scope_set.contains(&section.parent) {
+            write_refs_at(&mut document, &state.expected_refs, section.parent, head_ref.as_ref())?;
+        }
         for id in &section.commits {
             let commit = by_id[id];
-            let verb = if Some(*id) == head { "@pick" } else { "pick" };
+            let verb = if marker_required && *id == head {
+                "@pick"
+            } else {
+                "pick"
+            };
             let states = commit_states(repo, *id)?;
             document.extend_from_slice(
                 format!(
@@ -182,10 +210,12 @@ pub(crate) fn prepare(
                 )
                 .as_bytes(),
             );
+            write_refs_at(&mut document, &state.expected_refs, *id, head_ref.as_ref())?;
         }
     }
     if sections.is_empty() {
         write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
+        write_refs_at(&mut document, &state.expected_refs, onto, head_ref.as_ref())?;
     }
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
@@ -211,6 +241,7 @@ pub(crate) fn prepare_continuation(
         scope: plan.scope.clone(),
         marker_required: plan.checkout.is_some(),
         checkout_allowed: repo.workdir().is_some(),
+        edit_refs: true,
         expected_refs: plan.expected_refs.clone(),
         resolved,
         continuation_sources: plan.steps.iter().flat_map(|step| step.squash.iter().copied()).collect(),
@@ -241,8 +272,19 @@ pub(crate) fn prepare_continuation(
                 parent,
                 (parent == plan.base).then_some(("base", base_title.as_str())),
             )?;
+            if matches!(step.parent, rebase::PlanParent::Existing(_)) {
+                write_plan_refs_at(&mut document, &plan.expected_refs, step.parent, plan.checkout.as_ref())?;
+            }
         }
-        let marker = if plan.checkout == Some(index) { "@" } else { "" };
+        let marker = if plan
+            .checkout
+            .as_ref()
+            .is_some_and(|checkout| checkout.target == rebase::PlanParent::Step(index))
+        {
+            "@"
+        } else {
+            ""
+        };
         match step.commit {
             rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => {
                 let value = if matches!(step.commit, rebase::PlanCommit::Resolved(_)) {
@@ -276,6 +318,12 @@ pub(crate) fn prepare_continuation(
                 .as_bytes(),
             );
         }
+        write_plan_refs_at(
+            &mut document,
+            &plan.expected_refs,
+            rebase::PlanParent::Step(index),
+            plan.checkout.as_ref(),
+        )?;
     }
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
@@ -301,14 +349,17 @@ fn write_state(out: &mut Vec<u8>, state: &State) {
         )
         .as_bytes(),
     );
+    out.extend_from_slice(format!("edit-refs {}\n", state.edit_refs).as_bytes());
     for reference in &state.expected_refs {
         let name = gix::quote::ansi_c::quote(reference.name.as_bstr());
+        let old = reference.old.map_or_else(|| "-".into(), |id| id.to_string());
         out.extend_from_slice(
             format!(
-                "ref {} {} {} {}\n",
-                reference.old,
+                "ref {} {} {} {} {}\n",
+                old,
                 reference.target,
                 reference.follows_tip,
+                reference.editable,
                 name.to_str_lossy()
             )
             .as_bytes(),
@@ -324,6 +375,78 @@ fn write_state(out: &mut Vec<u8>, state: &State) {
     out.push(b'\n');
 }
 
+fn write_refs_at(
+    out: &mut Vec<u8>,
+    refs: &[rebase::ExpectedRef],
+    target: ObjectId,
+    head_ref: Option<&gix::refs::FullName>,
+) -> Result<()> {
+    let names = refs
+        .iter()
+        .filter(|reference| reference.editable && reference.target == target)
+        .map(|reference| (&reference.name, head_ref == Some(&reference.name)))
+        .collect::<Vec<_>>();
+    write_ref_line(out, refs, names)
+}
+
+fn write_plan_refs_at(
+    out: &mut Vec<u8>,
+    refs: &[rebase::ExpectedRef],
+    target: rebase::PlanParent,
+    checkout: Option<&rebase::PlanCheckout>,
+) -> Result<()> {
+    let names = refs
+        .iter()
+        .filter(|reference| reference.placement == Some(target))
+        .map(|reference| {
+            let name = &reference.name;
+            (
+                name,
+                checkout.is_some_and(|checkout| checkout.target == target && checkout.reference.as_ref() == Some(name)),
+            )
+        })
+        .collect::<Vec<_>>();
+    write_ref_line(out, refs, names)
+}
+
+fn write_ref_line(
+    out: &mut Vec<u8>,
+    refs: &[rebase::ExpectedRef],
+    mut names: Vec<(&gix::refs::FullName, bool)>,
+) -> Result<()> {
+    if names.is_empty() {
+        return Ok(());
+    }
+    names.sort_by_key(|(name, _)| *name);
+    out.push(b'(');
+    for (index, (name, head)) in names.into_iter().enumerate() {
+        if index > 0 {
+            out.extend_from_slice(b", ");
+        }
+        if head {
+            out.push(b'@');
+        }
+        let display = ref_display_name(name, refs);
+        out.extend_from_slice(gix::quote::ansi_c::quote(display.as_bstr()).as_ref());
+    }
+    out.extend_from_slice(b")\n");
+    Ok(())
+}
+
+fn ref_display_name(name: &gix::refs::FullName, refs: &[rebase::ExpectedRef]) -> BString {
+    let short = name.shorten();
+    if refs
+        .iter()
+        .filter(|candidate| candidate.editable && candidate.name.shorten() == short)
+        .count()
+        > 1
+    {
+        name.as_bstr().to_owned()
+    } else {
+        short.to_owned()
+    }
+}
+
 fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
     let commit = repo
         .find_commit(id)
@@ -463,6 +586,7 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
     let mut scope = Vec::new();
     let mut marker_required = None;
     let mut checkout_allowed = None;
+    let mut edit_refs = false;
     let mut expected_refs = Vec::new();
     let mut resolved = None;
     let mut continuation_sources = Vec::new();
@@ -491,13 +615,18 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
                     anyhow::bail!("the rebase state repeats checkout-allowed");
                 }
             }
+            "edit-refs" => edit_refs = value.parse()?,
             "ref" => {
                 let (old, value) = value.split_once(' ').context("a captured ref has no target")?;
                 let (target, value) = value.split_once(' ').context("a captured ref has no follow mode")?;
-                let old = ObjectId::from_hex(old.as_bytes())?;
+                let old = (old != "-").then(|| ObjectId::from_hex(old.as_bytes())).transpose()?;
                 let target = ObjectId::from_hex(target.as_bytes())?;
-                let (follows_tip, name) = value.split_once(' ').context("a captured ref has no name")?;
+                let (follows_tip, value) = value.split_once(' ').context("a captured ref has no name")?;
                 let follows_tip = follows_tip.parse()?;
+                let (editable, name) = value
+                    .split_once(' ')
+                    .and_then(|(editable, name)| editable.parse::<bool>().ok().map(|editable| (editable, name)))
+                    .unwrap_or((false, value));
                 let encoded_name = name.as_bytes().as_bstr();
                 let (name, consumed) = gix::quote::ansi_c::undo(encoded_name)
                     .map_err(gix::Exn::into_error)
@@ -512,6 +641,8 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
                     target,
                     new: old,
                     follows_tip,
+                    editable,
+                    placement: None,
                 });
             }
             "resolved" => {
@@ -530,6 +661,7 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
         scope,
         marker_required: marker_required.context("the rebase state has no marker requirement")?,
         checkout_allowed: checkout_allowed.context("the rebase state has no checkout capability")?,
+        edit_refs,
         expected_refs,
         resolved,
         continuation_sources,
@@ -556,7 +688,7 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
         if !refs.insert(reference.name.as_bstr()) {
             anyhow::bail!("the rebase state contains duplicate refs");
         }
-        if !scope.contains(&reference.target) {
+        if !scope.contains(&reference.target) && reference.target != state.base && reference.target != state.onto {
             anyhow::bail!("a captured ref does not logically point into the rebase scope");
         }
     }
@@ -586,16 +718,19 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
 }
 
 pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Parsed>> {
+    repo.head()?.id().context("rebase todos require a born HEAD")?;
     let input = std::str::from_utf8(edited).context("the rebase todo is not UTF-8")?;
-    let Some(state) = parse_state(repo, input)? else {
+    let Some(mut state) = parse_state(repo, input)? else {
         return Ok(None);
     };
     let scope: HashSet<_> = state.scope.iter().copied().collect();
     let mut picked = HashMap::<ObjectId, usize>::new();
     let mut steps = Vec::<rebase::PlanStep>::new();
     let mut cursor = None;
-    let mut checkout = None;
-    let mut marker_count = 0;
+    let mut checkout_target = None;
+    let mut checkout_reference = None;
+    let mut command_marker = false;
+    let mut ref_targets = HashMap::new();
     let mut sections = 0;
     let mut section_has_commit = false;
     let mut section_last_step = None;
@@ -639,6 +774,32 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
             section_last_step = None;
             continue;
         }
+        if line.starts_with('(') && line.ends_with(')') {
+            let target = cursor.context("a reference line must follow a fork or command")?;
+            for (marked, value) in parse_ref_line(line)? {
+                let name = resolve_ref_name(repo, &mut state.expected_refs, value.as_bstr())?;
+                if ref_targets.insert(name.clone(), target).is_some() {
+                    anyhow::bail!("a reference is placed more than once");
+                }
+                if marked {
+                    if !state.checkout_allowed || repo.workdir().is_none() {
+                        anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
+                    }
+                    if name.category() != Some(gix::refs::Category::LocalBranch) {
+                        anyhow::bail!("only a local branch may carry the @ marker");
+                    }
+                    if checkout_reference.replace(name).is_some() {
+                        anyhow::bail!("the rebase todo contains more than one @ reference");
+                    }
+                    if checkout_target.is_some_and(|checkout| checkout != target) {
+                        anyhow::bail!("the @ command and @ reference point to different results");
+                    }
+                    checkout_target = Some(target);
+                }
+            }
+            section_has_commit = true;
+            continue;
+        }
 
         let (command, tail) = if let Some(line) = line.strip_prefix('`') {
             let (command, tail) = line
@@ -652,9 +813,8 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
         let marked = verb.starts_with('@');
         let verb = verb.strip_prefix('@').unwrap_or(verb);
         if marked {
-            marker_count += 1;
-            if marker_count > 1 {
-                anyhow::bail!("the rebase todo contains more than one @ marker");
+            if std::mem::replace(&mut command_marker, true) {
+                anyhow::bail!("the rebase todo contains more than one @ command");
             }
             if !state.checkout_allowed || repo.workdir().is_none() {
                 anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
@@ -674,7 +834,11 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
             }
             steps[index].squash.push(id);
             if marked {
-                checkout = Some(index);
+                let target = rebase::PlanParent::Step(index);
+                if checkout_target.is_some_and(|checkout| checkout != target) {
+                    anyhow::bail!("the @ command and @ reference point to different results");
+                }
+                checkout_target = Some(target);
             }
             section_has_commit = true;
             continue;
@@ -728,7 +892,11 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
         cursor = Some(rebase::PlanParent::Step(index));
         section_last_step = Some(index);
         if marked {
-            checkout = Some(index);
+            let target = rebase::PlanParent::Step(index);
+            if checkout_target.is_some_and(|checkout| checkout != target) {
+                anyhow::bail!("the @ command and @ reference point to different results");
+            }
+            checkout_target = Some(target);
         }
         section_has_commit = true;
     }
@@ -738,9 +906,21 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
     if sections > 1 && !section_has_commit {
         anyhow::bail!("the last fork section contains no commits");
     }
-    if state.marker_required && marker_count != 1 {
+    if state.marker_required && checkout_target.is_none() {
         anyhow::bail!("the current checkout marker must be retained");
     }
+    if state.edit_refs {
+        for reference in &mut state.expected_refs {
+            if reference.editable {
+                reference.new = None;
+                reference.placement = ref_targets.remove(&reference.name);
+            }
+        }
+    }
+    let checkout = checkout_target.map(|target| rebase::PlanCheckout {
+        target,
+        reference: checkout_reference,
+    });
     Ok(Some(Parsed {
         plan: rebase::Plan {
             base: state.onto,
@@ -767,6 +947,106 @@ fn resolve_commit(repo: &gix::Repository, value: &str) -> Result<ObjectId> {
     Ok(id.detach())
 }
 
+fn parse_ref_line(line: &str) -> Result<Vec<(bool, BString)>> {
+    let body = line
+        .strip_prefix('(')
+        .and_then(|line| line.strip_suffix(')'))
+        .context("a reference line must be enclosed in parentheses")?;
+    let mut ranges = Vec::new();
+    let mut start = 0;
+    let mut quoted = false;
+    let mut escaped = false;
+    for (index, byte) in body.bytes().enumerate() {
+        if escaped {
+            escaped = false;
+            continue;
+        }
+        match byte {
+            b'\\' if quoted => escaped = true,
+            b'"' => quoted = !quoted,
+            b',' if !quoted => {
+                ranges.push(&body[start..index]);
+                start = index + 1;
+            }
+            _ => {}
+        }
+    }
+    if quoted || escaped {
+        anyhow::bail!("a quoted reference name is not closed");
+    }
+    ranges.push(&body[start..]);
+    let mut out = Vec::with_capacity(ranges.len());
+    for item in ranges {
+        let item = item.trim();
+        if item.is_empty() {
+            anyhow::bail!("a reference line contains an empty name");
+        }
+        let (marked, item) = item.strip_prefix('@').map_or((false, item), |item| (true, item));
+        let encoded = item.as_bytes().as_bstr();
+        let (name, consumed) = gix::quote::ansi_c::undo(encoded)
+            .map_err(gix::Exn::into_error)
+            .context("could not unquote a reference name")?;
+        if !encoded[consumed..].trim().is_empty() {
+            anyhow::bail!("a reference name has trailing data");
+        }
+        if name.is_empty() {
+            anyhow::bail!("a reference name is empty");
+        }
+        out.push((marked, name.into_owned()));
+    }
+    Ok(out)
+}
+
+fn resolve_ref_name(
+    repo: &gix::Repository,
+    refs: &mut Vec<rebase::ExpectedRef>,
+    input: &gix::bstr::BStr,
+) -> Result<gix::refs::FullName> {
+    let mut matches = refs
+        .iter()
+        .filter(|reference| reference.editable && ref_display_name(&reference.name, refs).as_bstr() == input)
+        .map(|reference| reference.name.clone());
+    if let Some(name) = matches.next() {
+        if matches.next().is_some() {
+            anyhow::bail!("the shortened reference name is ambiguous");
+        }
+        return Ok(name);
+    }
+    let full = if input.starts_with(b"refs/") {
+        input.to_owned()
+    } else {
+        let mut full = BString::from("refs/heads/");
+        full.extend_from_slice(input);
+        full
+    };
+    let name = gix::refs::FullName::try_from(full).context("the todo contains an invalid reference name")?;
+    if name.as_bstr().starts_with(crate::history::PIN_PREFIX)
+        || name.as_bstr().starts_with(crate::history::REVIEW_PREFIX)
+        || matches!(
+            name.category(),
+            Some(gix::refs::Category::Tag | gix::refs::Category::RemoteBranch)
+        )
+    {
+        anyhow::bail!("the todo cannot edit this reference namespace");
+    }
+    if refs.iter().any(|reference| reference.name == name) {
+        anyhow::bail!("the todo cannot edit a hidden reference");
+    }
+    if repo.try_find_reference(name.as_ref())?.is_some() {
+        anyhow::bail!("an existing reference outside the editable history cannot be moved");
+    }
+    refs.push(rebase::ExpectedRef {
+        name: name.clone(),
+        old: None,
+        target: repo.head_id()?.detach(),
+        new: None,
+        follows_tip: false,
+        editable: true,
+        placement: None,
+    });
+    Ok(name)
+}
+
 #[cfg(test)]
 mod tests {
     use std::process::Command;
@@ -815,9 +1095,9 @@ mod tests {
         base: ObjectId,
         onto: ObjectId,
         commits: &[Commit],
-        head: Option<ObjectId>,
+        _head: Option<ObjectId>,
     ) -> Result<Prepared> {
-        prepare(repo, base, onto, commits, head, &[], OntoKind::UpdatedBase)
+        prepare(repo, base, onto, commits, &[], OntoKind::UpdatedBase)
     }
 
     fn parse_plan(repo: &gix::Repository, document: &[u8]) -> Result<rebase::Plan> {
@@ -863,6 +1143,12 @@ mod tests {
             document.contains("○"),
             "unsigned commits carry the documented status symbol"
         );
+        let plan = parse_plan(&repo, &prepared.document)?;
+        assert_eq!(
+            plan.checkout.as_ref().and_then(|checkout| checkout.reference.as_ref()),
+            Some(&"refs/heads/main".try_into()?),
+            "the generated @ command and @ branch agree"
+        );
         Ok(())
     }
 
@@ -880,12 +1166,15 @@ mod tests {
             scope: vec![middle],
             marker_required: false,
             checkout_allowed: true,
+            edit_refs: true,
             expected_refs: vec![rebase::ExpectedRef {
                 name: name.clone(),
-                old: middle,
+                old: Some(middle),
                 target: middle,
-                new: middle,
+                new: Some(middle),
                 follows_tip: true,
+                editable: true,
+                placement: None,
             }],
             resolved: None,
             continuation_sources: Vec::new(),
@@ -1078,7 +1367,10 @@ mod tests {
         let edited = with_state(&prepared, &edited);
         let plan = parse_plan(&repo, &edited)?;
         assert_eq!(plan.steps.len(), 3);
-        assert_eq!(plan.checkout, Some(2));
+        assert_eq!(
+            plan.checkout.as_ref().map(|checkout| checkout.target),
+            Some(rebase::PlanParent::Step(2))
+        );
         assert_eq!(plan.steps[2].parent, rebase::PlanParent::Step(0));
         assert!(matches!(&plan.steps[1].commit, rebase::PlanCommit::Empty(title) if title == b"a new checkpoint"));
         Ok(())
@@ -1102,7 +1394,11 @@ mod tests {
         let plan = parse_plan(&repo, &edited)?;
         assert_eq!(plan.steps.len(), 2, "squash does not produce another commit");
         assert_eq!(plan.steps[0].squash, [tip]);
-        assert_eq!(plan.checkout, Some(0), "the squash marker selects the folded result");
+        assert_eq!(
+            plan.checkout.as_ref().map(|checkout| checkout.target),
+            Some(rebase::PlanParent::Step(0)),
+            "the squash marker selects the folded result"
+        );
         assert_eq!(
             plan.steps[1].parent,
             rebase::PlanParent::Step(0),
@@ -1127,6 +1423,7 @@ mod tests {
     fn continuation_todos_round_trip_the_resolved_index_and_remaining_squashes() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, _) = commits(&repo)?;
+        let branch: gix::refs::FullName = "refs/heads/continued".try_into()?;
         let prepared = prepare_continuation(
             &repo,
             &rebase::Plan {
@@ -1137,8 +1434,19 @@ mod tests {
                     commit: rebase::PlanCommit::Resolved(middle),
                     squash: vec![tip],
                 }],
-                checkout: Some(0),
-                expected_refs: Vec::new(),
+                checkout: Some(rebase::PlanCheckout {
+                    target: rebase::PlanParent::Step(0),
+                    reference: Some(branch.clone()),
+                }),
+                expected_refs: vec![rebase::ExpectedRef {
+                    name: branch.clone(),
+                    old: None,
+                    target: middle,
+                    new: Some(middle),
+                    follows_tip: false,
+                    editable: true,
+                    placement: Some(rebase::PlanParent::Step(0)),
+                }],
             },
             vec![middle],
         )?;
@@ -1151,11 +1459,22 @@ mod tests {
         let plan = parse_plan(&repo, &prepared.document)?;
         assert!(matches!(plan.steps[0].commit, rebase::PlanCommit::Resolved(id) if id == middle));
         assert_eq!(plan.steps[0].squash, [tip]);
+        assert_eq!(
+            plan.checkout.as_ref().and_then(|checkout| checkout.reference.as_ref()),
+            Some(&branch),
+            "the continuation retains its attached checkout"
+        );
+        assert!(
+            plan.expected_refs.iter().any(|reference| reference.name == branch
+                && reference.old.is_none()
+                && reference.placement == Some(rebase::PlanParent::Step(0))),
+            "a pending branch creation retains its nonexistence check and placement"
+        );
         Ok(())
     }
 
     #[test]
-    fn unchanged_marker_cannot_be_removed_but_an_empty_plan_is_valid_without_one() -> gix_testtools::Result {
+    fn unchanged_checkout_marker_cannot_be_removed() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
@@ -1164,13 +1483,125 @@ mod tests {
         let err = parse(&repo, &edited).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
 
-        let prepared = prepare_test(&repo, base, base, &commits, None)?;
-        let edited = with_state(&prepared, &format!("## fork {}\n", base.to_hex_with_len(7)));
+        Ok(())
+    }
+
+    #[test]
+    fn reference_lines_move_create_delete_and_detach_head() -> gix_testtools::Result {
+        let (fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let generated = String::from_utf8(prepared.document.clone())?;
+        assert!(
+            generated.contains("(@main, refs/patches/tip)"),
+            "the generated todo shows the attached branch as well as the HEAD command:\n{generated}"
+        );
+
+        let edited = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\npick {}\n(new-1)\n@pick {}\n(main)\n",
+                base.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+            ),
+        );
         let plan = parse_plan(&repo, &edited)?;
         assert!(
-            plan.steps.is_empty(),
-            "all picks may be dropped when no marker is required"
+            plan.checkout
+                .as_ref()
+                .is_some_and(|checkout| checkout.reference.is_none()),
+            "removing @ from main requests a detached checkout"
+        );
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+        let selected = outcome.selected.context("the edited todo retains a checkout")?;
+        super::super::time_travel::checkout_plan(
+            repo.git_dir(),
+            false,
+            selected,
+            outcome.checkout_reference.as_ref(),
+            &outcome.deferred_ref_deletions,
+            &[],
+            false,
+        )?;
+
+        assert!(repo.head()?.referent_name().is_none(), "HEAD is detached");
+        assert_eq!(
+            repo.find_reference("refs/heads/new-1")?.id().detach(),
+            outcome.map(middle).context("the middle commit is retained")?,
+            "the new branch points at its preceding command"
+        );
+        assert!(
+            repo.try_find_reference("refs/patches/middle")?.is_none()
+                && repo.try_find_reference("refs/patches/tip")?.is_none(),
+            "omitted generated refs are deleted"
+        );
+        assert_eq!(
+            std::fs::read_to_string(fixture.path().join("tip"))?,
+            "tip\n",
+            "the detached checkout keeps the selected tree"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn deleting_the_current_branch_is_deferred_until_head_detaches() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, _middle, tip, commits) = commits(&repo)?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let edited = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\n@pick {}\n",
+                base.to_hex_with_len(7),
+                tip.to_hex_with_len(7)
+            ),
+        );
+        let plan = parse_plan(&repo, &edited)?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+        assert!(
+            repo.try_find_reference("refs/heads/main")?.is_some(),
+            "the checked-out branch remains until checkout succeeds"
+        );
+        super::super::time_travel::checkout_plan(
+            repo.git_dir(),
+            false,
+            outcome.selected.context("the todo selects HEAD")?,
+            outcome.checkout_reference.as_ref(),
+            &outcome.deferred_ref_deletions,
+            &[],
+            false,
+        )?;
+        assert!(repo.head()?.referent_name().is_none(), "HEAD is detached");
+        assert!(
+            repo.try_find_reference("refs/heads/main")?.is_none(),
+            "the departed current branch is deleted"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn todos_reject_an_unborn_head() -> gix_testtools::Result {
+        let (fixture, repo) = repo()?;
+        let (base, _middle, _tip, commits) = commits(&repo)?;
+        let prepared = prepare_test(&repo, base, base, &commits, None)?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["symbolic-ref", "HEAD", "refs/heads/unborn"])
+                .status()?
+                .success(),
+            "HEAD becomes unborn while the todo is open"
+        );
+        assert!(
+            prepare_test(&repo, base, base, &commits, None).is_err(),
+            "generation rejects an unborn HEAD"
         );
+        let err = parse(&repo, &prepared.document).expect_err("application rejects an unborn HEAD");
+        assert!(format!("{err:#}").contains("born HEAD"));
         Ok(())
     }
 }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 194146fd8d9..8a19edf5158 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2095,12 +2095,7 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("forget: {err:#}")),
                     }
                 }
-                Effect::Rebase {
-                    base,
-                    onto,
-                    commits,
-                    head,
-                } => {
+                Effect::Rebase { base, onto, commits } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let todo_commits = commits
@@ -2130,19 +2125,20 @@ fn event_loop(
                                 base,
                                 onto,
                                 todo_commits?,
-                                head,
                                 enhanced_keyboard,
                             )
                         });
                     match result {
                         Ok(Some(edit::rebase::PlanPerform::Complete(outcome))) => {
-                            let checkout = outcome.selected;
-                            let notice = checkout
+                            let notice = outcome
+                                .selected
                                 .map(|selected| {
-                                    edit::time_travel::checkout_without_replay(
+                                    edit::time_travel::checkout_plan(
                                         &repository_path,
                                         repository_is_bare,
                                         selected,
+                                        outcome.checkout_reference.as_ref(),
+                                        &outcome.deferred_ref_deletions,
                                         &revisions,
                                         worktrees,
                                     )
@@ -3275,7 +3271,6 @@ fn rebase_history(
     base: gix::ObjectId,
     onto: gix::ObjectId,
     commits: Vec<edit::todo::Commit>,
-    head: Option<gix::ObjectId>,
     enhanced_keyboard: bool,
 ) -> Result<Option<edit::rebase::PlanPerform>> {
     let (prepared, editor) = {
@@ -3288,7 +3283,6 @@ fn rebase_history(
             base,
             onto,
             &commits,
-            head,
             &[],
             edit::todo::OntoKind::UpdatedBase,
         )?;
@@ -5742,7 +5736,10 @@ mod tests {
                     commit: edit::rebase::PlanCommit::Pick(tip),
                     squash: Vec::new(),
                 }],
-                checkout: Some(0),
+                checkout: Some(edit::rebase::PlanCheckout {
+                    target: edit::rebase::PlanParent::Step(0),
+                    reference: None,
+                }),
                 expected_refs: edit::rebase::capture_refs(&repo, &[middle, tip], &[tip])?,
             },
         )?

From ea35a13ffddb63a37eb219c44192fa13b8f65c20 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 11:31:25 +0200
Subject: [PATCH 107/282] fix: keep in-memory rebase conflicts drawable

Hide repository-backed changes and defer notes or message loading while a suspended conflict exists only in the rebase operation's object memory. Restore overlays as soon as the user accepts or cancels the preview.
---
 gix-tix/spec.md    | 8 +++++---
 gix-tix/src/app.rs | 8 +++++++-
 gix-tix/src/lib.rs | 9 +++++++--
 3 files changed, 19 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 26d523ca52f..0e5aa4e028d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -613,9 +613,11 @@ space first; changes blocks adapt within the remaining history width.
   Any conflict while applying a history todo first remains entirely in memory.
   The TUI projects the partial result, selects the actual conflicting result, and
   marks it with a blinking red `C`; predicted ref decorations remain at their
-  repository positions. `<enter>` accepts the partial result, moves already-final
-  refs, checks out the conflicting tree with an unmerged index, and retains an
-  in-memory continuation plan. Any other key discards the preview without writes.
+  repository positions. Repository-backed overlay content is hidden while these
+  candidate objects exist only in memory. `<enter>` accepts the partial result,
+  moves already-final refs, checks out the conflicting tree with an unmerged index,
+  and retains an in-memory continuation plan. Any other key discards the preview
+  without writes.
   Once the index has no unresolved stages, `<enter>` continues; another conflict
   repeats the same choice.
 - Command-line apply reports a conflict without changes unless
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 93c90f1e527..4f899632d7e 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1449,7 +1449,7 @@ impl App {
     }
 
     pub(crate) fn changes_visible(&self) -> bool {
-        self.changes_mode.is_some() && !self.changes_suppressed
+        self.changes_mode.is_some() && !self.changes_suppressed && self.pending_rebase_conflict.is_none()
     }
 
     fn ensure_changes_visible(&mut self) {
@@ -2658,10 +2658,16 @@ mod tests {
         assert!(!app.time_travel_shortcut_visible());
         assert!(app.update(Action::TimeTravel).is_empty());
         app.set_worktree_conflicted(false);
+        assert!(app.changes_visible(), "changes are normally shown while enabled");
         app.arm_rebase_conflict(id(1));
         assert!(!app.time_travel_shortcut_visible());
+        assert!(
+            !app.changes_visible(),
+            "an in-memory conflict preview cannot be loaded by an on-disk changes view"
+        );
         app.clear_rebase_conflict();
         assert!(app.time_travel_shortcut_visible());
+        assert!(app.changes_visible(), "clearing the preview restores the changes view");
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8a19edf5158..2a409a52ae1 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2595,10 +2595,11 @@ fn draw(
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let end = start.saturating_add(render_rows).min(app.rows.len());
+    let repository_fill_allowed = !app.has_rebase_conflict();
     let notes_to_load: Vec<_> = app.rows[start..end]
         .iter()
         .map(|row| row.id)
-        .filter(|id| !app.notes_loaded(*id))
+        .filter(|id| repository_fill_allowed && !app.notes_loaded(*id))
         .collect();
     let changes_visible = app.changes_visible();
     let selected_id = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
@@ -2617,6 +2618,7 @@ fn draw(
         .show_commit
         .then_some(selected)
         .flatten()
+        .filter(|_| repository_fill_allowed)
         .filter(|id| commit_message.as_ref().map(|(cached, _)| cached) != Some(id));
     if message_to_load.is_some() {
         app.reset_commit_view();
@@ -2652,7 +2654,10 @@ fn draw(
             )
         })
         .flatten();
-    if !app.show_commit || selected.is_none() {
+    if !app.show_commit
+        || selected.is_none()
+        || (!repository_fill_allowed && commit_message.as_ref().map(|(id, _)| *id) != selected)
+    {
         *commit_message = None;
     }
     if app.changes_mode.is_none() {

From c8b5f3b3d3b89d0f7c977c0af34093c217dd55bf Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 11:32:41 +0200
Subject: [PATCH 108/282] fix: emphasize tix review commits

Replace the undersized star marker with a filled diamond whose visual weight matches ordinary commit discs while remaining distinct and one cell wide.
---
 gix-tix/spec.md   | 2 +-
 gix-tix/src/ui.rs | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 0e5aa4e028d..eea3f83e8d7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -477,7 +477,7 @@ space first; changes blocks adapt within the remaining history width.
   as unstaged changes.
 - Review refs are always traversal tips and remain visible in every ref mode. One
   active ref is shown as `review`; multiple refs are shown as `review:N`. Review
-  commits replace the signature disc with a star while retaining independent
+  commits replace the signature disc with a filled diamond while retaining independent
   signature state. Ordinary edits preserve the review header and otherwise keep
   their normal signing and lazy-rebase behavior.
 - At a checked-out review commit, amend is offered only for staged changes and
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 57b3de81c60..722f1c473f8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1904,7 +1904,7 @@ fn color_graph(
         }
         let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
         if review && symbol == '●' {
-            cell.set_symbol("★");
+            cell.set_symbol("◆");
         } else if head.is_some() && symbol == '●' {
             cell.set_symbol("@");
         }
@@ -3168,7 +3168,7 @@ mod tests {
     }
 
     #[test]
-    fn review_commit_uses_a_star_instead_of_the_signature_disc() -> Result<(), Box<dyn std::error::Error>> {
+    fn review_commit_uses_a_diamond_instead_of_the_signature_disc() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(2, 1))?;
         terminal.draw(|frame| {
             frame.render_widget(Paragraph::new("●─"), Rect::new(0, 0, 2, 1));
@@ -3182,7 +3182,7 @@ mod tests {
                 Some(true),
             );
         })?;
-        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "★");
+        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "◆");
         assert_eq!(terminal.backend().buffer()[(1, 0)].symbol(), "─");
         Ok(())
     }

From 7c5fa41f53a57015f3c23f4aee55323680efe045 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 11:37:33 +0200
Subject: [PATCH 109/282] feat: restore the reviewed branch after finishing

Store the branch checked out at review start as the symbolic target of the review ref when it points to the reviewed commit. The ref naturally follows rewrites, and finishing reattaches HEAD after verifying that it reached the finished review commit.

Keep direct review refs for detached HEAD or reviews started away from the checked-out branch, and delete symbolic review resources without dereferencing them during setup rollback.
---
 gix-tix/spec.md            |  5 +++-
 gix-tix/src/edit/review.rs | 60 +++++++++++++++++++++++++++++---------
 2 files changed, 50 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index eea3f83e8d7..1896caecb6e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -474,7 +474,10 @@ space first; changes blocks adapt within the remaining history width.
   tip and an unsigned ordinary `review` commit at the base with
   `tix-rebase: onto refs/worktree/tix/review/N`. HEAD is detached at that commit,
   its base tree fills the index, and the reviewed tip tree remains in the worktree
-  as unstaged changes.
+  as unstaged changes. If attached HEAD pointed directly to the reviewed tip when
+  starting, the review ref symbolically targets that ref instead. Finishing then
+  reattaches HEAD after confirming the ref moved to the finished review commit;
+  otherwise the review ref remains a direct anchor and HEAD stays detached.
 - Review refs are always traversal tips and remain visible in every ref mode. One
   active ref is shown as `review`; multiple refs are shown as `review:N`. Review
   commits replace the signature disc with a filled diamond while retaining independent
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index d681a135489..60d4a8149f2 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -91,6 +91,7 @@ pub(crate) fn start(
         head.referent_name().map(|name| name.as_bstr().to_owned()),
         head.id().map(gix::Id::detach),
     );
+    let reattach = (restore.1 == Some(tip)).then(|| restore.0.clone()).flatten();
     if tip == base || !graph.is_ancestor(base, tip) {
         anyhow::bail!("the review base must be an ancestor of the reviewed commit");
     }
@@ -135,10 +136,15 @@ pub(crate) fn start(
 
     git(&workdir, ["checkout", "--quiet", "--detach", &tip.to_string()])
         .context("could not check out the reviewed commit")?;
-    if let Err(err) = git(
-        &workdir,
-        ["update-ref", name.as_bstr().to_str_lossy().as_ref(), &tip.to_string()],
-    ) {
+    let review_name = name.as_bstr().to_str_lossy();
+    let create_ref = match reattach.as_ref() {
+        Some(target) => git(
+            &workdir,
+            ["symbolic-ref", review_name.as_ref(), target.to_str_lossy().as_ref()],
+        ),
+        None => git(&workdir, ["update-ref", review_name.as_ref(), &tip.to_string()]),
+    };
+    if let Err(err) = create_ref {
         restore_checkout(&workdir, &restore)?;
         return Err(err.context("could not create review reference"));
     }
@@ -146,7 +152,7 @@ pub(crate) fn start(
         &workdir,
         ["update-ref", "--no-deref", "HEAD", &id.to_string(), &tip.to_string()],
     ) {
-        let _ = git(&workdir, ["update-ref", "-d", name.as_bstr().to_str_lossy().as_ref()]);
+        let _ = git(&workdir, ["update-ref", "--no-deref", "-d", review_name.as_ref()]);
         restore_checkout(&workdir, &restore)?;
         return Err(err.context("could not attach the worktree to the review commit"));
     }
@@ -155,7 +161,7 @@ pub(crate) fn start(
             &workdir,
             ["update-ref", "--no-deref", "HEAD", &tip.to_string(), &id.to_string()],
         );
-        let _ = git(&workdir, ["update-ref", "-d", name.as_bstr().to_str_lossy().as_ref()]);
+        let _ = git(&workdir, ["update-ref", "--no-deref", "-d", review_name.as_ref()]);
         restore_checkout(&workdir, &restore)?;
         return Err(err.context("could not reset the index to the review base"));
     }
@@ -167,11 +173,14 @@ pub(crate) fn start(
 
 #[tracing::instrument(skip_all, fields(%review))]
 pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, review: ObjectId) -> Result<ObjectId> {
-    let workdir = repo.workdir().context("finishing review requires a worktree")?;
+    let workdir = repo
+        .workdir()
+        .context("finishing review requires a worktree")?
+        .to_owned();
     if repo.head_id()?.detach() != review {
         anyhow::bail!("the review commit must be checked out before it can be finished");
     }
-    ensure_clean(workdir)?;
+    ensure_clean(&workdir)?;
     let commit = repo.find_commit(review)?.decode()?.into_owned()?;
     let review_ref = reference(&commit)?.context("the selected commit is not an active review")?;
     let base = commit
@@ -182,6 +191,7 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
     let mut reference = repo
         .find_reference(review_ref.as_ref())
         .context("the review reference is missing")?;
+    let reattach = reference.target().try_name().map(ToOwned::to_owned);
     let tip = reference
         .peel_to_id()
         .context("the review reference does not resolve")?
@@ -193,9 +203,23 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
             anyhow::bail!("{label} has a pending rebase");
         }
     }
-    super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs)?
+    let finished = super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs)?
         .selected
-        .context("finishing review did not produce a commit")
+        .context("finishing review did not produce a commit")?;
+    if let Some(reattach) = reattach {
+        let mut reference = repo
+            .find_reference(reattach.as_ref())
+            .context("the branch to restore after review is missing")?;
+        if reference.peel_to_id()?.detach() != finished {
+            anyhow::bail!("the branch to restore after review no longer points to the finished commit");
+        }
+        git(
+            &workdir,
+            ["symbolic-ref", "HEAD", reattach.as_bstr().to_str_lossy().as_ref()],
+        )
+        .context("could not reattach HEAD after review")?;
+    }
+    Ok(finished)
 }
 
 pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
@@ -301,6 +325,8 @@ mod tests {
             fixture.path(),
             &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "natural descendant"],
         )?;
+        run(fixture.path(), &["branch", "natural"])?;
+        run(fixture.path(), &["reset", "--hard", &tip.to_string()])?;
 
         let repo = gix::open_opts(
             fixture.path(),
@@ -323,10 +349,11 @@ mod tests {
             repo.find_commit(started.commit)?.tree_id()?,
             repo.find_commit(base)?.tree_id()?
         );
+        let review_ref = repo.find_reference(started.reference.as_ref())?;
         assert_eq!(
-            repo.find_reference(started.reference.as_ref())?.id().detach(),
-            tip,
-            "the review resource retains the reviewed tip"
+            review_ref.target().try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "the review resource remembers the branch to restore"
         );
         let commit = repo.find_commit(started.commit)?.decode()?.into_owned()?;
         assert_eq!(reference(&commit)?, Some(started.reference.clone()));
@@ -404,6 +431,11 @@ mod tests {
         let finished = finish(repo, &graph, amended)?;
         let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
         assert_eq!(repo.head_id()?.detach(), finished);
+        assert_eq!(
+            repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "finishing reattaches HEAD to the branch saved by the review resource"
+        );
         assert_eq!(
             repo.find_commit(finished)?.parent_ids().next().map(gix::Id::detach),
             Some(tip)
@@ -414,7 +446,7 @@ mod tests {
             repo.find_commit(child)?.parent_ids().next().map(gix::Id::detach),
             Some(finished)
         );
-        let natural = repo.find_reference("refs/heads/main")?.id().detach();
+        let natural = repo.find_reference("refs/heads/natural")?.id().detach();
         assert_eq!(
             repo.find_commit(natural)?.parent_ids().next().map(gix::Id::detach),
             Some(child),

From c354c220452e46cc5530e17a31ce361651f09ac4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 13:52:26 +0200
Subject: [PATCH 110/282] fix: keep conflict-marker trees out of rebased
 commits

Record the cherry-pick ours tree in suspended conflict commits while retaining the synthetic merge-result tree solely for materializing conflict markers and unmerged index stages. Reuse the existing two-tree worktree transition and roll it back if the final index write fails.
---
 gix-tix/spec.md                               | 18 +++--
 gix-tix/src/command/rebase.rs                 | 13 +++
 gix-tix/src/edit/rebase.rs                    | 80 +++++++++++++------
 ...sts__accepted-pending-rebase-conflict.snap | 13 ++-
 gix-tix/src/edit/time_travel.rs               | 16 +++-
 5 files changed, 100 insertions(+), 40 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1896caecb6e..6ad08cd37f8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -450,11 +450,12 @@ space first; changes blocks adapt within the remaining history width.
   ancestry through that destination. Every later descendant is reparented and
   becomes or remains lazy and unsigned, including ordinary commits created above
   pending history; traveling toward a non-pending ancestor leaves the entire
-  pending region untouched. A conflict
-  retains the exact merge tree, conflict stages, prepared commits, and in-memory
-  objects without changing the repository. The conflicting row shows a blinking
-  red `C`; `<enter>` persists the prepared rebase, leaves later descendants lazy,
-  and checks out the conflict tree with an unmerged index. Any other key discards
+  pending region untouched. A conflict retains the ours tree, exact merge-result
+  tree, conflict stages, prepared commits, and in-memory objects without changing
+  the repository. The conflicting row shows a blinking red `C`; `<enter>` persists
+  the prepared rebase, leaves later descendants lazy, checks out the conflicting
+  commit at the ours tree, then checks out the merge result and derives the
+  unmerged index from it. Any other key discards
   the suspended operation; key-release events are not actions and leave it armed.
   Diagnostics warn when a conflict suspends the rebase and record whether it is
   accepted, discarded, or fails during checkout.
@@ -546,8 +547,8 @@ space first; changes blocks adapt within the remaining history width.
   unreachable objects may remain for normal Git garbage collection.
 - A suspended conflict temporarily owns a cloned repository with object memory
   while awaiting one confirmation key. Dropping it writes nothing; accepting it
-  consumes the repository immediately after persisting and checking out the
-  retained merge result.
+  consumes the repository immediately after persisting the commit at the ours
+  tree and materializing the retained merge result in the worktree and index.
 
 ### History rebase editor
 
@@ -618,7 +619,8 @@ space first; changes blocks adapt within the remaining history width.
   marks it with a blinking red `C`; predicted ref decorations remain at their
   repository positions. Repository-backed overlay content is hidden while these
   candidate objects exist only in memory. `<enter>` accepts the partial result,
-  moves already-final refs, checks out the conflicting tree with an unmerged index,
+  moves already-final refs, records the ours tree in the conflicting commit, and
+  checks out the retained merge result with an unmerged index,
   and retains an in-memory continuation plan. Any other key discards the preview
   without writes.
   Once the index has no unresolved stages, `<enter>` continues; another conflict
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index d2a8b35e55b..f7bcd247205 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -443,6 +443,19 @@ mod tests {
             unresolved.stdout, b"file\n",
             "materialization writes the unmerged index"
         );
+        let materialized = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let conflict_commit = materialized.head_commit()?;
+        assert_eq!(
+            conflict_commit.tree_id()?.detach(),
+            conflict_commit
+                .parent_ids()
+                .next()
+                .expect("a cherry-picked commit has a parent")
+                .object()?
+                .peel_to_tree()?
+                .id,
+            "the materialized conflict commit records the ours tree"
+        );
 
         std::fs::write(fixture.path().join("file"), b"resolved\n")?;
         assert!(
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 3c902ede858..5275efcf490 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -285,7 +285,7 @@ impl Perform {
 pub(crate) struct Conflict {
     prepared: Prepared,
     conflicts: Vec<gix::merge::tree::Conflict>,
-    tree: ObjectId,
+    merged_tree: ObjectId,
     commit: ObjectId,
     original: ObjectId,
 }
@@ -300,7 +300,7 @@ impl Conflict {
         Ok(PersistedConflict {
             repo: self.prepared.repo,
             conflicts: self.conflicts,
-            tree: self.tree,
+            merged_tree: self.merged_tree,
             commit: self.commit,
             deferred_ref_deletions: outcome.deferred_ref_deletions,
         })
@@ -310,16 +310,16 @@ impl Conflict {
 pub(crate) struct PersistedConflict {
     repo: gix::Repository,
     conflicts: Vec<gix::merge::tree::Conflict>,
-    tree: ObjectId,
+    merged_tree: ObjectId,
     pub(crate) commit: ObjectId,
     pub(crate) deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
 }
 
 impl PersistedConflict {
-    pub(crate) fn write_index(&mut self) -> Result<()> {
+    pub(crate) fn materialize(&mut self) -> Result<()> {
         let mut index = self
             .repo
-            .index_from_tree(&self.tree)
+            .index_from_tree(&self.merged_tree)
             .context("could not prepare the conflicting index")?;
         if !gix::merge::tree::apply_index_entries(
             &self.conflicts,
@@ -330,9 +330,29 @@ impl PersistedConflict {
             anyhow::bail!("could not apply conflict stages to the prepared index");
         }
         index.remove_tree();
-        index
+        let ours_tree = self
+            .repo
+            .find_commit(self.commit)
+            .context("could not find the conflicting commit")?
+            .tree_id()
+            .context("could not read the conflicting commit tree")?
+            .detach();
+        let workdir = self
+            .repo
+            .workdir()
+            .context("materializing a conflict requires a worktree")?;
+        super::forget::apply_tree_transition(workdir, ours_tree, self.merged_tree)
+            .context("could not check out the conflicting merge result")?;
+        if let Err(err) = index
             .write(gix::index::write::Options::default())
             .context("could not write the conflicting index")
+        {
+            return match super::forget::apply_tree_transition(workdir, self.merged_tree, ours_tree) {
+                Ok(()) => Err(err),
+                Err(rollback) => Err(err.context(format!("conflict checkout rollback failed: {rollback:#}"))),
+            };
+        }
+        Ok(())
     }
 }
 
@@ -560,9 +580,13 @@ fn perform_inner(
         let mut new_conflict = None;
         commit.tree = match rewritten_tree {
             TreeRewrite::Complete(tree) => tree,
-            TreeRewrite::Conflict { tree, conflicts } => {
-                new_conflict = Some((tree, conflicts));
-                tree
+            TreeRewrite::Conflict {
+                ours,
+                merged,
+                conflicts,
+            } => {
+                new_conflict = Some((merged, conflicts));
+                ours
             }
         };
         commit.parents = new_parents.into_iter().collect();
@@ -632,10 +656,10 @@ fn perform_inner(
         delete_refs,
     };
     match conflict {
-        Some((original, tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
+        Some((original, merged_tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
             prepared,
             conflicts,
-            tree,
+            merged_tree,
             commit,
             original,
         })),
@@ -912,12 +936,16 @@ pub(crate) fn perform_plan_with_progress(
         let mut step_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
-            TreeRewrite::Conflict { tree, conflicts } => {
+            TreeRewrite::Conflict {
+                ours,
+                merged,
+                conflicts,
+            } => {
                 let (PlanCommit::Pick(original) | PlanCommit::Resolved(original)) = step.commit else {
                     unreachable!("empty commits cannot conflict")
                 };
-                step_conflict = Some((original, tree, conflicts, None));
-                tree
+                step_conflict = Some((original, merged, conflicts, None));
+                ours
             }
         };
         if let Some(started) = cherry_pick_started.filter(|_| step_conflict.is_none()) {
@@ -952,9 +980,13 @@ pub(crate) fn perform_plan_with_progress(
                 let started = Instant::now();
                 commit.tree = match cherry_pick_tree_outcome(&repo, old_base, commit.tree, source.tree)? {
                     TreeRewrite::Complete(tree) => tree,
-                    TreeRewrite::Conflict { tree, conflicts } => {
-                        step_conflict = Some((*id, tree, conflicts, Some(squash_index)));
-                        tree
+                    TreeRewrite::Conflict {
+                        ours,
+                        merged,
+                        conflicts,
+                    } => {
+                        step_conflict = Some((*id, merged, conflicts, Some(squash_index)));
+                        ours
                     }
                 };
                 applied += 1;
@@ -1118,7 +1150,7 @@ pub(crate) fn perform_plan_with_progress(
         signing_ms = progress.signing_time.as_millis(),
         "prepared rebase plan"
     );
-    let Some((original, tree, conflicts, commit, conflict_step, conflict_remaining_squash)) = conflict else {
+    let Some((original, merged_tree, conflicts, commit, conflict_step, conflict_remaining_squash)) = conflict else {
         return Ok(PlanPerform::Complete(prepared.finish()?));
     };
 
@@ -1158,7 +1190,7 @@ pub(crate) fn perform_plan_with_progress(
         conflict: Conflict {
             prepared,
             conflicts,
-            tree,
+            merged_tree,
             commit,
             original,
         },
@@ -1426,7 +1458,8 @@ fn validate(
 enum TreeRewrite {
     Complete(ObjectId),
     Conflict {
-        tree: ObjectId,
+        ours: ObjectId,
+        merged: ObjectId,
         conflicts: Vec<gix::merge::tree::Conflict>,
     },
 }
@@ -1567,18 +1600,19 @@ fn cherry_pick_tree_outcome(
         .merge_trees(old_base, new_base, tree, labels, repo.tree_merge_options()?)
         .context("could not cherry-pick a descendant tree")?;
     let unresolved = outcome.has_unresolved_conflicts(gix::merge::tree::TreatAsUnresolved::git());
-    let tree = outcome
+    let merged = outcome
         .tree
         .write()
         .context("could not prepare a rebased tree")?
         .detach();
     if unresolved {
         Ok(TreeRewrite::Conflict {
-            tree,
+            ours: new_base,
+            merged,
             conflicts: outcome.conflicts,
         })
     } else {
-        Ok(TreeRewrite::Complete(tree))
+        Ok(TreeRewrite::Complete(merged))
     }
 }
 
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index ffed3abf164..c0e0370cc09 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -10,7 +10,7 @@ refs/worktree/tix/pins/9dabf957 = -> refs/heads/main
 
 [commits]
 C0
-  tree T1
+  tree T0
   author author <author@example.com> 946684800 +0000
   committer committer <committer@example.com> 946684800 +0000
 
@@ -26,7 +26,7 @@ C1
   tip
 
 C2
-  tree T2
+  tree T1
   parent C1
   author author <author@example.com> 946944000 +0000
   committer author <author@example.com> 978307200 +0000
@@ -44,12 +44,11 @@ tree = conflicted
 100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
 
 [objects]
-T0 = 0f42ecffc297189265600788215c8b0055d862b8
-T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
-T2 = 6f2762b571ef9a93001cc607058818aa5d0d055c
+T0 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+T1 = 6f2762b571ef9a93001cc607058818aa5d0d055c
+C2 = 7dda806fe5de746fe7e14316c0775eb7df6003dc
+C1 = a2ce4f2d51adba4c0e29abc2000475aee3a4e8ae
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
-C1 = ba56ce9b9d8d6244d2515a069c41954891242837
 C0 = c0b811a58f27425263a4276fe881de38736a9446
-C2 = caa38dc6da6e13db4a27c3d73fa15562f2890764
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
 B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 0d7dbe88048..f2c6f55ef5e 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -57,7 +57,7 @@ impl Conflict {
         )?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
-        conflict.write_index()?;
+        conflict.materialize()?;
         Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
     }
 }
@@ -75,7 +75,7 @@ pub(crate) fn materialize_plan_conflict(
     let notice = move_head(repository_path, bare, conflict.commit, revisions, include_worktrees)?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
     delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
-    conflict.write_index()?;
+    conflict.materialize()?;
     tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
     Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
 }
@@ -1176,6 +1176,18 @@ mod tests {
             conflict_id,
             "the conflicting commit is checked out"
         );
+        let conflict_commit = repository.find_commit(conflict_id)?;
+        assert_eq!(
+            conflict_commit.tree_id()?.detach(),
+            conflict_commit
+                .parent_ids()
+                .next()
+                .expect("a cherry-picked commit has a parent")
+                .object()?
+                .peel_to_tree()?
+                .id,
+            "the conflicting commit records the ours tree"
+        );
         assert!(repository.head()?.is_detached(), "conflict resolution detaches HEAD");
         let branch = repository.find_reference("refs/heads/main")?.id().detach();
         assert_ne!(

From c6933052aab8b3530dab50659aa91b574e472f94 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:42:20 +0200
Subject: [PATCH 111/282] Document semantic commit boundaries for gix-tix
 agents

Long tix development sessions accumulate independent UI, editing, and plumbing changes. Grouping them by request timing instead of behavior makes the stack harder to review, reorder, and reason about.

Require agents to keep each semantic change in its own commit together with its implementation, tests, snapshots, and specification updates. This preserves reviewable boundaries and prevents follow-up fixes from being hidden inside unrelated patches.
---
 gix-tix/AGENTS.md | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index e28dbabbe68..fdddd3e021b 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -14,6 +14,10 @@
 
 ## Commit authorship
 
+- Create one commit per semantically distinct change. Do not combine independent
+  behavior changes merely because they were requested together.
+- Keep each change's implementation, tests, snapshots, and corresponding
+  `spec.md` updates in that change's commit.
 - A commit created or materially rewritten by an AI agent must use that agent's own name and email as its author. Do not silently inherit the repository owner's configured identity.
 - Preserve the author of an existing commit when the agent is not responsible for its contents.
 - Use another author's identity only when the user explicitly requests it for that particular commit.

From 97056fcb8ad51e7a8680d622550d476f42508f08 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:45:24 +0200
Subject: [PATCH 112/282] fix: explain when unchanged rebase todos apply

Saving an unchanged rebase document can mean a true no-op, replay pending commits, update the base, or continue a materialized conflict. The generic opening comment gave no indication whether leaving the document untouched would mutate history.

Generate a mode-specific first Markdown comment for every combination of base update and pending work, and a distinct continuation notice. Each explains the unchanged behavior and the common cancellation rule of emptying the file or removing the versioned state comment.
---
 gix-tix/spec.md          |  5 +++-
 gix-tix/src/edit/todo.rs | 62 ++++++++++++++++++++++++++++++++++++++--
 2 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6ad08cd37f8..737a9c2e7d8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -656,7 +656,10 @@ space first; changes blocks adapt within the remaining history width.
   the document unchanged is a no-op unless its scope contains pending commits or
   rebase-update selected a newer base; then the unchanged plan runs with the same
   eager `@` ancestry and lazy-fork rules. Explicit `tix rebase apply` always
-  applies a valid plan, even when its editable commands are unchanged.
+  applies a valid plan, even when its editable commands are unchanged. The first
+  Markdown comment states which of these modes applies and explains that emptying
+  the file or removing the `tix-rebase-state-v1` comment cancels. Continuation
+  todos likewise state that saving unchanged continues the materialized rebase.
 
 ### Editing shortcuts
 
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 4e56dac0f42..40b6bba1f32 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -169,7 +169,8 @@ pub(crate) fn prepare(
         resolved: None,
         continuation_sources: Vec::new(),
     };
-    let mut document = b"<!-- Rebase help follows the editable todo. -->\n".to_vec();
+    let mut document = unchanged_notice(base != onto, has_pending).as_bytes().to_vec();
+    document.push(b'\n');
     document.extend_from_slice(title.as_bytes());
     document.extend_from_slice(b"\n\n");
     let anchor_kind = if base == onto {
@@ -246,7 +247,7 @@ pub(crate) fn prepare_continuation(
         resolved,
         continuation_sources: plan.steps.iter().flat_map(|step| step.squash.iter().copied()).collect(),
     };
-    let mut document = b"<!-- Rebase help follows the editable todo. -->\n# Continue materialized rebase\n\n".to_vec();
+    let mut document = b"<!-- Rebase help follows. Saving unchanged continues the materialized rebase; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->\n# Continue materialized rebase\n\n".to_vec();
     for (index, step) in plan.steps.iter().enumerate() {
         let continues = matches!(step.parent, rebase::PlanParent::Step(parent) if parent + 1 == index);
         if !continues {
@@ -333,6 +334,23 @@ pub(crate) fn prepare_continuation(
     })
 }
 
+fn unchanged_notice(base_updated: bool, has_pending: bool) -> &'static str {
+    match (base_updated, has_pending) {
+        (false, false) => {
+            "<!-- Rebase help follows. Saving unchanged is a no-op; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+        }
+        (false, true) => {
+            "<!-- Rebase help follows. Pending commits make saving unchanged apply this todo: the @ ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+        }
+        (true, false) => {
+            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+        }
+        (true, true) => {
+            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base and applies pending commits: the @ ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+        }
+    }
+}
+
 fn write_state(out: &mut Vec<u8>, state: &State) {
     out.extend_from_slice(STATE_START.as_bytes());
     out.extend_from_slice(format!("base {}\nonto {}\n", state.base, state.onto).as_bytes());
@@ -1067,6 +1085,27 @@ mod tests {
         Ok((fixture, repo))
     }
 
+    #[test]
+    fn unchanged_notices_cover_every_reason_to_apply_or_cancel() {
+        for (updated, pending, expected) in [
+            (false, false, "Saving unchanged is a no-op"),
+            (false, true, "Pending commits make saving unchanged apply this todo"),
+            (true, false, "Saving unchanged rebases onto the updated base"),
+            (
+                true,
+                true,
+                "Saving unchanged rebases onto the updated base and applies pending commits",
+            ),
+        ] {
+            let notice = unchanged_notice(updated, pending);
+            assert!(notice.contains(expected), "the notice explains its execution mode");
+            assert!(
+                notice.contains("remove the tix-rebase-state-v1 comment to cancel"),
+                "every notice explains explicit cancellation"
+            );
+        }
+    }
+
     fn commits(repo: &gix::Repository) -> gix_testtools::Result<(ObjectId, ObjectId, ObjectId, Vec<Commit>)> {
         let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
@@ -1118,7 +1157,10 @@ mod tests {
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         assert!(!prepared.apply_unchanged);
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.starts_with("<!-- Rebase help follows the editable todo. -->"));
+        assert!(
+            document.starts_with(unchanged_notice(false, false)),
+            "the first line explains that saving unchanged is a no-op"
+        );
         assert!(document.contains(STATE_START), "the todo carries its transaction state");
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
         assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
@@ -1233,6 +1275,10 @@ mod tests {
             prepared.apply_unchanged,
             "pending commits make an unchanged todo actionable"
         );
+        assert!(
+            prepared.document.starts_with(unchanged_notice(false, true).as_bytes()),
+            "the first line explains why the unchanged todo remains actionable"
+        );
         let document = prepared.document.clone();
         let plan = parse_plan(&repo, &document)?;
         let graph = super::super::loaded_graph(&repo)?;
@@ -1301,6 +1347,10 @@ mod tests {
             prepared.apply_unchanged,
             "moving the base makes an unchanged editor document actionable"
         );
+        assert!(
+            prepared.document.starts_with(unchanged_notice(true, false).as_bytes()),
+            "the first line explains that the unchanged todo updates its base"
+        );
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(
             document.contains(&format!(
@@ -1450,6 +1500,12 @@ mod tests {
             },
             vec![middle],
         )?;
+        assert!(
+            prepared
+                .document
+                .starts_with(b"<!-- Rebase help follows. Saving unchanged continues the materialized rebase"),
+            "the continuation explains that saving unchanged resumes it"
+        );
         let document = String::from_utf8(prepared.document.clone())?;
         assert!(document.contains(&"0".repeat(40)), "the conflict uses the full null ID");
         assert!(

From f7c3697e38222810e848affdadfd644aa0aa3ee0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:49:18 +0200
Subject: [PATCH 113/282] feat: remove pins from selected tix commits

Pins deliberately keep otherwise unreachable leaves visible, but repeated reviews and time travel can leave several pins at the same commit. Without an in-app cleanup action, users had to locate and delete implementation refs manually.

Offer `unpin` in the edit menu for a pinned row and delete every matching pin in the current worktree through one reference transaction. Preserve unrelated pins, retain the selected commit across refresh, and report whether zero, one, or multiple pins were removed.
---
 gix-tix/spec.md                 |  2 +
 gix-tix/src/app.rs              |  9 +++++
 gix-tix/src/edit/time_travel.rs | 65 +++++++++++++++++++++++++++++----
 gix-tix/src/lib.rs              | 15 ++++++++
 gix-tix/src/ui.rs               | 16 +++++++-
 5 files changed, 98 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 737a9c2e7d8..1aacd8b3ebb 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -231,6 +231,8 @@ The Enter key is written as `<enter>` throughout.
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
+- The edit menu offers `unpin` on a pinned row. It atomically removes every pin
+  for that commit in the current worktree and retains that row's selection.
 - Checkout failures retain the original `HEAD`, remove only a newly created
   source pin, and leave destination pins intact. Successful travel consumes a
   destination pin and applies the same source-pin reconciliation for ancestor,
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 4f899632d7e..54ccb718592 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -308,6 +308,7 @@ pub(crate) enum Action {
     RebaseUpdate,
     Review,
     TimeTravel,
+    Unpin,
     VerifySignatures,
     Cancel,
     Copy,
@@ -347,6 +348,7 @@ pub(crate) enum Effect {
     },
     FinishReview(ObjectId),
     TimeTravel(ObjectId),
+    Unpin(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -806,6 +808,7 @@ impl App {
                 | Action::RebaseUpdate
                 | Action::Review
                 | Action::TimeTravel
+                | Action::Unpin
         ) {
             self.edit_expanded = false;
         }
@@ -1066,6 +1069,11 @@ impl App {
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
                 )];
             }
+            Action::Unpin => {
+                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                    return vec![Effect::Unpin(id)];
+                }
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -2643,6 +2651,7 @@ mod tests {
         assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
         app.set_worktree_changes_available(false);
         assert!(app.update(Action::TimeTravel).is_empty());
+        assert_eq!(app.update(Action::Unpin), vec![Effect::Unpin(id(1))]);
     }
 
     #[test]
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index f2c6f55ef5e..8733c3156c7 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -588,18 +588,38 @@ fn create_or_reuse_pin(repository: &gix::Repository, target: Target, id: ObjectI
 
 fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     repository
-        .edit_references([RefEdit {
-            change: Change::Delete {
-                expected: PreviousValue::MustExistAndMatch(pin.target.clone()),
-                log: RefLog::AndReference,
-            },
-            name: pin.name.clone(),
-            deref: false,
-        }])
+        .edit_references([delete_pin_edit(pin)])
         .context("could not remove tix pin")?;
     Ok(())
 }
 
+pub(crate) fn remove_pins(repository_path: &Path, bare: bool, selected: ObjectId) -> Result<usize> {
+    let repository =
+        open_repository(repository_path, bare, false).context("could not open repository to remove pins")?;
+    let pins: Vec<_> = history::all_pins(&repository)?
+        .into_iter()
+        .filter(|pin| pin.id == selected)
+        .collect();
+    if pins.is_empty() {
+        return Ok(0);
+    }
+    repository
+        .edit_references(pins.iter().map(delete_pin_edit))
+        .context("could not remove tix pins")?;
+    Ok(pins.len())
+}
+
+fn delete_pin_edit(pin: &history::Pin) -> RefEdit {
+    RefEdit {
+        change: Change::Delete {
+            expected: PreviousValue::MustExistAndMatch(pin.target.clone()),
+            log: RefLog::AndReference,
+        },
+        name: pin.name.clone(),
+        deref: false,
+    }
+}
+
 fn delete_deferred_refs(repository_path: &Path, bare: bool, refs: &[(gix::refs::FullName, ObjectId)]) -> Result<()> {
     if refs.is_empty() {
         return Ok(());
@@ -1026,6 +1046,35 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn removes_every_pin_at_the_selected_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let selected = repository.rev_parse_single("main")?.detach();
+        let other = repository.rev_parse_single("topic")?.detach();
+        for (name, target) in [
+            ("refs/worktree/tix/pins/first", selected),
+            ("refs/worktree/tix/pins/second", selected),
+            ("refs/worktree/tix/pins/other", other),
+        ] {
+            repository.reference(name, target, PreviousValue::MustNotExist, "test pin removal")?;
+        }
+        drop(repository);
+
+        assert_eq!(remove_pins(&repository_path, false, selected)?, 2);
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(
+            history::all_pins(&repository)?
+                .into_iter()
+                .map(|pin| pin.id)
+                .collect::<Vec<_>>(),
+            [other],
+            "pins on other commits remain"
+        );
+        Ok(())
+    }
+
     #[test]
     fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 2a409a52ae1..fe4d0d2e83e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2263,6 +2263,19 @@ fn event_loop(
                         }
                     }
                 }
+                Effect::Unpin(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit::time_travel::remove_pins(&repository_path, repository_is_bare, id) {
+                        Ok(0) => app.leave_message("no pins removed"),
+                        Ok(count) => {
+                            app.leave_message(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
+                            app.select_commit_after_refresh(id);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_message(format!("unpin: {err:#}")),
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -4276,6 +4289,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
+        KeyCode::Char('i') if edit_expanded => Some(Action::Unpin),
         KeyCode::Char('v') if edit_expanded => Some(Action::Review),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
@@ -5285,6 +5299,7 @@ mod tests {
             ('p', Action::Split),
             ('d', Action::Forget),
             ('t', Action::TimeTravel),
+            ('i', Action::Unpin),
         ] {
             assert_eq!(
                 action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), false, true),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 722f1c473f8..0df5ed7edf2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -837,6 +837,19 @@ pub(crate) fn draw_with_worktree(
             {
                 options.push(label);
             }
+            if app.changes_focus.is_none()
+                && app
+                    .selected
+                    .and_then(|index| app.rows.get(index))
+                    .and_then(|row| decorations.get(&row.id))
+                    .is_some_and(|decorations| {
+                        decorations
+                            .iter()
+                            .any(|decoration| decoration.kind == DecorationKind::Pin)
+                    })
+            {
+                options.push(("unpin", 'i'));
+            }
             edit_prefix_spans.push(Span::raw(" · "));
             edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
             edit_prefix_spans.push(Span::raw("dit ("));
@@ -2798,7 +2811,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_row(&terminal).contains("pin:01010101"));
         assert!(
-            rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return)"),
+            rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return · unpin)"),
             "the active edit prefix contains exactly its actionable commands"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
@@ -2806,6 +2819,7 @@ mod tests {
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_line(&terminal, 1).contains("travel"));
+        assert!(!rendered_line(&terminal, 1).contains("unpin"));
         Ok(())
     }
 

From 9fcfe4be0949588125b6b5d17d774d3711c7fd04 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:49:50 +0200
Subject: [PATCH 114/282] Remove obsolete shared-pin compatibility coverage

Pins are intentionally private to each worktree, and shared `refs/tix/pins/*` compatibility was removed from the product contract. Keeping a legacy fixture and assertions implied support for a namespace that current history discovery must ignore.

Remove the shared-pin setup and compatibility assertions, and narrow the specification and test name to the current invariant: each worktree sees only pins from its own private namespace.
---
 gix-tix/spec.md        |  4 ++--
 gix-tix/src/history.rs | 13 +------------
 2 files changed, 3 insertions(+), 14 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1aacd8b3ebb..a4d8d4f0820 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -224,8 +224,8 @@ The Enter key is written as `<enter>` throughout.
 - While `HEAD` is detached, every valid pin from the current worktree augments
   implicit and explicit revision tips. While it is attached, only pins at strict
   descendants of `HEAD` do so, preserving rewritten leaves after a history rebase
-  moves the checked-out branch down its stack. Pins from other worktrees, legacy
-  shared `refs/tix/pins/*` refs, dangling, malformed, and non-commit pins do not
+  moves the checked-out branch down its stack. Pins from other worktrees,
+  dangling, malformed, and non-commit pins do not
   enter the view or its decorations. Normal hidden-revision exclusions still apply.
 - Worktree pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index e547e192027..6f5e70d3737 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -2471,7 +2471,7 @@ mod tests {
     }
 
     #[test]
-    fn pins_are_private_to_the_current_worktree_and_legacy_pins_are_ignored() -> gix_testtools::Result {
+    fn pins_are_private_to_the_current_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let linked = gix_testtools::tempfile::tempdir()?;
         let linked_path = linked.path().join("linked");
@@ -2498,13 +2498,6 @@ mod tests {
                 "test private pin",
             )?;
         }
-        main.reference(
-            "refs/tix/pins/legacy",
-            linked_id,
-            gix::refs::transaction::PreviousValue::MustNotExist,
-            "test legacy pin",
-        )?;
-
         assert_eq!(
             all_pins(&main)?.into_iter().map(|pin| pin.id).collect::<Vec<_>>(),
             [main_id],
@@ -2515,10 +2508,6 @@ mod tests {
             [linked_id],
             "the linked worktree sees only its private pin"
         );
-        assert!(
-            main.try_find_reference("refs/tix/pins/legacy")?.is_some(),
-            "the ignored shared pin remains untouched"
-        );
         Ok(())
     }
 

From b8433968af6d6ea1ef3de589eb53b2fae00c44d3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:53:52 +0200
Subject: [PATCH 115/282] change!: make existing HEAD attachment implicit in
 tix todos

Generated todos marked the currently attached branch with `@`, making unchanged checkout state look like an explicit ref edit. Removing or moving that marker also overloaded detachment, deletion, and checkout selection in ways that were difficult to reason about.

Record the attached local branch in versioned todo state and render it as an ordinary ref. Preserve attachment automatically while that ref remains at the `@` command; reserve an explicit `@ref` for requesting or enforcing attachment, and validate that it is one editable local branch at the selected result.
---
 gix-tix/spec.md          |  12 +--
 gix-tix/src/edit/todo.rs | 158 ++++++++++++++++++++++++++-------------
 2 files changed, 112 insertions(+), 58 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a4d8d4f0820..7d6d431b19a 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -606,12 +606,12 @@ space first; changes blocks adapt within the remaining history width.
   unverified signature, and `○` for an unsigned commit. Applicable states may be
   combined without changing plan semantics.
 - `@pick`, `@squash`, or `@empty` chooses the post-rebase commit. A generated
-  todo keeps this marker even when `HEAD` is attached, and additionally marks
-  its local branch as `@branch`. One command marker and one branch marker may
-  coexist only when they resolve to the same result. Removing only the branch
-  marker detaches `HEAD` without deleting the branch; removing the name deletes
-  it. Checkout markers are invalid without a worktree. Todo generation and
-  application reject an unborn `HEAD`.
+  todo keeps this marker even when `HEAD` is attached, but shows its branch as an
+  ordinary ref. Versioned state remembers that attachment while the branch stays
+  at the marked result. Moving it elsewhere detaches `HEAD`; adding `@` to one
+  local branch explicitly attaches it and is valid only at the marked result.
+  Removing the name deletes the branch. Checkout markers are invalid without a
+  worktree. Todo generation and application reject an unborn `HEAD`.
 - Only the ancestry ending at `@` and any squash groups are eagerly cherry-picked
   and re-signed. Other resulting stacks retain their trees, receive pending-rebase
   markers, and invalidate old signatures for later time travel. With no `@`,
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 40b6bba1f32..31438ded126 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -20,7 +20,7 @@ const HELP: &str = r#"
 - `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
-- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. Prefix one local branch with `@` to attach HEAD to it. `@command` and `@branch` may coexist only at the same result. Removing only the branch's `@` detaches HEAD without deleting the branch.
+- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. The current attached branch stays attached while it remains at the `@` command. Prefix one local branch with `@` to attach HEAD to it explicitly; it must point to the `@` command.
 - Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
@@ -57,6 +57,7 @@ struct State {
     scope: Vec<ObjectId>,
     marker_required: bool,
     checkout_allowed: bool,
+    head_ref: Option<gix::refs::FullName>,
     edit_refs: bool,
     expected_refs: Vec<rebase::ExpectedRef>,
     resolved: Option<ObjectId>,
@@ -164,6 +165,7 @@ pub(crate) fn prepare(
         scope: scope.clone(),
         marker_required,
         checkout_allowed: repo.workdir().is_some(),
+        head_ref,
         edit_refs: true,
         expected_refs,
         resolved: None,
@@ -193,7 +195,7 @@ pub(crate) fn prepare(
             (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
         )?;
         if !scope_set.contains(&section.parent) {
-            write_refs_at(&mut document, &state.expected_refs, section.parent, head_ref.as_ref())?;
+            write_refs_at(&mut document, &state.expected_refs, section.parent)?;
         }
         for id in &section.commits {
             let commit = by_id[id];
@@ -211,12 +213,12 @@ pub(crate) fn prepare(
                 )
                 .as_bytes(),
             );
-            write_refs_at(&mut document, &state.expected_refs, *id, head_ref.as_ref())?;
+            write_refs_at(&mut document, &state.expected_refs, *id)?;
         }
     }
     if sections.is_empty() {
         write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
-        write_refs_at(&mut document, &state.expected_refs, onto, head_ref.as_ref())?;
+        write_refs_at(&mut document, &state.expected_refs, onto)?;
     }
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
@@ -242,6 +244,7 @@ pub(crate) fn prepare_continuation(
         scope: plan.scope.clone(),
         marker_required: plan.checkout.is_some(),
         checkout_allowed: repo.workdir().is_some(),
+        head_ref: plan.checkout.as_ref().and_then(|checkout| checkout.reference.clone()),
         edit_refs: true,
         expected_refs: plan.expected_refs.clone(),
         resolved,
@@ -274,7 +277,7 @@ pub(crate) fn prepare_continuation(
                 (parent == plan.base).then_some(("base", base_title.as_str())),
             )?;
             if matches!(step.parent, rebase::PlanParent::Existing(_)) {
-                write_plan_refs_at(&mut document, &plan.expected_refs, step.parent, plan.checkout.as_ref())?;
+                write_plan_refs_at(&mut document, &plan.expected_refs, step.parent)?;
             }
         }
         let marker = if plan
@@ -319,12 +322,7 @@ pub(crate) fn prepare_continuation(
                 .as_bytes(),
             );
         }
-        write_plan_refs_at(
-            &mut document,
-            &plan.expected_refs,
-            rebase::PlanParent::Step(index),
-            plan.checkout.as_ref(),
-        )?;
+        write_plan_refs_at(&mut document, &plan.expected_refs, rebase::PlanParent::Step(index))?;
     }
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
@@ -367,6 +365,11 @@ fn write_state(out: &mut Vec<u8>, state: &State) {
         )
         .as_bytes(),
     );
+    if let Some(name) = &state.head_ref {
+        out.extend_from_slice(b"head-ref ");
+        out.extend_from_slice(gix::quote::ansi_c::quote(name.as_bstr()).as_ref());
+        out.push(b'\n');
+    }
     out.extend_from_slice(format!("edit-refs {}\n", state.edit_refs).as_bytes());
     for reference in &state.expected_refs {
         let name = gix::quote::ansi_c::quote(reference.name.as_bstr());
@@ -393,57 +396,34 @@ fn write_state(out: &mut Vec<u8>, state: &State) {
     out.push(b'\n');
 }
 
-fn write_refs_at(
-    out: &mut Vec<u8>,
-    refs: &[rebase::ExpectedRef],
-    target: ObjectId,
-    head_ref: Option<&gix::refs::FullName>,
-) -> Result<()> {
+fn write_refs_at(out: &mut Vec<u8>, refs: &[rebase::ExpectedRef], target: ObjectId) -> Result<()> {
     let names = refs
         .iter()
         .filter(|reference| reference.editable && reference.target == target)
-        .map(|reference| (&reference.name, head_ref == Some(&reference.name)))
+        .map(|reference| &reference.name)
         .collect::<Vec<_>>();
     write_ref_line(out, refs, names)
 }
 
-fn write_plan_refs_at(
-    out: &mut Vec<u8>,
-    refs: &[rebase::ExpectedRef],
-    target: rebase::PlanParent,
-    checkout: Option<&rebase::PlanCheckout>,
-) -> Result<()> {
+fn write_plan_refs_at(out: &mut Vec<u8>, refs: &[rebase::ExpectedRef], target: rebase::PlanParent) -> Result<()> {
     let names = refs
         .iter()
         .filter(|reference| reference.placement == Some(target))
-        .map(|reference| {
-            let name = &reference.name;
-            (
-                name,
-                checkout.is_some_and(|checkout| checkout.target == target && checkout.reference.as_ref() == Some(name)),
-            )
-        })
+        .map(|reference| &reference.name)
         .collect::<Vec<_>>();
     write_ref_line(out, refs, names)
 }
 
-fn write_ref_line(
-    out: &mut Vec<u8>,
-    refs: &[rebase::ExpectedRef],
-    mut names: Vec<(&gix::refs::FullName, bool)>,
-) -> Result<()> {
+fn write_ref_line(out: &mut Vec<u8>, refs: &[rebase::ExpectedRef], mut names: Vec<&gix::refs::FullName>) -> Result<()> {
     if names.is_empty() {
         return Ok(());
     }
-    names.sort_by_key(|(name, _)| *name);
+    names.sort();
     out.push(b'(');
-    for (index, (name, head)) in names.into_iter().enumerate() {
+    for (index, name) in names.into_iter().enumerate() {
         if index > 0 {
             out.extend_from_slice(b", ");
         }
-        if head {
-            out.push(b'@');
-        }
         let display = ref_display_name(name, refs);
         out.extend_from_slice(gix::quote::ansi_c::quote(display.as_bstr()).as_ref());
     }
@@ -604,6 +584,7 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
     let mut scope = Vec::new();
     let mut marker_required = None;
     let mut checkout_allowed = None;
+    let mut head_ref = None;
     let mut edit_refs = false;
     let mut expected_refs = Vec::new();
     let mut resolved = None;
@@ -633,6 +614,19 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
                     anyhow::bail!("the rebase state repeats checkout-allowed");
                 }
             }
+            "head-ref" => {
+                let encoded = value.as_bytes().as_bstr();
+                let (name, consumed) = gix::quote::ansi_c::undo(encoded)
+                    .map_err(gix::Exn::into_error)
+                    .context("could not unquote the recorded HEAD ref")?;
+                if !encoded[consumed..].trim().is_empty() {
+                    anyhow::bail!("the recorded HEAD ref has trailing data");
+                }
+                let name = gix::refs::FullName::try_from(name.as_ref()).context("the recorded HEAD ref is invalid")?;
+                if head_ref.replace(name).is_some() {
+                    anyhow::bail!("the rebase state repeats its HEAD ref");
+                }
+            }
             "edit-refs" => edit_refs = value.parse()?,
             "ref" => {
                 let (old, value) = value.split_once(' ').context("a captured ref has no target")?;
@@ -679,6 +673,7 @@ fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
         scope,
         marker_required: marker_required.context("the rebase state has no marker requirement")?,
         checkout_allowed: checkout_allowed.context("the rebase state has no checkout capability")?,
+        head_ref,
         edit_refs,
         expected_refs,
         resolved,
@@ -710,6 +705,15 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
             anyhow::bail!("a captured ref does not logically point into the rebase scope");
         }
     }
+    if let Some(name) = &state.head_ref
+        && (name.category() != Some(gix::refs::Category::LocalBranch)
+            || !state
+                .expected_refs
+                .iter()
+                .any(|reference| reference.editable && reference.name == *name))
+    {
+        anyhow::bail!("the recorded HEAD ref is not an editable local branch");
+    }
     for tip in &state.tips {
         repo.find_commit(*tip).context("could not find a recorded rebase tip")?;
     }
@@ -746,7 +750,7 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
     let mut steps = Vec::<rebase::PlanStep>::new();
     let mut cursor = None;
     let mut checkout_target = None;
-    let mut checkout_reference = None;
+    let mut explicit_checkout_reference = None;
     let mut command_marker = false;
     let mut ref_targets = HashMap::new();
     let mut sections = 0;
@@ -806,13 +810,9 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
                     if name.category() != Some(gix::refs::Category::LocalBranch) {
                         anyhow::bail!("only a local branch may carry the @ marker");
                     }
-                    if checkout_reference.replace(name).is_some() {
+                    if explicit_checkout_reference.replace((name, target)).is_some() {
                         anyhow::bail!("the rebase todo contains more than one @ reference");
                     }
-                    if checkout_target.is_some_and(|checkout| checkout != target) {
-                        anyhow::bail!("the @ command and @ reference point to different results");
-                    }
-                    checkout_target = Some(target);
                 }
             }
             section_has_commit = true;
@@ -927,6 +927,20 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
     if state.marker_required && checkout_target.is_none() {
         anyhow::bail!("the current checkout marker must be retained");
     }
+    let checkout_reference = match (checkout_target, explicit_checkout_reference) {
+        (Some(target), Some((name, reference_target))) => {
+            if target != reference_target {
+                anyhow::bail!("the @ command and @ reference point to different results");
+            }
+            Some(name)
+        }
+        (None, Some(_)) => anyhow::bail!("an @ reference requires an @ command at the same result"),
+        (Some(target), None) => state
+            .head_ref
+            .take()
+            .filter(|name| ref_targets.get(name) == Some(&target)),
+        (None, None) => None,
+    };
     if state.edit_refs {
         for reference in &mut state.expected_refs {
             if reference.editable {
@@ -1189,7 +1203,7 @@ mod tests {
         assert_eq!(
             plan.checkout.as_ref().and_then(|checkout| checkout.reference.as_ref()),
             Some(&"refs/heads/main".try_into()?),
-            "the generated @ command and @ branch agree"
+            "the generated @ command retains the implicitly attached branch"
         );
         Ok(())
     }
@@ -1208,6 +1222,7 @@ mod tests {
             scope: vec![middle],
             marker_required: false,
             checkout_allowed: true,
+            head_ref: Some(name.clone()),
             edit_refs: true,
             expected_refs: vec![rebase::ExpectedRef {
                 name: name.clone(),
@@ -1230,6 +1245,11 @@ mod tests {
         );
         let parsed = parse_state(&repo, &document)?.context("state is present")?;
         assert_eq!(parsed.expected_refs[0].name, name, "quoted names round-trip losslessly");
+        assert_eq!(
+            parsed.head_ref,
+            Some(name),
+            "the attached branch round-trips losslessly"
+        );
 
         assert!(parse(&repo, b"")?.is_none(), "empty input cancels");
         assert!(parse(&repo, b"pick deadbeef")?.is_none(), "removing the anchor cancels");
@@ -1507,6 +1527,11 @@ mod tests {
             "the continuation explains that saving unchanged resumes it"
         );
         let document = String::from_utf8(prepared.document.clone())?;
+        assert!(document.contains("(continued)"), "continuation refs are not marked");
+        assert!(
+            !document.contains("(@continued)"),
+            "HEAD attachment stays in transaction state"
+        );
         assert!(document.contains(&"0".repeat(40)), "the conflict uses the full null ID");
         assert!(
             document.contains(&format!("`squash {}`", tip.to_hex_with_len(7))),
@@ -1549,14 +1574,43 @@ mod tests {
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let generated = String::from_utf8(prepared.document.clone())?;
         assert!(
-            generated.contains("(@main, refs/patches/tip)"),
-            "the generated todo shows the attached branch as well as the HEAD command:\n{generated}"
+            generated.contains("(main, refs/patches/tip)"),
+            "the generated todo shows the attached branch as an ordinary ref:\n{generated}"
+        );
+        assert!(!generated.contains("@main"), "existing HEAD attachment is implicit");
+        assert_eq!(
+            parse_plan(&repo, &prepared.document)?
+                .checkout
+                .and_then(|checkout| checkout.reference),
+            Some("refs/heads/main".try_into()?),
+            "an unchanged todo retains the original attachment"
+        );
+
+        let explicit = generated.replace("(main, refs/patches/tip)", "(@main, refs/patches/tip)");
+        assert_eq!(
+            parse_plan(&repo, explicit.as_bytes())?
+                .checkout
+                .and_then(|checkout| checkout.reference),
+            Some("refs/heads/main".try_into()?),
+            "adding @ explicitly enforces the same attachment"
+        );
+
+        let mismatched = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\npick {}\n(@main)\n@pick {}\n",
+                base.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+            ),
         );
+        let err = parse(&repo, &mismatched).expect_err("an explicit attachment must agree with @pick");
+        assert!(format!("{err:#}").contains("different results"));
 
         let edited = with_state(
             &prepared,
             &format!(
-                "## fork {}\npick {}\n(new-1)\n@pick {}\n(main)\n",
+                "## fork {}\npick {}\n(new-1, main)\n@pick {}\n",
                 base.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
@@ -1567,7 +1621,7 @@ mod tests {
             plan.checkout
                 .as_ref()
                 .is_some_and(|checkout| checkout.reference.is_none()),
-            "removing @ from main requests a detached checkout"
+            "moving the implicit HEAD branch away from @ requests a detached checkout"
         );
         let graph = super::super::loaded_graph(&repo)?;
         let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;

From ccc5a23cdb4c23c1915c3aaa1bb20cf8eeb1991f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 14:56:38 +0200
Subject: [PATCH 116/282] fix: show refs only once in tix rebase todos

References had become first-class editable lines in rebase todos, but the display metadata copied from history still repeated the same decorations beside each commit. The duplicate presentation obscured which representation actually controlled ref movement.

Format todo commit metadata without reference decorations in both TUI and CLI preparation. Standalone ref lines remain the sole editable source of ref placement, while dates, authors, attributions, and subjects retain the familiar history presentation.
---
 gix-tix/spec.md               |  2 ++
 gix-tix/src/command/rebase.rs |  2 +-
 gix-tix/src/edit/todo.rs      |  2 +-
 gix-tix/src/lib.rs            |  2 +-
 gix-tix/src/ui.rs             | 16 +++++++++-------
 5 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7d6d431b19a..bc8dfebb163 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -596,6 +596,8 @@ space first; changes blocks adapt within the remaining history width.
   state comment follows the complete help at the end of the document.
 - Standalone `(ref, ref)` lines place direct mutable refs at the preceding fork
   heading or command result. Multiple consecutive lines share that destination.
+  Commit command metadata omits ref decorations because these lines are their
+  sole editable representation.
   Existing displayed names may be moved or removed, and new unqualified names
   create local branches; explicit editable `refs/...` names are also accepted.
   Short names follow the history display, ambiguous names expand to full names,
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index f7bcd247205..93b8c053b00 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -189,7 +189,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
             Ok(todo::Commit {
                 id: *id,
                 parents: row.parent_ids.iter().copied().collect(),
-                info: crate::ui::todo_metadata(&app, row, &decorations, &mailmap),
+                info: crate::ui::todo_metadata(&app, row, &mailmap),
             })
         })
         .collect::<Result<Vec<_>>>()?;
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 31438ded126..f357b65918c 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1132,7 +1132,7 @@ mod tests {
                 Commit {
                     id: tip,
                     parents: vec![middle],
-                    info: "(main) 2000-01-03 author tip".into(),
+                    info: "2000-01-03 author tip".into(),
                 },
                 Commit {
                     id: middle,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index fe4d0d2e83e..db6c10e25e2 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2109,7 +2109,7 @@ fn event_loop(
                             Ok(edit::todo::Commit {
                                 id: *id,
                                 parents: row.parent_ids.to_vec(),
-                                info: ui::todo_metadata(&app, row, &decorations, &mailmap),
+                                info: ui::todo_metadata(&app, row, &mailmap),
                             })
                         })
                         .collect::<Result<Vec<_>>>();
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 0df5ed7edf2..19157255324 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1806,18 +1806,14 @@ fn metadata_line<'a>(
     Line::from(spans)
 }
 
-pub(crate) fn todo_metadata(
-    app: &App,
-    row: &CommitRow,
-    decorations: &Decorations,
-    mailmap: &gix::mailmap::Snapshot,
-) -> String {
+pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::Snapshot) -> String {
     let title = app.title(row);
+    let decorations = Decorations::new();
     let line = metadata_line(
         row,
         title,
         app.attributions(row),
-        decorations,
+        &decorations,
         mailmap,
         MetadataOptions {
             show_committer_date: app.show_committer_date,
@@ -2577,6 +2573,12 @@ mod tests {
 
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
 
+        assert_eq!(
+            super::todo_metadata(&app, &app.rows[0], &mailmap),
+            "1970-01-01 mapped author subject",
+            "todo commit metadata excludes separately represented refs"
+        );
+
         let footer_text = "#1 · view · edit · copy · refs · ? · ↑↓/jk move · h/l pan · <enter> diff · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);

From 6196e07998399c15cbb23e921524f16e04d1dcaa Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:16:52 +0200
Subject: [PATCH 117/282] feat: pin arbitrary commits from the tix CLI

History edits and detached travel sometimes need an explicit durable tip, but pin creation was available only through interactive TUI flows. Scripts and agents could not prepare the same safety boundary before invoking edit commands.

Add `tix pin` for one or more revspecs, resolving the complete request before writing so an invalid argument leaves no partial pins. Preserve first-seen order, deduplicate commit IDs, reuse matching direct pins without collapsing distinct symbolic ones, and print each label with its repository-shortened ID.
---
 gix-tix/spec.md                 |   4 +
 gix-tix/src/command.rs          | 130 +++++++++++++++++++++++++++++++-
 gix-tix/src/edit/time_travel.rs |  13 +++-
 3 files changed, 142 insertions(+), 5 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bc8dfebb163..ae0eabd50a7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -233,6 +233,10 @@ The Enter key is written as `<enter>` throughout.
   then lexical ref-name order.
 - The edit menu offers `unpin` on a pinned row. It atomically removes every pin
   for that commit in the current worktree and retains that row's selection.
+- `tix pin <REVSPEC>...` resolves every argument before writing, deduplicates
+  commits in argument order, and creates or reuses direct current-worktree pins.
+  Each unique commit prints as `pin:<suffix> <short-id>`; symbolic pins at the
+  same current commit remain distinct because their targets may move.
 - Checkout failures retain the original `HEAD`, remove only a newly created
   source pin, and leave destination pins intact. Successful travel consumes a
   destination pin and applies the same source-pin reconciliation for ancestor,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 0da79c5c25f..e7206fde32d 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -1,7 +1,8 @@
-use std::ffi::OsString;
+use std::{collections::HashSet, ffi::OsString};
 
 use anyhow::{Context, Result};
 use clap::Parser;
+use gix::prelude::ObjectIdExt;
 
 mod rebase;
 
@@ -35,11 +36,20 @@ enum Command {
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
     Split,
+    /// Pin one or more commits as persistent history tips.
+    Pin(Pin),
     /// Generate or apply a self-contained history-rebase todo.
     #[command(subcommand)]
     Rebase(rebase::Command),
 }
 
+#[derive(Debug, clap::Args)]
+struct Pin {
+    /// Revisions resolving to commits to pin.
+    #[arg(required = true, value_name = "REVSPEC")]
+    revisions: Vec<OsString>,
+}
+
 #[derive(Debug, clap::Parser)]
 #[command(
     name = "tix",
@@ -95,12 +105,58 @@ impl Platform {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 split(repository, &graph)?;
             }
+            Command::Pin(args) => pin(&repository, args)?,
             Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
     }
 }
 
+fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
+    for pin in create_pins(repository, &args.revisions)? {
+        println!("{}", display_pin(repository, &pin)?);
+    }
+    Ok(())
+}
+
+fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<Vec<crate::history::Pin>> {
+    let mut seen = HashSet::new();
+    let ids = revisions
+        .iter()
+        .map(|revision| {
+            let revision = gix::path::os_str_into_bstr(revision)
+                .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
+            let id = repository
+                .rev_parse_single(revision)
+                .with_context(|| format!("could not resolve revision {revision:?}"))?;
+            Ok(id
+                .object()
+                .context("could not read pin target")?
+                .peel_to_commit()
+                .context("pin target does not resolve to a commit")?
+                .id)
+        })
+        .collect::<Result<Vec<_>>>()?;
+    ids.into_iter()
+        .filter(|id| seen.insert(*id))
+        .map(|id| {
+            crate::edit::time_travel::create_or_reuse_pin(repository, gix::refs::Target::Object(id), id, "tix pin")
+                .map(|(pin, _created)| pin)
+        })
+        .collect()
+}
+
+fn display_pin(repository: &gix::Repository, pin: &crate::history::Pin) -> Result<String> {
+    Ok(format!(
+        "{} {}",
+        crate::edit::time_travel::pin_label(pin),
+        pin.id
+            .attach(repository)
+            .shorten()
+            .context("could not shorten pinned commit ID")?
+    ))
+}
+
 fn edit_head(
     repository: gix::Repository,
     graph: &crate::history::HistoryGraph,
@@ -183,6 +239,14 @@ mod tests {
                 .command,
             Some(Command::Split)
         ));
+        let pin = Cli::try_parse_from(["tix", "pin", "main", "HEAD~2"])
+            .expect("one or more pin revisions parse")
+            .platform
+            .command;
+        let Some(Command::Pin(pin)) = pin else {
+            panic!("pin was expected")
+        };
+        assert_eq!(pin.revisions, ["main", "HEAD~2"]);
         assert!(matches!(
             Cli::try_parse_from([
                 "tix",
@@ -257,12 +321,76 @@ mod tests {
                 .kind(),
             ErrorKind::UnknownArgument
         );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "pin"])
+                .expect_err("pin requires at least one revision")
+                .kind(),
+            ErrorKind::MissingRequiredArgument
+        );
 
         let cli = Cli::try_parse_from(["tix", "--", "amend"]).expect("-- makes amend a revision");
         assert!(cli.platform.command.is_none());
         assert_eq!(cli.platform.revisions, ["amend"]);
     }
 
+    #[test]
+    fn pin_resolves_every_revision_before_creating_direct_deduplicated_pins() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let revisions = |values: &[&str]| values.iter().map(OsString::from).collect::<Vec<_>>();
+        let main = repository.rev_parse_single("main")?.detach();
+
+        for invalid in ["missing", "main..topic", "HEAD^{tree}"] {
+            create_pins(&repository, &revisions(&["main", invalid]))
+                .expect_err("a non-commit revision rejects the complete request");
+            assert!(
+                crate::history::all_pins(&repository)?.is_empty(),
+                "resolution failure is unobservable"
+            );
+        }
+
+        assert!(
+            ProcessCommand::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["symbolic-ref", "refs/worktree/tix/pins/follow", "refs/heads/main",])
+                .status()?
+                .success(),
+            "the fixture has a movable symbolic pin"
+        );
+        let root = repository.rev_parse_single("v1")?.object()?.peel_to_commit()?.id;
+        let short_main = main.to_hex_with_len(7).to_string();
+        let pins = create_pins(&repository, &revisions(&["main", "v1", &short_main]))?;
+        assert_eq!(
+            pins.iter().map(|pin| pin.id).collect::<Vec<_>>(),
+            [main, root],
+            "duplicate revspec results preserve first-seen order"
+        );
+        assert!(
+            pins.iter()
+                .all(|pin| pin.target.try_id().map(ToOwned::to_owned) == Some(pin.id)),
+            "command-created pins are direct"
+        );
+        assert_eq!(
+            crate::history::all_pins(&repository)?.len(),
+            3,
+            "the symbolic pin does not suppress an explicit direct pin"
+        );
+
+        let repeated = create_pins(&repository, &revisions(&["main"]))?;
+        assert_eq!(repeated[0].name, pins[0].name, "an existing direct pin is reused");
+        assert_eq!(crate::history::all_pins(&repository)?.len(), 3);
+        let display = display_pin(&repository, &pins[0])?;
+        let (label, short_id) = display.split_once(' ').context("pin output has a label and ID")?;
+        assert!(label.starts_with("pin:"), "output names the pin");
+        assert_eq!(
+            short_id,
+            main.attach(&repository).shorten()?.to_string(),
+            "output uses the repository's abbreviated ID"
+        );
+        Ok(())
+    }
+
     #[test]
     fn split_command_uses_the_index_for_the_new_commit_and_worktree_for_its_parent() -> gix_testtools::Result {
         fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 8733c3156c7..7fd1286faf2 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -139,7 +139,7 @@ fn move_head_to(
         return Ok(None);
     }
     let destination_pin = selected_pin(&repository, selected)?;
-    let provisional = create_or_reuse_pin(&repository, saved_target, head_id)?;
+    let provisional = create_or_reuse_pin(&repository, saved_target, head_id, "tix time-travel")?;
     drop(repository);
     let checkout = match (reference, &destination_pin) {
         (Some(reference), _) => checkout_branch(&workdir, reference),
@@ -536,7 +536,12 @@ fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Opti
     Ok(pins.into_iter().next())
 }
 
-fn create_or_reuse_pin(repository: &gix::Repository, target: Target, id: ObjectId) -> Result<(history::Pin, bool)> {
+pub(crate) fn create_or_reuse_pin(
+    repository: &gix::Repository,
+    target: Target,
+    id: ObjectId,
+    reflog_message: &str,
+) -> Result<(history::Pin, bool)> {
     let pins = history::all_pins(repository)?;
     if let Some(pin) = pins.iter().find(|pin| pin.target == target) {
         return Ok((pin.clone(), false));
@@ -574,7 +579,7 @@ fn create_or_reuse_pin(repository: &gix::Repository, target: Target, id: ObjectI
                 log: LogChange {
                     mode: RefLog::AndReference,
                     force_create_reflog: false,
-                    message: "tix time-travel".into(),
+                    message: reflog_message.into(),
                 },
                 expected: PreviousValue::MustNotExist,
                 new: target.clone(),
@@ -704,7 +709,7 @@ fn contains(repository: &gix::Repository, ancestor: ObjectId, descendant: Object
             .is_ok_and(|base| base.as_ref() == ancestor)
 }
 
-fn pin_label(pin: &history::Pin) -> String {
+pub(crate) fn pin_label(pin: &history::Pin) -> String {
     format!(
         "pin:{}",
         pin.name

From 14a0af3d132c1296933c7a9689eaacc70b0af1f1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:21:57 +0200
Subject: [PATCH 118/282] fix: center the initial HEAD selection in tix

Startup selected the current worktree HEAD as soon as it appeared, but merely kept it visible at the viewport edge. When HEAD had descendants, the first frame concealed the surrounding history and made the detached position look like a tip.

Retain the pending initial selection until the real viewport height is known, then center it with normal boundary clamping. Continue following HEAD while history streams unless the user navigates first, so startup reveals useful context without overriding interaction.
---
 gix-tix/spec.md    |  7 ++++---
 gix-tix/src/app.rs | 38 ++++++++++++++++++++++++++++++++++++--
 gix-tix/src/ui.rs  |  1 +
 3 files changed, 41 insertions(+), 5 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ae0eabd50a7..219b9bd1fba 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -107,9 +107,10 @@ without trading responsiveness for metadata that is not visible.
   the same signature and selection coloring. It remains visible when textual
   reference labels are hidden, and textual `HEAD` is never rendered alongside it.
 - At startup, the current worktree's `@` row becomes selected as soon as it is
-  loaded, unless the user navigates first. If it has visible descendants, its
-  unselected non-whitespace content is underlined and `@` is bold; a selected
-  row keeps only bold `@`.
+  loaded, unless the user navigates first. Once the viewport is known, the row
+  is centered with normal history-boundary clamping so surrounding commits are
+  visible. If it has visible descendants, its unselected non-whitespace content
+  is underlined and `@` is bold; a selected row keeps only bold `@`.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. Other detached
   worktrees use their checkout directory basename. The current worktree's
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 54ccb718592..0cc8471da68 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -650,7 +650,6 @@ impl App {
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
         {
             self.selected = Some(index);
-            self.pending_initial_selection = None;
             self.ensure_visible();
         }
         if self.reachability_anchor.is_some() {
@@ -1137,7 +1136,6 @@ impl App {
                 self.state = State::Computing;
                 self.follow_tail = false;
                 self.reload_selection = None;
-                self.pending_initial_selection = None;
                 Some(self.rows.clone())
             }
             State::Cancelling => {
@@ -1815,6 +1813,26 @@ impl App {
         }
     }
 
+    pub(crate) fn center_initial_selection(&mut self) {
+        let Some(id) = self.pending_initial_selection else {
+            return;
+        };
+        let Some(selected) = self.rows.iter().position(|row| row.id == id) else {
+            if matches!(self.state, State::Complete | State::Cancelled) {
+                self.pending_initial_selection = None;
+            }
+            return;
+        };
+        let height = self.viewport_rows.max(1);
+        let centered = selected.saturating_sub(height / 2);
+        let max_offset = self.rows.len().saturating_sub(height);
+        self.selected = Some(selected);
+        self.offset = centered.min(max_offset);
+        if matches!(self.state, State::Complete | State::Cancelled) {
+            self.pending_initial_selection = None;
+        }
+    }
+
     pub(crate) fn set_horizontal_bounds(&mut self, page: usize, max: usize) {
         self.horizontal_page = page.max(1);
         self.horizontal_max = max;
@@ -2897,6 +2915,22 @@ mod tests {
         assert_eq!(moved.selected, Some(0), "navigation cancels the pending jump to HEAD");
     }
 
+    #[test]
+    fn startup_selection_centers_the_worktree_head_once_the_viewport_is_known() {
+        let mut app = App::new(1);
+        app.set_worktree_head(Some(id(4)), true);
+        app.extend_commits((1..=7).rev().map(row).collect::<Vec<_>>());
+        assert_eq!(
+            app.offset, 3,
+            "the provisional one-row viewport only keeps HEAD visible"
+        );
+
+        app.viewport_rows = 5;
+        app.center_initial_selection();
+        assert_eq!(app.selected, Some(3), "HEAD remains selected");
+        assert_eq!(app.offset, 1, "HEAD is centered once the real viewport height is known");
+    }
+
     #[test]
     fn startup_head_selection_falls_back_when_head_is_unavailable() {
         let mut absent = App::new(2);
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 19157255324..1b92290c8b8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -351,6 +351,7 @@ pub(crate) fn draw_with_worktree(
         .min()
         .unwrap_or(body.height)
         .max(1) as usize;
+    app.center_initial_selection();
     app.ensure_visible();
     let start = app.offset.min(app.rows.len());
     let render_end = start.saturating_add(body.height as usize).min(app.rows.len());

From 49182fa7758670d92ff0f99a95b8467aa24d74d5 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:26:46 +0200
Subject: [PATCH 119/282] feat: follow references pinned by tix

A direct pin created from a branch name became stale as soon as another process advanced that branch. Conversely, derived revisions such as `main~1` must continue to identify the commit resolved at creation time.

Retain the parsed revspec reference and create a symbolic pin only when the argument directly names the peeled commit. Keep expressions and object IDs as direct pins, deduplicate by target semantics, and verify that symbolic pins follow later branch updates.
---
 gix-tix/spec.md        |  9 +++---
 gix-tix/src/command.rs | 68 ++++++++++++++++++++++++++++--------------
 2 files changed, 51 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 219b9bd1fba..b5e088527cb 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -234,10 +234,11 @@ The Enter key is written as `<enter>` throughout.
   then lexical ref-name order.
 - The edit menu offers `unpin` on a pinned row. It atomically removes every pin
   for that commit in the current worktree and retains that row's selection.
-- `tix pin <REVSPEC>...` resolves every argument before writing, deduplicates
-  commits in argument order, and creates or reuses direct current-worktree pins.
-  Each unique commit prints as `pin:<suffix> <short-id>`; symbolic pins at the
-  same current commit remain distinct because their targets may move.
+- `tix pin <REVSPEC>...` resolves every argument before writing and deduplicates
+  pin targets in argument order. A direct reference name creates or reuses a
+  symbolic current-worktree pin so it follows later reference updates; derived
+  revisions and object IDs remain fixed direct pins. Each unique target prints
+  as `pin:<suffix> <short-id>`, and targets at the same commit remain distinct.
 - Checkout failures retain the original `HEAD`, remove only a newly created
   source pin, and leave destination pins intact. Successful travel consumes a
   destination pin and applies the same source-pin reconciliation for ancestor,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index e7206fde32d..bade7d745b0 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -2,7 +2,7 @@ use std::{collections::HashSet, ffi::OsString};
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use gix::prelude::ObjectIdExt;
+use gix::prelude::{ObjectIdExt, ReferenceExt};
 
 mod rebase;
 
@@ -121,27 +121,37 @@ fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
 
 fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<Vec<crate::history::Pin>> {
     let mut seen = HashSet::new();
-    let ids = revisions
+    let targets = revisions
         .iter()
         .map(|revision| {
             let revision = gix::path::os_str_into_bstr(revision)
                 .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
-            let id = repository
-                .rev_parse_single(revision)
+            let spec = repository
+                .rev_parse(revision)
                 .with_context(|| format!("could not resolve revision {revision:?}"))?;
-            Ok(id
+            let reference = spec.first_reference().cloned();
+            let id = spec
+                .single()
+                .with_context(|| format!("revision {revision:?} does not name a single object"))?
                 .object()
                 .context("could not read pin target")?
                 .peel_to_commit()
                 .context("pin target does not resolve to a commit")?
-                .id)
+                .id;
+            let target = match reference {
+                Some(reference) if reference.clone().attach(repository).peel_to_commit()?.id == id => {
+                    gix::refs::Target::Symbolic(reference.name)
+                }
+                _ => gix::refs::Target::Object(id),
+            };
+            Ok((target, id))
         })
         .collect::<Result<Vec<_>>>()?;
-    ids.into_iter()
-        .filter(|id| seen.insert(*id))
-        .map(|id| {
-            crate::edit::time_travel::create_or_reuse_pin(repository, gix::refs::Target::Object(id), id, "tix pin")
-                .map(|(pin, _created)| pin)
+    targets
+        .into_iter()
+        .filter(|(target, _id)| seen.insert(target.clone()))
+        .map(|(target, id)| {
+            crate::edit::time_travel::create_or_reuse_pin(repository, target, id, "tix pin").map(|(pin, _created)| pin)
         })
         .collect()
 }
@@ -334,7 +344,7 @@ mod tests {
     }
 
     #[test]
-    fn pin_resolves_every_revision_before_creating_direct_deduplicated_pins() -> gix_testtools::Result {
+    fn pin_follows_direct_references_and_keeps_derived_revisions_fixed() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
         let revisions = |values: &[&str]| values.iter().map(OsString::from).collect::<Vec<_>>();
@@ -359,27 +369,30 @@ mod tests {
             "the fixture has a movable symbolic pin"
         );
         let root = repository.rev_parse_single("v1")?.object()?.peel_to_commit()?.id;
+        let parent = repository.rev_parse_single("main~1")?.detach();
         let short_main = main.to_hex_with_len(7).to_string();
-        let pins = create_pins(&repository, &revisions(&["main", "v1", &short_main]))?;
+        let pins = create_pins(&repository, &revisions(&["main", "v1", "main~1", &short_main]))?;
         assert_eq!(
             pins.iter().map(|pin| pin.id).collect::<Vec<_>>(),
-            [main, root],
-            "duplicate revspec results preserve first-seen order"
+            [main, root, parent, main],
+            "distinct pin targets preserve argument order even when IDs match"
         );
-        assert!(
+        assert_eq!(
             pins.iter()
-                .all(|pin| pin.target.try_id().map(ToOwned::to_owned) == Some(pin.id)),
-            "command-created pins are direct"
+                .map(|pin| pin.target.try_name().is_some())
+                .collect::<Vec<_>>(),
+            [true, true, false, false],
+            "direct reference names follow symbolically while derived revisions and IDs stay fixed"
         );
         assert_eq!(
             crate::history::all_pins(&repository)?.len(),
-            3,
-            "the symbolic pin does not suppress an explicit direct pin"
+            4,
+            "the existing branch pin is reused while other semantic targets remain distinct"
         );
 
         let repeated = create_pins(&repository, &revisions(&["main"]))?;
-        assert_eq!(repeated[0].name, pins[0].name, "an existing direct pin is reused");
-        assert_eq!(crate::history::all_pins(&repository)?.len(), 3);
+        assert_eq!(repeated[0].name, pins[0].name, "an existing symbolic pin is reused");
+        assert_eq!(crate::history::all_pins(&repository)?.len(), 4);
         let display = display_pin(&repository, &pins[0])?;
         let (label, short_id) = display.split_once(' ').context("pin output has a label and ID")?;
         assert!(label.starts_with("pin:"), "output names the pin");
@@ -388,6 +401,17 @@ mod tests {
             main.attach(&repository).shorten()?.to_string(),
             "output uses the repository's abbreviated ID"
         );
+        repository.reference(
+            "refs/heads/main",
+            parent,
+            gix::refs::transaction::PreviousValue::MustExistAndMatch(gix::refs::Target::Object(main)),
+            "advance pinned reference",
+        )?;
+        let followed = crate::history::all_pins(&repository)?
+            .into_iter()
+            .find(|pin| pin.name == pins[0].name)
+            .context("the symbolic pin remains")?;
+        assert_eq!(followed.id, parent, "the symbolic pin follows the moved branch");
         Ok(())
     }
 

From 4e1d28458ac7dd8dbbcb6febf9eac80ff7b62794 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:35:32 +0200
Subject: [PATCH 120/282] fix: don't replay clean checkout ancestry in tix
 todos

An unchanged todo became actionable when any visible fork contained a pending commit. A pending sibling could therefore force the clean `@` ancestry through needless cherry-picking and signing.

Inspect only the first-parent path ending at the checkout marker when deciding whether the history editor must apply an unchanged document. Pending work on other forks remains visible and lazy, while explicit command-line apply keeps its intentional always-apply semantics.
---
 gix-tix/spec.md          |  7 ++--
 gix-tix/src/edit/todo.rs | 69 ++++++++++++++++++++++++++++++++++------
 2 files changed, 64 insertions(+), 12 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b5e088527cb..39a3e221578 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -663,9 +663,10 @@ space first; changes blocks adapt within the remaining history width.
   a referenced leaf, the existing time-travel checkout detaches `HEAD` there while
   the ref stays at the leaf. Concurrent ref edits win by making the transaction
   fail; the editor result is not rebuilt against a later graph snapshot. Leaving
-  the document unchanged is a no-op unless its scope contains pending commits or
-  rebase-update selected a newer base; then the unchanged plan runs with the same
-  eager `@` ancestry and lazy-fork rules. Explicit `tix rebase apply` always
+  the document unchanged is a no-op unless the ancestry ending at `@` contains
+  pending commits or rebase-update selected a newer base; pending commits on
+  other forks remain lazy and do not replay a clean checkout ancestry. Explicit
+  `tix rebase apply` always
   applies a valid plan, even when its editable commands are unchanged. The first
   Markdown comment states which of these modes applies and explains that emptying
   the file or removing the `tix-rebase-state-v1` comment cancels. Continuation
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index f357b65918c..15b046f5154 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -21,7 +21,7 @@ const HELP: &str = r#"
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. The current attached branch stays attached while it remains at the `@` command. Prefix one local branch with `@` to attach HEAD to it explicitly; it must point to the `@` command.
-- Saving an unchanged document in the history-view editor is a no-op unless listed commits have a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
+- Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
 - Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
@@ -104,6 +104,7 @@ pub(crate) fn prepare(
         .flatten();
     let scope: Vec<_> = commits.iter().map(|commit| commit.id).collect();
     let scope_set: HashSet<_> = scope.iter().copied().collect();
+    let by_id: HashMap<_, _> = commits.iter().map(|commit| (commit.id, commit)).collect();
     let marker_required = repo.workdir().is_some() && scope_set.contains(&head);
     let mut tips = scope_set.clone();
     for commit in commits {
@@ -112,13 +113,23 @@ pub(crate) fn prepare(
         }
     }
     let tips = tips.into_iter().collect::<Vec<_>>();
-    let has_pending = commits.iter().try_fold(false, |pending, commit| {
-        Ok::<_, anyhow::Error>(pending || rebase::is_pending(&repo.find_commit(commit.id)?.decode()?.into_owned()?))
-    })?;
+    let mut cursor = marker_required.then_some(head);
+    let mut has_pending = false;
+    while let Some(id) = cursor {
+        let commit = by_id.get(&id).context("the checkout ancestry is incomplete")?;
+        if rebase::is_pending(&repo.find_commit(id)?.decode()?.into_owned()?) {
+            has_pending = true;
+            break;
+        }
+        cursor = commit
+            .parents
+            .first()
+            .copied()
+            .filter(|parent| scope_set.contains(parent));
+    }
     let apply_unchanged = base != onto || has_pending;
 
     let mut children = HashMap::<ObjectId, Vec<ObjectId>>::new();
-    let by_id: HashMap<_, _> = commits.iter().map(|commit| (commit.id, commit)).collect();
     for commit in commits {
         let parent = commit
             .parents
@@ -338,13 +349,13 @@ fn unchanged_notice(base_updated: bool, has_pending: bool) -> &'static str {
             "<!-- Rebase help follows. Saving unchanged is a no-op; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
         }
         (false, true) => {
-            "<!-- Rebase help follows. Pending commits make saving unchanged apply this todo: the @ ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Pending commits on the @ ancestry make saving unchanged apply this todo: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
         }
         (true, false) => {
             "<!-- Rebase help follows. Saving unchanged rebases onto the updated base; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
         }
         (true, true) => {
-            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base and applies pending commits: the @ ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base and applies pending commits on the @ ancestry: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
         }
     }
 }
@@ -1103,12 +1114,16 @@ mod tests {
     fn unchanged_notices_cover_every_reason_to_apply_or_cancel() {
         for (updated, pending, expected) in [
             (false, false, "Saving unchanged is a no-op"),
-            (false, true, "Pending commits make saving unchanged apply this todo"),
+            (
+                false,
+                true,
+                "Pending commits on the @ ancestry make saving unchanged apply this todo",
+            ),
             (true, false, "Saving unchanged rebases onto the updated base"),
             (
                 true,
                 true,
-                "Saving unchanged rebases onto the updated base and applies pending commits",
+                "Saving unchanged rebases onto the updated base and applies pending commits on the @ ancestry",
             ),
         ] {
             let notice = unchanged_notice(updated, pending);
@@ -1320,6 +1335,42 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pending_commits_outside_the_checkout_ancestry_do_not_apply_an_unchanged_todo() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, mut commits) = commits(&repo)?;
+        let mut sibling = repo.find_commit(tip)?.decode()?.into_owned()?;
+        sibling.parents = [middle].into_iter().collect();
+        sibling.message = "pending sibling".into();
+        sibling
+            .extra_headers
+            .push(("tix-rebase-parent".into(), middle.to_hex().to_string().into()));
+        let sibling = repo.write_object(&sibling)?.detach();
+        commits.push(Commit {
+            id: sibling,
+            parents: vec![middle],
+            info: "pending sibling".into(),
+        });
+
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        assert!(
+            !prepared.apply_unchanged,
+            "pending commits on another fork must not replay the clean checkout ancestry"
+        );
+        assert!(
+            prepared.document.starts_with(unchanged_notice(false, false).as_bytes()),
+            "the first line identifies an unchanged todo as a no-op"
+        );
+        assert!(
+            prepared
+                .document
+                .windows("↻".len())
+                .any(|window| window == "↻".as_bytes()),
+            "the pending sibling remains visible in the todo"
+        );
+        Ok(())
+    }
+
     #[test]
     fn descendant_forks_stay_terse() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;

From 911d86343a3e2511a06757c412064ff716dd02bb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:38:14 +0200
Subject: [PATCH 121/282] feat: show pinned tix commits with a pushpin

Generated pin suffixes are implementation details and consumed valuable horizontal space without explaining why the commit mattered. Multiple pins at one commit made that noise worse.

Represent pin presence with one blue pushpin in history metadata, regardless of how many pins point there, and omit their internal names. The row communicates retained history while leaving exact pin identities to rebase todos and ref plumbing.
---
 gix-tix/spec.md   |  3 ++-
 gix-tix/src/ui.rs | 34 ++++++++++++++++++++++++++++------
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 39a3e221578..b4b7fdbfb6d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -228,7 +228,8 @@ The Enter key is written as `<enter>` throughout.
   moves the checked-out branch down its stack. Pins from other worktrees,
   dangling, malformed, and non-commit pins do not
   enter the view or its decorations. Normal hidden-revision exclusions still apply.
-- Worktree pins are shown as blue `pin:<suffix>` decorations. `t` on a pinned
+- One or more worktree pins at a commit are shown as a single blue `📌`
+  decoration; their internal names are omitted from history rows. `t` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 1b92290c8b8..4f2d6ed242b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1669,6 +1669,7 @@ fn metadata_line<'a>(
         },
     )];
     let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
+    let mut pin_shown = false;
     let mut labels = row_decorations
         .iter()
         .filter(|decoration| match ref_mode {
@@ -1684,6 +1685,14 @@ fn metadata_line<'a>(
                     )
             }
         })
+        .filter(|decoration| {
+            if decoration.kind != DecorationKind::Pin {
+                return true;
+            }
+            let show = !pin_shown;
+            pin_shown = true;
+            show
+        })
         .peekable();
     if labels.peek().is_some() {
         spans.push(Span::raw(" ("));
@@ -1691,7 +1700,11 @@ fn metadata_line<'a>(
             if index != 0 {
                 spans.push(Span::raw(", "));
             }
-            let name = decoration.name.to_str_lossy();
+            let name = if decoration.kind == DecorationKind::Pin {
+                std::borrow::Cow::Borrowed("📌")
+            } else {
+                decoration.name.to_str_lossy()
+            };
             spans.push(Span::styled(
                 if matches!(
                     decoration.kind,
@@ -2796,10 +2809,16 @@ mod tests {
         let mut decorations = Decorations::from([
             (
                 selected,
-                vec![Decoration {
-                    name: "pin:01010101".into(),
-                    kind: DecorationKind::Pin,
-                }],
+                vec![
+                    Decoration {
+                        name: "pin:01010101".into(),
+                        kind: DecorationKind::Pin,
+                    },
+                    Decoration {
+                        name: "pin:01010102".into(),
+                        kind: DecorationKind::Pin,
+                    },
+                ],
             ),
             (
                 head,
@@ -2812,7 +2831,10 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_row(&terminal).contains("pin:01010101"));
+        let row = rendered_row(&terminal);
+        assert!(row.contains("📌"), "a pinned commit has an obvious pin marker: {row:?}");
+        assert_eq!(row.matches("📌").count(), 1, "multiple pins share one visual marker");
+        assert!(!row.contains("pin:01010101"), "pin identities stay out of history rows");
         assert!(
             rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return · unpin)"),
             "the active edit prefix contains exactly its actionable commands"

From e20d457c910d6c5dd6ef57a741b20db3948f31cc Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:41:33 +0200
Subject: [PATCH 122/282] feat: group tix navigation hints under help

Pane switching and navigation hints occupied the footer continuously even though they describe stable, discoverable behavior. On narrower terminals they crowded out stateful actions that mattered more.

Move switch, move, pan, and diff hints behind the `?` information prefix and reveal them only while that group is expanded. Keep quit outside the group and show transient focus feedback there only when the information menu is visible.
---
 gix-tix/spec.md   |  5 +++--
 gix-tix/src/ui.rs | 36 ++++++++++++++++++++----------------
 2 files changed, 23 insertions(+), 18 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b4b7fdbfb6d..843a43ce1c8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -198,12 +198,13 @@ navigation or another recognized command. The `?` group similarly remains open
 for signature verification, alignment, message, and changes actions, but these
 actions retain their direct shortcuts while the group is closed. While expanded,
 the group visually contains every following status action through `<enter> diff`,
-including pane switching and navigation; quit remains outside it. The footer
+including pane switching and navigation; none of those hints is visible while
+the group is closed, and quit remains outside it. The footer
 underlines the `v` in `view`; while active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
-actions follow before movement, panning, and diff navigation shortcuts. Copy
+actions end at the information prefix while it is closed. Copy
 immediately follows the edit group; the reference toggle immediately precedes
 the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4f2d6ed242b..3e9a042f318 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -871,8 +871,9 @@ pub(crate) fn draw_with_worktree(
             edit_prefix_spans.push(Span::raw("dit"));
         }
     }
-    if app.tree_changes_visible || app.worktree_changes_visible {
-        footer_spans.push(match app.focus_feedback.take() {
+    let focus_feedback = app.focus_feedback.take();
+    if app.information_expanded && (app.tree_changes_visible || app.worktree_changes_visible) {
+        footer_spans.push(match focus_feedback {
             Some(destination) => Span::raw(format!(" · <tab> → {destination}")),
             None => Span::raw(" · <tab> switch"),
         });
@@ -957,11 +958,11 @@ pub(crate) fn draw_with_worktree(
     if app.changes_focus.is_none() && history_state == State::Loading {
         footer_spans.push(Span::raw(" · Esc cancel"));
     }
-    footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
-    if app.changes_focus.is_none() {
-        footer_spans.push(Span::raw(" · <enter> diff"));
-    }
     if app.information_expanded {
+        footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
+        if app.changes_focus.is_none() {
+            footer_spans.push(Span::raw(" · <enter> diff"));
+        }
         footer_spans.push(Span::raw(")"));
     }
     if app.changes_focus.is_none() {
@@ -2593,7 +2594,7 @@ mod tests {
             "todo commit metadata excludes separately represented refs"
         );
 
-        let footer_text = "#1 · view · edit · copy · refs · ? · ↑↓/jk move · h/l pan · <enter> diff · quit";
+        let footer_text = "#1 · view · edit · copy · refs · ? · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -3897,9 +3898,15 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&footer_terminal, 15)
-                .contains("? · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff · quit"),
-            "the collapsed information prefix leaves the following actions visible"
+            rendered_line(&footer_terminal, 15).contains("? · quit"),
+            "the collapsed information prefix is followed only by quit"
+        );
+        assert!(
+            !rendered_line(&footer_terminal, 15).contains("<tab> switch")
+                && !rendered_line(&footer_terminal, 15).contains("↑↓/jk move")
+                && !rendered_line(&footer_terminal, 15).contains("h/l pan")
+                && !rendered_line(&footer_terminal, 15).contains("<enter> diff"),
+            "information actions are hidden with their prefix"
         );
         app.information_expanded = true;
         footer_terminal.draw(|frame| {
@@ -3991,7 +3998,7 @@ mod tests {
             Color::Reset,
             "the main status keeps its original background"
         );
-        assert!(rendered_line(&terminal, 15).contains("<tab> switch"));
+        assert!(!rendered_line(&terminal, 15).contains("<tab> switch"));
 
         app.changes_suppressed = true;
         app.information_expanded = true;
@@ -4045,7 +4052,7 @@ mod tests {
                 && !terminal.backend().buffer()[(2, 15)].modifier.contains(Modifier::DIM),
             "the inactive history is dimmed without dimming the main status"
         );
-        assert!(rendered_line(&terminal, 15).contains("<tab> → tree changes"));
+        assert!(!rendered_line(&terminal, 15).contains("<tab> → tree changes"));
         assert!(rendered_line(&terminal, 15).contains("q/Esc history"));
         terminal.draw(|frame| {
             super::draw(
@@ -4057,10 +4064,7 @@ mod tests {
                 Some(&changes),
             );
         })?;
-        assert!(
-            rendered_line(&terminal, 15).contains("<tab> switch"),
-            "focus feedback lasts for one redraw"
-        );
+        assert!(!rendered_line(&terminal, 15).contains("<tab> switch"));
         assert!(
             !terminal.backend().buffer()[(added_x, 7)]
                 .modifier

From 471ce0cb13d7dd888013aa79f8d40bdaa447528f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 15:47:10 +0200
Subject: [PATCH 123/282] fix: detect repeated tix character navigation

The terminal enhancement requested repeat events, but printable `j` and `k` could still arrive through legacy character input without event types. Holding those keys therefore looked like isolated presses and recomputed the changes pane for every row.

Request escape-code reporting for all keys together with event types and disambiguation. Printable navigation now participates in the existing repeat suppression path, matching page keys and restoring responsive held-key scrolling.
---
 gix-tix/spec.md    |  3 ++-
 gix-tix/src/lib.rs | 26 ++++++++++++++++++++------
 2 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 843a43ce1c8..650497ed9a1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -300,7 +300,8 @@ space first; changes blocks adapt within the remaining history width.
   block shows its distinct status line.
 - `p` cycles the comparison parent while Tree has focus. Merge commits are
   compared to one parent at a time; root commits compare against an empty tree.
-- Repeated history keys and vertical mouse bursts temporarily hide changes
+- Repeated history keys, including printable `j`/`k` reported through enhanced
+  keyboard input, and vertical mouse bursts temporarily hide changes
   overlays. They return after 75 ms of navigation idle, with the same path
   selection and viewport where possible.
 - Tree diff results, detached diff resources, and line counts use a bounded MRU
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index db6c10e25e2..ee4f836faee 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -827,16 +827,17 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
 fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
     execute!(backend, EnableFocusChange, EnableMouseCapture)?;
     if enhanced_keyboard {
-        execute!(
-            backend,
-            PushKeyboardEnhancementFlags(
-                KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
-            )
-        )?;
+        execute!(backend, PushKeyboardEnhancementFlags(keyboard_enhancement_flags()))?;
     }
     Ok(())
 }
 
+fn keyboard_enhancement_flags() -> KeyboardEnhancementFlags {
+    KeyboardEnhancementFlags::DISAMBIGUATE_ESCAPE_CODES
+        | KeyboardEnhancementFlags::REPORT_EVENT_TYPES
+        | KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES
+}
+
 fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
     if enhanced_keyboard {
         execute!(backend, PopKeyboardEnhancementFlags)?;
@@ -5383,6 +5384,19 @@ mod tests {
         ));
     }
 
+    #[test]
+    fn enhanced_keyboard_reports_repeats_for_printable_navigation_keys() {
+        let flags = keyboard_enhancement_flags();
+        assert!(
+            flags.contains(KeyboardEnhancementFlags::REPORT_EVENT_TYPES),
+            "enhanced input distinguishes presses, repeats, and releases"
+        );
+        assert!(
+            flags.contains(KeyboardEnhancementFlags::REPORT_ALL_KEYS_AS_ESCAPE_CODES),
+            "printable j/k keys must use enhanced input for repeat events"
+        );
+    }
+
     #[test]
     fn key_releases_do_not_cancel_suspended_operations() {
         let key = |kind| TerminalEvent::Key(KeyEvent::new_with_kind(KeyCode::Char('t'), KeyModifiers::NONE, kind));

From 00b8841ae4ec47d3ec8fea36a059d9dda9a9af39 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 16:36:46 +0200
Subject: [PATCH 124/282] Share tix stash plumbing across edit workflows

Review time travel contained the complete Git stash and companion-ref lifecycle inline. Adding commit-associated stashes on a separate path would duplicate recovery, rollback, and warning behavior and let the two workflows drift.

Extract save, find, and apply operations into the edit stash module, including preservation of the ordinary stash stack and restoration after ref-creation failure. Keep review-specific naming at the caller while both workflows share the same transactional plumbing.
---
 gix-tix/src/edit/mod.rs         |   1 +
 gix-tix/src/edit/stash.rs       | 173 ++++++++++++++++++++++++++++++++
 gix-tix/src/edit/time_travel.rs | 166 +++++-------------------------
 3 files changed, 201 insertions(+), 139 deletions(-)
 create mode 100644 gix-tix/src/edit/stash.rs

diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index cdf16e78469..03b0ca31450 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -66,6 +66,7 @@ pub(crate) mod rebase;
 pub(crate) mod review;
 pub(crate) mod reword;
 pub(crate) mod split;
+pub(crate) mod stash;
 pub(crate) mod time_travel;
 pub(crate) mod todo;
 
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
new file mode 100644
index 00000000000..9490d40e804
--- /dev/null
+++ b/gix-tix/src/edit/stash.rs
@@ -0,0 +1,173 @@
+use std::{fmt::Write as _, path::Path, process::Command};
+
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::ByteSlice,
+    refs::{
+        Target,
+        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+    },
+};
+
+use crate::open_repository;
+
+#[derive(Clone)]
+pub(super) struct SavedStash {
+    pub name: gix::refs::FullName,
+    pub target: Target,
+    pub warning: Option<String>,
+}
+
+#[expect(clippy::too_many_arguments)]
+#[tracing::instrument(skip_all, fields(stash = %name))]
+pub(super) fn save(
+    repository_path: &Path,
+    bare: bool,
+    workdir: &Path,
+    name: gix::refs::FullName,
+    message: String,
+    reflog_message: &'static str,
+    state_label: &'static str,
+) -> Result<SavedStash> {
+    let repo = open_repository(repository_path, bare, false)
+        .with_context(|| format!("could not open repository to save {state_label}"))?;
+    if repo.try_find_reference(name.as_ref())?.is_some() {
+        anyhow::bail!("{state_label} is already saved");
+    }
+    let previous = repo
+        .try_find_reference("refs/stash")?
+        .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach));
+    drop(repo);
+
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["stash", "push", "--include-untracked", "--quiet", "--message"])
+        .arg(message)
+        .output()
+        .context("could not launch git stash push")?;
+    if !output.status.success() {
+        anyhow::bail!("git stash push failed: {}", output.stderr.trim().to_str_lossy());
+    }
+
+    let repo = open_repository(repository_path, bare, false).context("could not reopen repository after stashing")?;
+    let mut stash = repo
+        .try_find_reference("refs/stash")?
+        .context("git stash push did not create refs/stash")?;
+    let id = stash.peel_to_id()?.detach();
+    if previous == Some(id) {
+        anyhow::bail!("git stash push did not create a new stash");
+    }
+    let target = Target::Object(id);
+    if let Err(err) = repo.edit_references([RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: reflog_message.into(),
+            },
+            expected: PreviousValue::MustNotExist,
+            new: target.clone(),
+        },
+        name: name.clone(),
+        deref: false,
+    }]) {
+        drop(repo);
+        let restore = Command::new("git")
+            .arg("-C")
+            .arg(workdir)
+            .args(["stash", "pop", "--index", "--quiet"])
+            .output();
+        return Err(anyhow::anyhow!(err)).context(match restore {
+            Ok(output) if output.status.success() => {
+                format!("could not retain {state_label}; original state was restored")
+            }
+            Ok(output) => format!(
+                "could not retain {state_label} and git stash pop failed: {}",
+                output.stderr.trim().to_str_lossy()
+            ),
+            Err(restore) => {
+                format!("could not retain {state_label} and could not launch git stash pop: {restore}")
+            }
+        });
+    }
+    drop(repo);
+
+    let warning = match current(repository_path, bare)? {
+        Some(current) if current == id => {
+            let output = Command::new("git")
+                .arg("-C")
+                .arg(workdir)
+                .args(["stash", "drop", "--quiet", "stash@{0}"])
+                .output()
+                .context("could not launch git stash drop")?;
+            (!output.status.success()).then(|| {
+                format!(
+                    "{state_label} was saved, but its ordinary stash entry remains: {}",
+                    output.stderr.trim().to_str_lossy()
+                )
+            })
+        }
+        _ => Some(format!(
+            "{state_label} was saved, but refs/stash changed before its entry could be dropped"
+        )),
+    };
+    tracing::info!(stash = %name, %id, "saved worktree state");
+    Ok(SavedStash { name, target, warning })
+}
+
+fn current(repository_path: &Path, bare: bool) -> Result<Option<ObjectId>> {
+    let repo = open_repository(repository_path, bare, false).context("could not inspect refs/stash")?;
+    let Some(mut reference) = repo.try_find_reference("refs/stash")? else {
+        return Ok(None);
+    };
+    Ok(Some(reference.peel_to_id()?.detach()))
+}
+
+pub(super) fn find(repository_path: &Path, bare: bool, name: gix::refs::FullName) -> Result<Option<SavedStash>> {
+    let repo = open_repository(repository_path, bare, false).context("could not inspect saved worktree state")?;
+    let Some(reference) = repo.try_find_reference(name.as_ref())? else {
+        return Ok(None);
+    };
+    Ok(Some(SavedStash {
+        name,
+        target: reference.target().into_owned(),
+        warning: None,
+    }))
+}
+
+#[tracing::instrument(skip_all, fields(stash = %stash.name))]
+pub(super) fn apply(repository_path: &Path, bare: bool, workdir: &Path, stash: SavedStash) -> Result<String> {
+    let repo = open_repository(repository_path, bare, false)
+        .context("could not open repository before applying saved worktree state")?;
+    let output = Command::new("git")
+        .arg("-C")
+        .arg(workdir)
+        .args(["stash", "apply", "--index", "--quiet"])
+        .arg(stash.name.as_bstr().to_str_lossy().as_ref())
+        .output()
+        .context("could not launch git stash apply")?;
+    let deletion = repo.edit_references([RefEdit {
+        change: Change::Delete {
+            expected: PreviousValue::MustExistAndMatch(stash.target),
+            log: RefLog::AndReference,
+        },
+        name: stash.name.clone(),
+        deref: false,
+    }]);
+    let mut notice = if output.status.success() {
+        format!("restored {}", stash.name.shorten())
+    } else {
+        format!(
+            "{} restore needs attention: {}",
+            stash.name.shorten(),
+            output.stderr.trim().to_str_lossy()
+        )
+    };
+    if let Err(err) = deletion {
+        write!(notice, "; stash reference remains: {err}").expect("writing to a string cannot fail");
+    }
+    tracing::info!(stash = %stash.name, success = output.status.success(), "applied saved worktree state");
+    Ok(notice)
+}
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 7fd1286faf2..e8e2d68cbba 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -17,6 +17,9 @@ use gix::{
 
 use crate::{history, open_repository};
 
+#[cfg(test)]
+use super::stash::SavedStash;
+
 pub(crate) enum Perform {
     Complete(Option<String>),
     Conflict(Conflict),
@@ -336,161 +339,46 @@ fn review_tree(
     Ok(Some(ReviewTree { root, reference }))
 }
 
-#[derive(Clone)]
-struct SavedStash {
-    name: gix::refs::FullName,
-    target: Target,
-    warning: Option<String>,
-}
-
 #[tracing::instrument(skip_all, fields(review = %review.reference))]
 fn save_review_stash(
     repository_path: &Path,
     bare: bool,
     workdir: &Path,
     review: &ReviewTree,
-) -> Result<Option<SavedStash>> {
+) -> Result<Option<super::stash::SavedStash>> {
     if !super::review::is_dirty(workdir)? {
         return Ok(None);
     }
     let name = super::review::stash_reference(review.reference.as_bstr())?;
-    let repo =
-        open_repository(repository_path, bare, false).context("could not open repository to save review state")?;
-    if repo.try_find_reference(name.as_ref())?.is_some() {
-        anyhow::bail!("review {} already has saved worktree state", review.reference.shorten());
-    }
-    let previous = repo
-        .try_find_reference("refs/stash")?
-        .and_then(|mut reference| reference.peel_to_id().ok().map(gix::Id::detach));
-    drop(repo);
-
-    let output = Command::new("git")
-        .arg("-C")
-        .arg(workdir)
-        .args(["stash", "push", "--include-untracked", "--quiet", "--message"])
-        .arg(format!("tix review {}", review.reference.shorten()))
-        .output()
-        .context("could not launch git stash push")?;
-    if !output.status.success() {
-        anyhow::bail!("git stash push failed: {}", output.stderr.trim().to_str_lossy());
-    }
-
-    let repo = open_repository(repository_path, bare, false).context("could not reopen repository after stashing")?;
-    let mut stash = repo
-        .try_find_reference("refs/stash")?
-        .context("git stash push did not create refs/stash")?;
-    let id = stash.peel_to_id()?.detach();
-    if previous == Some(id) {
-        anyhow::bail!("git stash push did not create a new stash");
-    }
-    let target = Target::Object(id);
-    if let Err(err) = repo.edit_references([RefEdit {
-        change: Change::Update {
-            log: LogChange {
-                mode: RefLog::AndReference,
-                force_create_reflog: false,
-                message: "tix review auto-stash".into(),
-            },
-            expected: PreviousValue::MustNotExist,
-            new: target.clone(),
-        },
-        name: name.clone(),
-        deref: false,
-    }]) {
-        drop(repo);
-        let restore = Command::new("git")
-            .arg("-C")
-            .arg(workdir)
-            .args(["stash", "pop", "--index", "--quiet"])
-            .output();
-        return Err(anyhow::anyhow!(err)).context(match restore {
-            Ok(output) if output.status.success() => {
-                "could not retain review stash; original state was restored".to_owned()
-            }
-            Ok(output) => format!(
-                "could not retain review stash and git stash pop failed: {}",
-                output.stderr.trim().to_str_lossy()
-            ),
-            Err(restore) => format!("could not retain review stash and could not launch git stash pop: {restore}"),
-        });
-    }
-    drop(repo);
-
-    let warning = match current_stash(repository_path, bare)? {
-        Some(current) if current == id => {
-            let output = Command::new("git")
-                .arg("-C")
-                .arg(workdir)
-                .args(["stash", "drop", "--quiet", "stash@{0}"])
-                .output()
-                .context("could not launch git stash drop")?;
-            (!output.status.success()).then(|| {
-                format!(
-                    "review state was saved, but its ordinary stash entry remains: {}",
-                    output.stderr.trim().to_str_lossy()
-                )
-            })
-        }
-        _ => Some("review state was saved, but refs/stash changed before its entry could be dropped".to_owned()),
-    };
-    tracing::info!(review = %review.reference, stash = %name, %id, "saved review worktree state");
-    Ok(Some(SavedStash { name, target, warning }))
-}
-
-fn current_stash(repository_path: &Path, bare: bool) -> Result<Option<ObjectId>> {
-    let repo = open_repository(repository_path, bare, false).context("could not inspect refs/stash")?;
-    let Some(mut reference) = repo.try_find_reference("refs/stash")? else {
-        return Ok(None);
-    };
-    Ok(Some(reference.peel_to_id()?.detach()))
+    super::stash::save(
+        repository_path,
+        bare,
+        workdir,
+        name,
+        format!("tix review {}", review.reference.shorten()),
+        "tix review auto-stash",
+        "review state",
+    )
+    .map(Some)
 }
 
-fn find_review_stash(repository_path: &Path, bare: bool, review: &ReviewTree) -> Result<Option<SavedStash>> {
-    let repo = open_repository(repository_path, bare, false).context("could not inspect saved review state")?;
+fn find_review_stash(
+    repository_path: &Path,
+    bare: bool,
+    review: &ReviewTree,
+) -> Result<Option<super::stash::SavedStash>> {
     let name = super::review::stash_reference(review.reference.as_bstr())?;
-    let Some(reference) = repo.try_find_reference(name.as_ref())? else {
-        return Ok(None);
-    };
-    Ok(Some(SavedStash {
-        name,
-        target: reference.target().into_owned(),
-        warning: None,
-    }))
+    super::stash::find(repository_path, bare, name)
 }
 
 #[tracing::instrument(skip_all, fields(stash = %stash.name))]
-fn apply_review_stash(repository_path: &Path, bare: bool, workdir: &Path, stash: SavedStash) -> Result<String> {
-    let repo =
-        open_repository(repository_path, bare, false).context("could not open repository before applying stash")?;
-    let output = Command::new("git")
-        .arg("-C")
-        .arg(workdir)
-        .args(["stash", "apply", "--index", "--quiet"])
-        .arg(stash.name.as_bstr().to_str_lossy().as_ref())
-        .output()
-        .context("could not launch git stash apply")?;
-    let deletion = repo.edit_references([RefEdit {
-        change: Change::Delete {
-            expected: PreviousValue::MustExistAndMatch(stash.target),
-            log: RefLog::AndReference,
-        },
-        name: stash.name.clone(),
-        deref: false,
-    }]);
-    let mut notice = if output.status.success() {
-        format!("restored {}", stash.name.shorten())
-    } else {
-        format!(
-            "{} restore needs attention: {}",
-            stash.name.shorten(),
-            output.stderr.trim().to_str_lossy()
-        )
-    };
-    if let Err(err) = deletion {
-        write!(notice, "; stash reference remains: {err}").expect("writing to a string cannot fail");
-    }
-    tracing::info!(stash = %stash.name, success = output.status.success(), "applied review worktree state");
-    Ok(notice)
+fn apply_review_stash(
+    repository_path: &Path,
+    bare: bool,
+    workdir: &Path,
+    stash: super::stash::SavedStash,
+) -> Result<String> {
+    super::stash::apply(repository_path, bare, workdir, stash)
 }
 
 fn append_notice(notice: &mut Option<String>, addition: String) {

From c70376c6b3324e0164f671798323d27dc2f4e915 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 16:37:54 +0200
Subject: [PATCH 125/282] fix: keep tix resource markers visible in history

The pushpin was rendered as an ordinary reference decoration, so hiding refs also hid the evidence that a commit was preserving history. Resource state should not depend on the chosen ref-detail mode.

Render pin state immediately after the hash, outside the ordinary decoration list, while continuing to collapse multiple pins and hide their internal names. The marker now remains visible in every reference mode and has a stable position beside other commit resources.
---
 gix-tix/spec.md   |  4 +++-
 gix-tix/src/ui.rs | 35 +++++++++++++++++++++--------------
 2 files changed, 24 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 650497ed9a1..6187c2243e5 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -230,7 +230,9 @@ The Enter key is written as `<enter>` throughout.
   dangling, malformed, and non-commit pins do not
   enter the view or its decorations. Normal hidden-revision exclusions still apply.
 - One or more worktree pins at a commit are shown as a single blue `📌`
-  decoration; their internal names are omitted from history rows. `t` on a pinned
+  resource marker immediately after the hash and outside ordinary reference
+  decorations. It remains visible when references are hidden, and internal pin
+  names are omitted from history rows. `t` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 3e9a042f318..31745f9b6c9 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1670,9 +1670,15 @@ fn metadata_line<'a>(
         },
     )];
     let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
-    let mut pin_shown = false;
+    if row_decorations
+        .iter()
+        .any(|decoration| decoration.kind == DecorationKind::Pin)
+    {
+        spans.push(Span::styled(" 📌", decoration_style(DecorationKind::Pin)));
+    }
     let mut labels = row_decorations
         .iter()
+        .filter(|decoration| decoration.kind != DecorationKind::Pin)
         .filter(|decoration| match ref_mode {
             _ if decoration.kind == DecorationKind::Head => false,
             _ if decoration.kind == DecorationKind::Review => true,
@@ -1686,14 +1692,6 @@ fn metadata_line<'a>(
                     )
             }
         })
-        .filter(|decoration| {
-            if decoration.kind != DecorationKind::Pin {
-                return true;
-            }
-            let show = !pin_shown;
-            pin_shown = true;
-            show
-        })
         .peekable();
     if labels.peek().is_some() {
         spans.push(Span::raw(" ("));
@@ -1701,11 +1699,7 @@ fn metadata_line<'a>(
             if index != 0 {
                 spans.push(Span::raw(", "));
             }
-            let name = if decoration.kind == DecorationKind::Pin {
-                std::borrow::Cow::Borrowed("📌")
-            } else {
-                decoration.name.to_str_lossy()
-            };
+            let name = decoration.name.to_str_lossy();
             spans.push(Span::styled(
                 if matches!(
                     decoration.kind,
@@ -2836,6 +2830,19 @@ mod tests {
         assert!(row.contains("📌"), "a pinned commit has an obvious pin marker: {row:?}");
         assert_eq!(row.matches("📌").count(), 1, "multiple pins share one visual marker");
         assert!(!row.contains("pin:01010101"), "pin identities stay out of history rows");
+        let hash = row.find("0101010").expect("the row contains its hash");
+        let pin = row.find("📌").expect("the row contains its pin");
+        let date = row.find("1970-01-01").expect("the row contains its date");
+        assert!(
+            hash < pin && pin < date,
+            "the pin sits between the hash and metadata: {row:?}"
+        );
+        app.ref_mode = RefMode::None;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            rendered_row(&terminal).contains("📌"),
+            "hiding refs retains resource markers"
+        );
         assert!(
             rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return · unpin)"),
             "the active edit prefix contains exactly its actionable commands"

From 11c8f5bc5f181d5e32e2ab18e87aa06edfe88696 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 16:46:10 +0200
Subject: [PATCH 126/282] feat: stash worktree changes at tix commits

Time travel and review need a way to preserve staged, unstaged, and untracked work without surrendering the index layout or disturbing the ordinary Git stash stack.

Offer `stash` only from cached, unconflicted status at the selected `@`. Save through Git with untracked files, associate the result with the full commit ID, expose a persistent gift marker, and restore and consume that state when time travel returns, including when apply leaves conflicts for normal resolution.
---
 gix-tix/spec.md                 |  14 +++-
 gix-tix/src/app.rs              |  31 +++++++-
 gix-tix/src/edit/mod.rs         |   8 ++
 gix-tix/src/edit/stash.rs       | 131 ++++++++++++++++++++++++++++++++
 gix-tix/src/edit/time_travel.rs |  40 ++++++++++
 gix-tix/src/edit/todo.rs        |  26 ++++++-
 gix-tix/src/history.rs          |  53 +++++++++++++
 gix-tix/src/lib.rs              |  20 ++++-
 gix-tix/src/ui.rs               |  93 +++++++++++++++++++++--
 9 files changed, 404 insertions(+), 12 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6187c2243e5..ffc804c4b9c 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -258,6 +258,18 @@ The Enter key is written as `<enter>` throughout.
   --index` and always removes the companion ref after Git returns. Apply conflicts
   remain in the ordinary index/worktree conflict workflow. Nested trees use the
   nearest review-root ancestor.
+- When loaded worktree status shows staged, unstaged, or untracked changes without
+  conflicts, the edit menu offers `stas[h]` at the selected `@` entry. Missing or
+  stale worktree status hides the action instead of performing another status
+  query. Saving uses Git with `--include-untracked`, leaves ignored files alone,
+  preserves the ordinary stash stack, and records the stash commit at
+  `refs/tix/stash/<full-commit-id>`. A commit can retain only one such stash.
+- A commit stash is shown as a bright `🎁` beside any `📌`, directly after the
+  hash and outside reference visibility. Time travel back to that exact commit
+  restores it with `git stash apply --index` and consumes its companion ref after
+  Git returns, including when application leaves conflicts to resolve. Manual
+  commit stashes use the same plumbing during reviews, while automatic review
+  stashes retain their review-tree identity and namespace.
 
 ## Overlay views
 
@@ -682,7 +694,7 @@ space first; changes blocks adapt within the remaining history width.
 - `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base and
   `e u` rebases it onto the newer hidden branch tip when available,
   `e r` rewords, `e n` creates a rebased child, `e f` forks an independent child,
-  `e a` amends `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
+  `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   `e d d` confirms forgetting a top commit, and `e t` enters or returns from
   time travel when each action is available.
 - Edit shortcuts keep the group open. Navigation or another recognized command
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 0cc8471da68..80de7c24156 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -301,6 +301,7 @@ pub(crate) enum Action {
     NewEmptyCommit,
     ForkCommit,
     Amend,
+    Stash,
     Spill,
     Split,
     Forget,
@@ -334,6 +335,7 @@ pub(crate) enum Effect {
     },
     ForkCommit(ObjectId),
     Amend(ObjectId),
+    Stash(ObjectId),
     Spill(ObjectId),
     Split(ObjectId),
     Forget(ObjectId),
@@ -440,6 +442,7 @@ pub(crate) struct App {
     pending_rebase_conflict: Option<ObjectId>,
     worktree_conflicted: bool,
     amend_available: bool,
+    stash_available: bool,
     worktree_path_amend_available: bool,
     finish_review_available: bool,
     spill_available: bool,
@@ -528,6 +531,7 @@ impl App {
             pending_rebase_conflict: None,
             worktree_conflicted: false,
             amend_available: false,
+            stash_available: false,
             worktree_path_amend_available: false,
             finish_review_available: false,
             spill_available: false,
@@ -800,6 +804,7 @@ impl App {
                 | Action::NewEmptyCommit
                 | Action::ForkCommit
                 | Action::Amend
+                | Action::Stash
                 | Action::Spill
                 | Action::Split
                 | Action::Forget
@@ -1017,6 +1022,11 @@ impl App {
                     self.rows[self.selected.expect("amend requires a selection")].id,
                 )];
             }
+            Action::Stash if self.can_stash() => {
+                return vec![Effect::Stash(
+                    self.rows[self.selected.expect("stash requires a selection")].id,
+                )];
+            }
             Action::Spill if self.can_spill() => {
                 return vec![Effect::Spill(
                     self.rows[self.selected.expect("spill requires a selection")].id,
@@ -1730,6 +1740,19 @@ impl App {
             }
     }
 
+    pub(crate) fn can_stash(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && !self.worktree_conflicted
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.stash_available
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| !self.hidden_rows.contains(&row.id) && Some(row.id) == self.worktree_head)
+    }
+
     pub(crate) fn can_spill(&self) -> bool {
         self.can_edit_head() && matches!(self.changes_focus, None | Some(ChangePane::Tree)) && self.spill_available
     }
@@ -1741,12 +1764,14 @@ impl App {
     pub(crate) fn set_head_edit_availability(
         &mut self,
         amend: bool,
+        stash: bool,
         worktree_path_amend: bool,
         finish_review: bool,
         spill: bool,
         split: bool,
     ) {
         self.amend_available = amend;
+        self.stash_available = stash;
         self.worktree_path_amend_available = worktree_path_amend;
         self.finish_review_available = finish_review;
         self.spill_available = spill;
@@ -2524,15 +2549,16 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_head_edit_availability(true, true, false, true, false);
+        app.set_head_edit_availability(true, true, true, false, true, false);
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
+        assert_eq!(app.update(Action::Stash), vec![Effect::Stash(id(2))]);
         assert_eq!(app.update(Action::Spill), vec![Effect::Spill(id(2))]);
         assert!(
             app.update(Action::Split).is_empty(),
             "split needs both kinds of changes"
         );
-        app.set_head_edit_availability(true, true, false, true, true);
+        app.set_head_edit_availability(true, true, true, false, true, true);
         assert_eq!(app.update(Action::Split), vec![Effect::Split(id(2))]);
         app.changes_focus = Some(ChangePane::Tree);
         assert!(!app.can_amend(), "a tree path cannot be amended");
@@ -2552,6 +2578,7 @@ mod tests {
         app.changes_focus = None;
         app.update(Action::MoveDown);
         assert!(!app.can_amend());
+        assert!(!app.can_stash());
         assert!(app.update(Action::Amend).is_empty());
     }
 
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 03b0ca31450..74b0a9f1bf0 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -9,6 +9,14 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
     let mut revisions = Vec::new();
     for reference in repo.references()?.all()? {
         let reference = reference.map_err(|err| anyhow::anyhow!("could not read reference: {err}"))?;
+        if reference.name().as_bstr().starts_with(crate::history::STASH_PREFIX)
+            || reference
+                .name()
+                .as_bstr()
+                .starts_with(crate::history::REVIEW_STASH_PREFIX)
+        {
+            continue;
+        }
         let Some(id) = reference.try_id() else { continue };
         if reference.name().as_bstr() == b"HEAD"
             || repo
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
index 9490d40e804..b9fc2fb0dff 100644
--- a/gix-tix/src/edit/stash.rs
+++ b/gix-tix/src/edit/stash.rs
@@ -12,6 +12,63 @@ use gix::{
 
 use crate::open_repository;
 
+pub(crate) fn reference(id: ObjectId) -> Result<gix::refs::FullName> {
+    format!(
+        "{}{}",
+        String::from_utf8_lossy(crate::history::STASH_PREFIX),
+        id.to_hex()
+    )
+    .try_into()
+    .context("generated an invalid tix stash reference")
+}
+
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
+pub(crate) fn save_manual(repository_path: &Path, bare: bool, id: ObjectId) -> Result<String> {
+    let repo = open_repository(repository_path, bare, false).context("could not open repository to stash changes")?;
+    let workdir = repo
+        .workdir()
+        .context("stashing changes requires a worktree")?
+        .to_owned();
+    let head = repo
+        .head_id()
+        .context("stashing changes requires a born HEAD")?
+        .detach();
+    if head != id {
+        anyhow::bail!("changes can only be stashed at the current HEAD");
+    }
+    if repo
+        .index_or_empty()
+        .context("could not inspect the index before stashing")?
+        .entries()
+        .iter()
+        .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+    {
+        anyhow::bail!("cannot stash changes with unresolved index conflicts");
+    }
+    let name = reference(id)?;
+    if repo.try_find_reference(name.as_ref())?.is_some() {
+        anyhow::bail!("{} already has saved worktree state", id.to_hex_with_len(7));
+    }
+    drop(repo);
+    if !super::review::is_dirty(&workdir)? {
+        anyhow::bail!("there are no worktree or index changes to stash");
+    }
+    let saved = save(
+        repository_path,
+        bare,
+        &workdir,
+        name,
+        format!("tix {}", id.to_hex_with_len(7)),
+        "tix commit stash",
+        "commit state",
+    )?;
+    let mut notice = format!("stashed changes at {}", id.to_hex_with_len(7));
+    if let Some(warning) = saved.warning {
+        write!(notice, "; {warning}").expect("writing to a string cannot fail");
+    }
+    Ok(notice)
+}
+
 #[derive(Clone)]
 pub(super) struct SavedStash {
     pub name: gix::refs::FullName,
@@ -171,3 +228,77 @@ pub(super) fn apply(repository_path: &Path, bare: bool, workdir: &Path, stash: S
     tracing::info!(stash = %stash.name, success = output.status.success(), "applied saved worktree state");
     Ok(notice)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn manual_stashes_preserve_git_stashes_and_restore_index_and_worktree_state() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        git(fixture.path(), &["init", "-q", "-b", "main"])?;
+        git(fixture.path(), &["config", "user.name", "user"])?;
+        git(fixture.path(), &["config", "user.email", "user@example.com"])?;
+        std::fs::write(fixture.path().join("tracked"), "base\n")?;
+        std::fs::write(fixture.path().join(".gitignore"), "ignored\n")?;
+        git(fixture.path(), &["add", "."])?;
+        git(fixture.path(), &["-c", "commit.gpgSign=false", "commit", "-qm", "base"])?;
+        let head = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+
+        std::fs::write(fixture.path().join("ordinary"), "ordinary stash\n")?;
+        git(
+            fixture.path(),
+            &["stash", "push", "--include-untracked", "-qm", "ordinary"],
+        )?;
+        let ordinary = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "refs/stash"])?.trim())?;
+
+        std::fs::write(fixture.path().join("staged"), "staged\n")?;
+        git(fixture.path(), &["add", "staged"])?;
+        std::fs::write(fixture.path().join("tracked"), "unstaged\n")?;
+        std::fs::write(fixture.path().join("untracked"), "untracked\n")?;
+        std::fs::write(fixture.path().join("ignored"), "ignored\n")?;
+
+        let repo = crate::open_test_repository(fixture.path())?;
+        let repository_path = repo.git_dir().to_owned();
+        drop(repo);
+        let notice = save_manual(&repository_path, false, head)?;
+        assert!(notice.contains("stashed changes"));
+
+        let repo = crate::open_test_repository(fixture.path())?;
+        assert_eq!(repo.find_reference("refs/stash")?.id().detach(), ordinary);
+        let name = reference(head)?;
+        assert!(repo.try_find_reference(name.as_ref())?.is_some());
+        assert!(
+            git(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty(),
+            "the tracked and untracked changes were stashed"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("ignored"))?, b"ignored\n");
+        drop(repo);
+
+        let saved = find(&repository_path, false, name.clone())?.expect("the manual stash exists");
+        apply(&repository_path, false, fixture.path(), saved)?;
+        assert_eq!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.trim(),
+            b"staged"
+        );
+        assert_eq!(git(fixture.path(), &["diff", "--name-only"])?.trim(), b"tracked");
+        assert_eq!(std::fs::read(fixture.path().join("untracked"))?, b"untracked\n");
+        let repo = crate::open_test_repository(fixture.path())?;
+        assert!(repo.try_find_reference(name.as_ref())?.is_none());
+        assert_eq!(repo.find_reference("refs/stash")?.id().detach(), ordinary);
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index e8e2d68cbba..21967208e99 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -309,6 +309,12 @@ pub(crate) fn perform(
     {
         append_notice(&mut notice, apply_review_stash(repository_path, bare, &workdir, stash)?);
     }
+    if let Some(stash) = super::stash::find(repository_path, bare, super::stash::reference(selected)?)? {
+        append_notice(
+            &mut notice,
+            super::stash::apply(repository_path, bare, &workdir, stash)?,
+        );
+    }
     Ok(Perform::Complete(notice))
 }
 
@@ -939,6 +945,40 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn returning_to_a_commit_restores_its_manual_stash() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let head = repository.head_id()?.detach();
+        let parent = repository
+            .find_commit(head)?
+            .parent_ids()
+            .next()
+            .context("the history fixture has a parent")?
+            .detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        std::fs::write(fixture.path().join("manual-stash"), "saved\n")?;
+        super::super::stash::save_manual(&repository_path, false, head)?;
+        perform(&repository_path, false, parent, &graph, &[], &[], false)?.complete()?;
+        assert!(
+            !fixture.path().join("manual-stash").exists(),
+            "leaving the stashed commit keeps its worktree clean"
+        );
+
+        perform(&repository_path, false, head, &graph, &[], &[], false)?.complete()?;
+        assert_eq!(std::fs::read(fixture.path().join("manual-stash"))?, b"saved\n");
+        assert!(
+            crate::open_test_repository(fixture.path())?
+                .try_find_reference(super::super::stash::reference(head)?.as_ref())?
+                .is_none(),
+            "returning consumes the manual stash association"
+        );
+        Ok(())
+    }
+
     #[test]
     fn removes_every_pin_at_the_selected_commit() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 15b046f5154..04a6b42abc5 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -24,7 +24,7 @@ const HELP: &str = r#"
 - Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
-- Commit states are display-only: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, and `○` means unsigned.
+- Commit states are display-only and editing them has no effect: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, `○` means unsigned, and `🎁` means worktree state is stashed for that commit. Stashes follow rewritten commits automatically; dropping a stashed commit or combining multiple stashes into one result is rejected.
 -->
 "#;
 
@@ -477,7 +477,10 @@ fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
             signature = true;
         }
     }
-    let mut out = Vec::with_capacity(3);
+    let stashed = repo
+        .try_find_reference(super::stash::reference(id)?.as_ref())?
+        .is_some();
+    let mut out = Vec::with_capacity(4);
     if pending {
         out.push("↻");
     }
@@ -490,6 +493,9 @@ fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
     if !empty_signature && !signature {
         out.push("○");
     }
+    if stashed {
+        out.push("🎁");
+    }
     Ok(format!("{} ", out.join(" ")))
 }
 
@@ -1182,7 +1188,13 @@ mod tests {
     #[test]
     fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
-        let (base, _middle, tip, commits) = commits(&repo)?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        repo.reference(
+            super::super::stash::reference(middle)?,
+            tip,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test todo stash marker",
+        )?;
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         assert!(!prepared.apply_unchanged);
         let document = String::from_utf8(prepared.document.clone())?;
@@ -1214,6 +1226,14 @@ mod tests {
             document.contains("○"),
             "unsigned commits carry the documented status symbol"
         );
+        assert!(
+            document.contains("🎁"),
+            "stashed commits carry a display-only gift marker"
+        );
+        let mut edited_symbols = document.clone();
+        let marker = edited_symbols.find("🎁").expect("the command carries a stash marker");
+        edited_symbols.replace_range(marker..marker + "🎁".len(), "changed-state");
+        parse_plan(&repo, edited_symbols.as_bytes())?;
         let plan = parse_plan(&repo, &prepared.document)?;
         assert_eq!(
             plan.checkout.as_ref().and_then(|checkout| checkout.reference.as_ref()),
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 6f5e70d3737..2fe9f3accd5 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -30,6 +30,7 @@ pub(crate) struct Decoration {
 pub(crate) enum DecorationKind {
     Head,
     Pin,
+    Stash,
     Review,
     CurrentWorktreeBranch,
     WorktreeBranch,
@@ -44,6 +45,7 @@ pub(crate) enum DecorationKind {
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
 pub(crate) const PIN_PREFIX: &[u8] = b"refs/worktree/tix/pins/";
+pub(crate) const STASH_PREFIX: &[u8] = b"refs/tix/stash/";
 pub(crate) const REVIEW_PREFIX: &[u8] = b"refs/worktree/tix/review/";
 pub(crate) const REVIEW_STASH_PREFIX: &[u8] = b"refs/worktree/tix/review/stashes/";
 
@@ -1619,6 +1621,20 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         if full_name.as_bstr().starts_with(REVIEW_STASH_PREFIX) {
             continue;
         }
+        if let Some(suffix) = full_name.as_bstr().strip_prefix(STASH_PREFIX) {
+            let id = match ObjectId::from_hex(suffix) {
+                Ok(id) if id.to_hex().to_string().as_bytes() == suffix => id,
+                _ => {
+                    tracing::warn!(name = %full_name, "ignored malformed tix stash reference");
+                    continue;
+                }
+            };
+            out.entry(id).or_default().push(Decoration {
+                name: "stash".into(),
+                kind: DecorationKind::Stash,
+            });
+            continue;
+        }
         let pin_suffix = full_name.as_bstr().strip_prefix(PIN_PREFIX).map(BString::from);
         let review_suffix = review_number(full_name.as_bstr()).map(BString::from);
         if pin_suffix.is_some() && !pins.contains(full_name.as_bstr()) {
@@ -1715,6 +1731,8 @@ fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
 fn decoration_kind(name: &[u8]) -> DecorationKind {
     if name.starts_with(PIN_PREFIX) {
         DecorationKind::Pin
+    } else if name.starts_with(STASH_PREFIX) {
+        DecorationKind::Stash
     } else if name.starts_with(REVIEW_PREFIX) {
         DecorationKind::Review
     } else if name.starts_with(b"refs/heads/") {
@@ -2408,6 +2426,10 @@ mod tests {
     #[test]
     fn classifies_reference_kinds() {
         assert_eq!(decoration_kind(b"refs/worktree/tix/pins/abcd"), DecorationKind::Pin);
+        assert_eq!(
+            decoration_kind(b"refs/tix/stash/0123456789012345678901234567890123456789"),
+            DecorationKind::Stash
+        );
         assert_eq!(decoration_kind(b"refs/worktree/tix/review/1"), DecorationKind::Review);
         assert_eq!(decoration_kind(b"refs/heads/main"), DecorationKind::Local);
         assert_eq!(decoration_kind(b"refs/tags/v1"), DecorationKind::Tag);
@@ -2470,6 +2492,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn commit_stashes_decorate_the_associated_commit_without_becoming_tips() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::open_test_repository(fixture.path())?;
+        let head = repo.head_id()?.detach();
+        let stash = repo.rev_parse_single("topic")?.detach();
+        let name = super::super::edit::stash::reference(head)?;
+        repo.reference(
+            name,
+            stash,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test commit stash",
+        )?;
+
+        assert!(!snapshot(&repo, &[], &[], false)?.view_tips.contains(&stash));
+        let decorations = decorations(&repo, &[], &worktree_checkouts(&repo))?;
+        assert!(
+            decorations.get(&head).is_some_and(|decorations| decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Stash)),
+            "the ref-name suffix associates the stash with HEAD"
+        );
+        assert!(
+            decorations.get(&stash).is_none_or(|decorations| decorations
+                .iter()
+                .all(|decoration| decoration.kind != DecorationKind::Stash)),
+            "the stash object itself is not decorated"
+        );
+        Ok(())
+    }
+
     #[test]
     fn pins_are_private_to_the_current_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index ee4f836faee..d78aa827688 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2077,6 +2077,19 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("{verb}: {err:#}")),
                     }
                 }
+                Effect::Stash(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit::stash::save_manual(&repository_path, repository_is_bare, id) {
+                        Ok(notice) => {
+                            app.leave_message(notice);
+                            app.select_commit_after_refresh(id);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_message(format!("stash: {err:#}")),
+                    }
+                }
                 Effect::Forget(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2789,7 +2802,10 @@ fn draw(
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
     let tree_changes = tree_changes.as_ref().map(|(_, changes)| changes);
-    let worktree_changes = worktree_changes.as_ref().map(|(_, changes)| changes);
+    let worktree_changes = worktree_changes
+        .as_ref()
+        .filter(|(marker, _)| *marker != usize::MAX)
+        .map(|(_, changes)| changes);
     terminal
         .autoresize()
         .context("could not resize the terminal before drawing")?;
@@ -4263,6 +4279,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
         KeyCode::Down | KeyCode::Char('j') => Some(Action::MoveDown),
+        KeyCode::Char('h') if edit_expanded => Some(Action::Stash),
         KeyCode::Char('h') if history_display_expanded => Some(Action::ToggleHidden),
         KeyCode::Char('h') => Some(Action::ScrollLeft),
         KeyCode::Char('l') => Some(Action::ScrollRight),
@@ -5296,6 +5313,7 @@ mod tests {
             ('m', Action::NewEmptyCommit),
             ('f', Action::ForkCommit),
             ('a', Action::Amend),
+            ('h', Action::Stash),
             ('s', Action::Spill),
             ('p', Action::Split),
             ('d', Action::Forget),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 31745f9b6c9..1504c99efa2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -307,6 +307,16 @@ pub(crate) fn draw_with_worktree(
         .selected
         .and_then(|index| app.rows.get(index))
         .is_some_and(|row| row.is_review);
+    let selected_has_stash = app
+        .selected
+        .and_then(|index| app.rows.get(index))
+        .and_then(|row| decorations.get(&row.id))
+        .is_some_and(|refs| refs.iter().any(|reference| reference.kind == DecorationKind::Stash));
+    let stashable = selected_is_head
+        && !selected_has_stash
+        && worktree_changes.is_some_and(|changes| {
+            !changes.paths.is_empty() && !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
+        });
     let worktree_path_amend = worktree_changes.is_some_and(|changes| {
         !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
             && changes
@@ -323,6 +333,7 @@ pub(crate) fn draw_with_worktree(
                     !changes.paths.is_empty()
                 }
             }),
+        stashable,
         selected_is_head && worktree_path_amend,
         selected_is_head && selected_is_review && worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
@@ -820,6 +831,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_amend() {
                 options.push(("amend", 'a'));
             }
+            if app.can_stash() {
+                options.push(("stash", 'h'));
+            }
             if app.can_spill() {
                 options.push(("spill", 's'));
             }
@@ -1676,9 +1690,23 @@ fn metadata_line<'a>(
     {
         spans.push(Span::styled(" 📌", decoration_style(DecorationKind::Pin)));
     }
+    if row_decorations
+        .iter()
+        .any(|decoration| decoration.kind == DecorationKind::Stash)
+    {
+        let marker = if row_decorations
+            .iter()
+            .any(|decoration| decoration.kind == DecorationKind::Pin)
+        {
+            "🎁"
+        } else {
+            " 🎁"
+        };
+        spans.push(Span::styled(marker, decoration_style(DecorationKind::Stash)));
+    }
     let mut labels = row_decorations
         .iter()
-        .filter(|decoration| decoration.kind != DecorationKind::Pin)
+        .filter(|decoration| !matches!(decoration.kind, DecorationKind::Pin | DecorationKind::Stash))
         .filter(|decoration| match ref_mode {
             _ if decoration.kind == DecorationKind::Head => false,
             _ if decoration.kind == DecorationKind::Review => true,
@@ -1881,6 +1909,7 @@ fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
+        DecorationKind::Stash => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::Review => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::CurrentWorktreeBranch => Style::default().fg(Color::Cyan),
         DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => Style::default().fg(Color::LightBlue),
@@ -2813,6 +2842,10 @@ mod tests {
                         name: "pin:01010102".into(),
                         kind: DecorationKind::Pin,
                     },
+                    Decoration {
+                        name: "stash".into(),
+                        kind: DecorationKind::Stash,
+                    },
                 ],
             ),
             (
@@ -2832,16 +2865,22 @@ mod tests {
         assert!(!row.contains("pin:01010101"), "pin identities stay out of history rows");
         let hash = row.find("0101010").expect("the row contains its hash");
         let pin = row.find("📌").expect("the row contains its pin");
+        let gift = row.find("🎁").expect("the row contains its stash marker");
         let date = row.find("1970-01-01").expect("the row contains its date");
+        assert!(
+            pin < gift && gift < date,
+            "resource markers form one compact group: {row:?}"
+        );
         assert!(
             hash < pin && pin < date,
             "the pin sits between the hash and metadata: {row:?}"
         );
         app.ref_mode = RefMode::None;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let row = rendered_row(&terminal);
         assert!(
-            rendered_row(&terminal).contains("📌"),
-            "hiding refs retains resource markers"
+            row.contains("📌") && row.contains("🎁"),
+            "hiding refs retains resource markers: {row:?}"
         );
         assert!(
             rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return · unpin)"),
@@ -2933,7 +2972,7 @@ mod tests {
             }],
             ..Changes::default()
         };
-        let decorations = Decorations::from([(
+        let mut decorations = Decorations::from([(
             id,
             vec![Decoration {
                 name: "HEAD".into(),
@@ -2969,7 +3008,7 @@ mod tests {
             }],
             ..Changes::default()
         };
-        app.set_head_edit_availability(true, true, false, false, false);
+        app.set_head_edit_availability(true, false, true, false, false, false);
         assert!(app.can_amend(), "the focused worktree path is amendable");
         assert!(app.edit_expanded, "the edit prefix remains expanded");
         terminal.draw(|frame| {
@@ -2992,6 +3031,50 @@ mod tests {
         );
         assert!(!footer.contains("spill"), "worktree paths cannot be spilled");
 
+        app.changes_focus = None;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&worktree),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 7).contains("stash"),
+            "loaded unconflicted worktree changes offer stashing"
+        );
+        decorations
+            .get_mut(&id)
+            .expect("HEAD has decorations")
+            .push(Decoration {
+                name: "stash".into(),
+                kind: DecorationKind::Stash,
+            });
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&worktree),
+            );
+        })?;
+        assert!(
+            !rendered_line(&terminal, 7).contains("stash"),
+            "an existing commit stash suppresses another save action"
+        );
+        decorations
+            .get_mut(&id)
+            .expect("HEAD has decorations")
+            .retain(|decoration| decoration.kind != DecorationKind::Stash);
+        app.changes_focus = Some(ChangePane::Worktree);
+
         std::sync::Arc::make_mut(&mut app.rows[0]).is_review = true;
         terminal.draw(|frame| {
             super::draw_with_worktree(

From 046c664363c22eb286237f13bc6ae8e694fd64c8 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 16:53:05 +0200
Subject: [PATCH 127/282] fix: retain tix stashes across commit rewrites

A commit stash is associated through the commit ID embedded in its ref name. Rewording or rebasing that commit otherwise orphaned the saved state under an ID that history no longer displayed.

Prepare stash-ref moves from the rewrite map and include their forward and rollback edits in the same reference transaction as the history update. Reject drops, converging associations, malformed IDs, and occupied destinations before prepared objects or refs become observable.
---
 gix-tix/spec.md            |   4 ++
 gix-tix/src/edit/rebase.rs |  92 ++++++++++++++++++++++++++++-
 gix-tix/src/edit/stash.rs  | 117 ++++++++++++++++++++++++++++++++++++-
 gix-tix/src/history.rs     |  11 ++--
 4 files changed, 214 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ffc804c4b9c..08cf8769368 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -270,6 +270,10 @@ The Enter key is written as `<enter>` throughout.
   Git returns, including when application leaves conflicts to resolve. Manual
   commit stashes use the same plumbing during reviews, while automatic review
   stashes retain their review-tree identity and namespace.
+- Rewriting a commit atomically renames its commit-stash association alongside
+  other reference updates. Dropping a stashed commit, converging multiple stashes
+  onto one result, or overwriting an existing destination stash is rejected before
+  prepared objects or references are persisted.
 
 ## Overlay views
 
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 5275efcf490..6d75fe89f6c 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -364,6 +364,8 @@ struct Prepared {
     skip_worktree_transitions: bool,
     selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
+    stash_rewritten: HashMap<ObjectId, Option<ObjectId>>,
+    removed: HashSet<ObjectId>,
     committer: gix::actor::Signature,
     expected_refs: Option<Vec<ExpectedRef>>,
     checkout_reference: Option<gix::refs::FullName>,
@@ -643,7 +645,13 @@ fn perform_inner(
             || forked
             || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
         selected,
+        stash_rewritten: rewritten.clone(),
         rewritten,
+        removed: if removed {
+            root.into_iter().collect()
+        } else {
+            HashSet::new()
+        },
         committer,
         expected_refs: None,
         checkout_reference: None,
@@ -791,7 +799,9 @@ pub(super) fn finish_review(
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected: Some(finished_review),
+        stash_rewritten: rewritten.clone(),
         rewritten,
+        removed: HashSet::new(),
         committer,
         expected_refs: None,
         checkout_reference: None,
@@ -1038,6 +1048,7 @@ pub(crate) fn perform_plan_with_progress(
     }
 
     let dropped: Vec<_> = plan.scope.iter().copied().filter(|id| !picked.contains(id)).collect();
+    let removed: HashSet<_> = dropped.iter().copied().collect();
     for id in &dropped {
         let commit = repo.find_commit(*id)?.decode()?.into_owned()?;
         delete_refs.extend(super::review::deletions(&repo, &commit)?);
@@ -1134,6 +1145,8 @@ pub(crate) fn perform_plan_with_progress(
         skip_worktree_transitions: false,
         selected,
         rewritten: rewritten.clone(),
+        stash_rewritten: rewritten.clone(),
+        removed,
         committer,
         expected_refs: Some(plan.expected_refs.clone()),
         checkout_reference: plan.checkout.as_ref().and_then(|checkout| checkout.reference.clone()),
@@ -1206,6 +1219,7 @@ pub(crate) fn perform_plan_with_progress(
 
 impl Prepared {
     fn finish(&mut self) -> Result<Outcome> {
+        let stash_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
         let objects = self
             .repo
             .objects
@@ -1261,6 +1275,7 @@ impl Prepared {
             &self.committer,
             self.expected_refs.take(),
             (&self.pins, &self.delete_refs),
+            stash_edits,
         )?;
         for (transitioned, transition) in transitions.iter().enumerate() {
             if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
@@ -1801,6 +1816,7 @@ fn worktree_transitions(
     Ok(out)
 }
 
+#[expect(clippy::too_many_arguments)]
 fn update_refs(
     repo: &gix::Repository,
     rewritten: &HashMap<ObjectId, Option<ObjectId>>,
@@ -1809,10 +1825,11 @@ fn update_refs(
     committer: &gix::actor::Signature,
     expected_refs: Option<Vec<ExpectedRef>>,
     resources: (&[ObjectId], &[(gix::refs::FullName, Target)]),
+    stash_edits: super::stash::RewriteEdits,
 ) -> Result<Vec<RefEdit>> {
     let (pins, delete_refs) = resources;
-    let mut edits = Vec::new();
-    let mut rollback = Vec::new();
+    let mut edits = stash_edits.forward;
+    let mut rollback = stash_edits.rollback;
     if let Some(expected_refs) = expected_refs {
         for ExpectedRef { name, old, new, .. } in expected_refs {
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
@@ -2066,6 +2083,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn rewriting_a_stashed_commit_moves_its_stash_association() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let saved = repo.write_blob(b"saved worktree state")?.detach();
+        let old_name = super::super::stash::reference(middle)?;
+        repo.reference(old_name.clone(), saved, PreviousValue::MustNotExist, "test stash")?;
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.message = "rewritten middle".into();
+
+        let outcome = perform(
+            &repo,
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIs,
+        )?
+        .complete()?;
+        let rewritten = outcome.map(middle).expect("the stashed commit is retained");
+        let new_name = super::super::stash::reference(rewritten)?;
+        assert!(repo.try_find_reference(old_name.as_ref())?.is_none());
+        assert_eq!(
+            repo.find_reference(new_name.as_ref())?.id().detach(),
+            saved,
+            "the saved state follows the rewritten commit without changing its target"
+        );
+        Ok(())
+    }
+
     #[test]
     fn removes_a_middle_commit_by_cherry_picking_its_descendant() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -3064,6 +3112,46 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn dropping_a_stashed_commit_is_rejected_before_refs_change() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let saved = repo.write_blob(b"saved worktree state")?.detach();
+        let name = super::super::stash::reference(middle)?;
+        repo.reference(name.clone(), saved, PreviousValue::MustNotExist, "test stash")?;
+
+        let err = match perform_plan(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![middle, tip],
+                steps: vec![PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(tip),
+                    squash: Vec::new(),
+                }],
+                checkout: None,
+                expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+            },
+        ) {
+            Ok(_) => panic!("dropping a commit with saved state must fail before producing an outcome"),
+            Err(err) => err,
+        };
+        assert!(err.to_string().contains("cannot drop stashed commit"));
+        assert_eq!(repo.head_id()?.detach(), tip, "HEAD remains at the original tip");
+        assert_eq!(
+            repo.find_reference(name.as_ref())?.id().detach(),
+            saved,
+            "the stash association remains unchanged"
+        );
+        Ok(())
+    }
+
     #[test]
     fn dropping_a_review_commit_removes_all_review_resources() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
index b9fc2fb0dff..94e26c449b1 100644
--- a/gix-tix/src/edit/stash.rs
+++ b/gix-tix/src/edit/stash.rs
@@ -1,9 +1,14 @@
-use std::{fmt::Write as _, path::Path, process::Command};
+use std::{
+    collections::{HashMap, HashSet},
+    fmt::Write as _,
+    path::Path,
+    process::Command,
+};
 
 use anyhow::{Context, Result};
 use gix::{
     ObjectId,
-    bstr::ByteSlice,
+    bstr::{BStr, ByteSlice},
     refs::{
         Target,
         transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
@@ -22,6 +27,113 @@ pub(crate) fn reference(id: ObjectId) -> Result<gix::refs::FullName> {
     .context("generated an invalid tix stash reference")
 }
 
+pub(crate) fn associated_commit(name: &BStr) -> Result<Option<ObjectId>> {
+    let Some(suffix) = name.strip_prefix(crate::history::STASH_PREFIX) else {
+        return Ok(None);
+    };
+    let id = ObjectId::from_hex(suffix).context("tix stash reference has an invalid commit ID")?;
+    if id.to_hex().to_string().as_bytes() != suffix {
+        anyhow::bail!("tix stash reference does not use a canonical full commit ID");
+    }
+    Ok(Some(id))
+}
+
+pub(super) struct RewriteEdits {
+    pub forward: Vec<RefEdit>,
+    pub rollback: Vec<RefEdit>,
+}
+
+pub(super) fn rewrite_edits(
+    repo: &gix::Repository,
+    rewritten: &HashMap<ObjectId, Option<ObjectId>>,
+    removed: &HashSet<ObjectId>,
+) -> Result<RewriteEdits> {
+    let mut moves = Vec::new();
+    let mut destinations = HashMap::<ObjectId, ObjectId>::new();
+    for reference in repo.references()?.all()? {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) => {
+                return Err(anyhow::anyhow!(
+                    "could not inspect a stash reference before rebasing: {err}"
+                ));
+            }
+        };
+        let old = match associated_commit(reference.name().as_bstr()) {
+            Ok(Some(id)) => id,
+            Ok(None) => continue,
+            Err(err) => {
+                tracing::warn!(name = %reference.name(), error = %err, "ignored malformed tix stash reference");
+                continue;
+            }
+        };
+        let Some(new) = rewritten.get(&old).copied() else {
+            continue;
+        };
+        if removed.contains(&old) {
+            anyhow::bail!("cannot drop stashed commit {}", old.to_hex_with_len(7));
+        }
+        let new = new.context("a stashed commit cannot disappear during a rewrite")?;
+        if new == old {
+            continue;
+        }
+        if let Some(other) = destinations.insert(new, old) {
+            anyhow::bail!(
+                "stashes at {} and {} would converge on {}",
+                other.to_hex_with_len(7),
+                old.to_hex_with_len(7),
+                new.to_hex_with_len(7)
+            );
+        }
+        moves.push((reference.name().to_owned(), reference.target().into_owned(), old, new));
+    }
+
+    let mut forward = Vec::with_capacity(moves.len() * 2);
+    let mut rollback = Vec::with_capacity(moves.len() * 2);
+    for (old_name, target, old, new) in moves {
+        let new_name = reference(new)?;
+        if repo.try_find_reference(new_name.as_ref())?.is_some() {
+            anyhow::bail!(
+                "rewritten commit {} already has saved worktree state",
+                new.to_hex_with_len(7)
+            );
+        }
+        forward.push(delete_edit(old_name.clone(), target.clone()));
+        forward.push(create_edit(new_name.clone(), target.clone()));
+        rollback.push(delete_edit(new_name, target.clone()));
+        rollback.push(create_edit(old_name, target));
+        tracing::debug!(old = %old, new = %new, "prepared tix stash association rewrite");
+    }
+    Ok(RewriteEdits { forward, rollback })
+}
+
+fn create_edit(name: gix::refs::FullName, target: Target) -> RefEdit {
+    RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: "tix commit stash rewrite".into(),
+            },
+            expected: PreviousValue::MustNotExist,
+            new: target,
+        },
+        name,
+        deref: false,
+    }
+}
+
+fn delete_edit(name: gix::refs::FullName, target: Target) -> RefEdit {
+    RefEdit {
+        change: Change::Delete {
+            expected: PreviousValue::MustExistAndMatch(target),
+            log: RefLog::AndReference,
+        },
+        name,
+        deref: false,
+    }
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn save_manual(repository_path: &Path, bare: bool, id: ObjectId) -> Result<String> {
     let repo = open_repository(repository_path, bare, false).context("could not open repository to stash changes")?;
@@ -76,7 +188,6 @@ pub(super) struct SavedStash {
     pub warning: Option<String>,
 }
 
-#[expect(clippy::too_many_arguments)]
 #[tracing::instrument(skip_all, fields(stash = %name))]
 pub(super) fn save(
     repository_path: &Path,
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 2fe9f3accd5..3f8cdab6689 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1621,11 +1621,12 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         if full_name.as_bstr().starts_with(REVIEW_STASH_PREFIX) {
             continue;
         }
-        if let Some(suffix) = full_name.as_bstr().strip_prefix(STASH_PREFIX) {
-            let id = match ObjectId::from_hex(suffix) {
-                Ok(id) if id.to_hex().to_string().as_bytes() == suffix => id,
-                _ => {
-                    tracing::warn!(name = %full_name, "ignored malformed tix stash reference");
+        if full_name.as_bstr().starts_with(STASH_PREFIX) {
+            let id = match crate::edit::stash::associated_commit(full_name.as_bstr()) {
+                Ok(Some(id)) => id,
+                Ok(None) => unreachable!("the stash prefix was checked"),
+                Err(err) => {
+                    tracing::warn!(name = %full_name, error = %err, "ignored malformed tix stash reference");
                     continue;
                 }
             };

From 3091f5c6a0024845e17fb84cf9eb1db022a73ff6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 17:10:59 +0200
Subject: [PATCH 128/282] feat: restore tix commit stashes in place

Commit-associated worktree state was restored automatically only after travelling away and back. A user who chose to remain at the commit had no symmetric way to recover that state, particularly after deciding not to travel.

Offer `unstash` on the selected `@` whenever a commit stash exists, even alongside unrelated worktree changes. Restore through the same indexed apply path used by time travel, consume the companion ref, retain unrelated changes, and refresh cached status.
---
 gix-tix/spec.md           |  3 +++
 gix-tix/src/app.rs        | 32 ++++++++++++++++++++++++++++++--
 gix-tix/src/edit/stash.rs | 30 ++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs        | 13 +++++++++++++
 gix-tix/src/ui.rs         |  9 ++++++---
 5 files changed, 80 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 08cf8769368..7c4a74c4182 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -270,6 +270,9 @@ The Enter key is written as `<enter>` throughout.
   Git returns, including when application leaves conflicts to resolve. Manual
   commit stashes use the same plumbing during reviews, while automatic review
   stashes retain their review-tree identity and namespace.
+- At a selected `@` with a commit stash, the edit menu offers `unstas[h]` even
+  when other worktree changes are present. It applies and consumes the stash in
+  place through the same path used when time travel returns to that commit.
 - Rewriting a commit atomically renames its commit-stash association alongside
   other reference updates. Dropping a stashed commit, converging multiple stashes
   onto one result, or overwriting an existing destination stash is rejected before
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 80de7c24156..b1dd9e21b87 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -336,6 +336,7 @@ pub(crate) enum Effect {
     ForkCommit(ObjectId),
     Amend(ObjectId),
     Stash(ObjectId),
+    Unstash(ObjectId),
     Spill(ObjectId),
     Split(ObjectId),
     Forget(ObjectId),
@@ -443,6 +444,7 @@ pub(crate) struct App {
     worktree_conflicted: bool,
     amend_available: bool,
     stash_available: bool,
+    unstash_available: bool,
     worktree_path_amend_available: bool,
     finish_review_available: bool,
     spill_available: bool,
@@ -532,6 +534,7 @@ impl App {
             worktree_conflicted: false,
             amend_available: false,
             stash_available: false,
+            unstash_available: false,
             worktree_path_amend_available: false,
             finish_review_available: false,
             spill_available: false,
@@ -1022,6 +1025,11 @@ impl App {
                     self.rows[self.selected.expect("amend requires a selection")].id,
                 )];
             }
+            Action::Stash if self.can_unstash() => {
+                return vec![Effect::Unstash(
+                    self.rows[self.selected.expect("unstash requires a selection")].id,
+                )];
+            }
             Action::Stash if self.can_stash() => {
                 return vec![Effect::Stash(
                     self.rows[self.selected.expect("stash requires a selection")].id,
@@ -1753,6 +1761,17 @@ impl App {
                 .is_some_and(|row| !self.hidden_rows.contains(&row.id) && Some(row.id) == self.worktree_head)
     }
 
+    pub(crate) fn can_unstash(&self) -> bool {
+        self.state == State::Complete
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.unstash_available
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|row| !self.hidden_rows.contains(&row.id) && Some(row.id) == self.worktree_head)
+    }
+
     pub(crate) fn can_spill(&self) -> bool {
         self.can_edit_head() && matches!(self.changes_focus, None | Some(ChangePane::Tree)) && self.spill_available
     }
@@ -1761,10 +1780,12 @@ impl App {
         self.can_edit_head() && self.changes_focus.is_none() && self.split_available
     }
 
+    #[expect(clippy::too_many_arguments)]
     pub(crate) fn set_head_edit_availability(
         &mut self,
         amend: bool,
         stash: bool,
+        unstash: bool,
         worktree_path_amend: bool,
         finish_review: bool,
         spill: bool,
@@ -1772,6 +1793,7 @@ impl App {
     ) {
         self.amend_available = amend;
         self.stash_available = stash;
+        self.unstash_available = unstash;
         self.worktree_path_amend_available = worktree_path_amend;
         self.finish_review_available = finish_review;
         self.spill_available = spill;
@@ -2549,7 +2571,7 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_head_edit_availability(true, true, true, false, true, false);
+        app.set_head_edit_availability(true, true, false, true, false, true, false);
         complete(&mut app);
         assert_eq!(app.update(Action::Amend), vec![Effect::Amend(id(2))]);
         assert_eq!(app.update(Action::Stash), vec![Effect::Stash(id(2))]);
@@ -2558,8 +2580,14 @@ mod tests {
             app.update(Action::Split).is_empty(),
             "split needs both kinds of changes"
         );
-        app.set_head_edit_availability(true, true, true, false, true, true);
+        app.set_head_edit_availability(true, true, false, true, false, true, true);
         assert_eq!(app.update(Action::Split), vec![Effect::Split(id(2))]);
+        app.set_head_edit_availability(true, false, true, true, false, true, true);
+        assert_eq!(
+            app.update(Action::Stash),
+            vec![Effect::Unstash(id(2))],
+            "the stash key restores existing state instead of saving another stash"
+        );
         app.changes_focus = Some(ChangePane::Tree);
         assert!(!app.can_amend(), "a tree path cannot be amended");
         assert!(!app.can_split(), "a tree path cannot be split");
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
index 94e26c449b1..4ef2d113857 100644
--- a/gix-tix/src/edit/stash.rs
+++ b/gix-tix/src/edit/stash.rs
@@ -181,6 +181,27 @@ pub(crate) fn save_manual(repository_path: &Path, bare: bool, id: ObjectId) -> R
     Ok(notice)
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
+pub(crate) fn restore_manual(repository_path: &Path, bare: bool, id: ObjectId) -> Result<String> {
+    let repo = open_repository(repository_path, bare, false).context("could not open repository to unstash changes")?;
+    let workdir = repo
+        .workdir()
+        .context("unstashing changes requires a worktree")?
+        .to_owned();
+    if repo
+        .head_id()
+        .context("unstashing changes requires a born HEAD")?
+        .detach()
+        != id
+    {
+        anyhow::bail!("changes can only be unstashed at the current HEAD");
+    }
+    let name = reference(id)?;
+    drop(repo);
+    let saved = find(repository_path, bare, name)?.context("the selected commit has no saved worktree state")?;
+    apply(repository_path, bare, &workdir, saved)
+}
+
 #[derive(Clone)]
 pub(super) struct SavedStash {
     pub name: gix::refs::FullName,
@@ -399,14 +420,19 @@ mod tests {
         assert_eq!(std::fs::read(fixture.path().join("ignored"))?, b"ignored\n");
         drop(repo);
 
-        let saved = find(&repository_path, false, name.clone())?.expect("the manual stash exists");
-        apply(&repository_path, false, fixture.path(), saved)?;
+        std::fs::write(fixture.path().join("local"), "existing worktree change\n")?;
+        restore_manual(&repository_path, false, head)?;
         assert_eq!(
             git(fixture.path(), &["diff", "--cached", "--name-only"])?.trim(),
             b"staged"
         );
         assert_eq!(git(fixture.path(), &["diff", "--name-only"])?.trim(), b"tracked");
         assert_eq!(std::fs::read(fixture.path().join("untracked"))?, b"untracked\n");
+        assert_eq!(
+            std::fs::read(fixture.path().join("local"))?,
+            b"existing worktree change\n",
+            "unstashing leaves unrelated worktree changes intact"
+        );
         let repo = crate::open_test_repository(fixture.path())?;
         assert!(repo.try_find_reference(name.as_ref())?.is_none());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), ordinary);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d78aa827688..d3ab993aaca 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2090,6 +2090,19 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("stash: {err:#}")),
                     }
                 }
+                Effect::Unstash(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit::stash::restore_manual(&repository_path, repository_is_bare, id) {
+                        Ok(notice) => {
+                            app.leave_message(notice);
+                            app.select_commit_after_refresh(id);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_message(format!("unstash: {err:#}")),
+                    }
+                }
                 Effect::Forget(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 1504c99efa2..43355ecb7e7 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -334,6 +334,7 @@ pub(crate) fn draw_with_worktree(
                 }
             }),
         stashable,
+        selected_is_head && selected_has_stash,
         selected_is_head && worktree_path_amend,
         selected_is_head && selected_is_review && worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
@@ -833,6 +834,8 @@ pub(crate) fn draw_with_worktree(
             }
             if app.can_stash() {
                 options.push(("stash", 'h'));
+            } else if app.can_unstash() {
+                options.push(("unstash", 'h'));
             }
             if app.can_spill() {
                 options.push(("spill", 's'));
@@ -3008,7 +3011,7 @@ mod tests {
             }],
             ..Changes::default()
         };
-        app.set_head_edit_availability(true, false, true, false, false, false);
+        app.set_head_edit_availability(true, false, false, true, false, false, false);
         assert!(app.can_amend(), "the focused worktree path is amendable");
         assert!(app.edit_expanded, "the edit prefix remains expanded");
         terminal.draw(|frame| {
@@ -3066,8 +3069,8 @@ mod tests {
             );
         })?;
         assert!(
-            !rendered_line(&terminal, 7).contains("stash"),
-            "an existing commit stash suppresses another save action"
+            rendered_line(&terminal, 7).contains("unstash"),
+            "an existing commit stash offers in-place restoration even with worktree changes"
         );
         decorations
             .get_mut(&id)

From c584bb6212d414bb1565c8429c70bbad10b26a7f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 19:59:34 +0200
Subject: [PATCH 129/282] fix: preserve clean prefixes in tix rebases

Applying a todo eagerly recreated every commit through `@`, even when the early picks and their parentage were unchanged. Large clean prefixes were needlessly re-signed, changed identity, and inflated rebase time.

Map an unchanged, non-pending pick without squashes to itself when its planned parent is still its actual parent. Eager replay now starts at the first pending or structurally changed commit, while descendants and other stacks retain the established lazy-rebase behavior.
---
 gix-tix/spec.md            |   6 +-
 gix-tix/src/edit/rebase.rs | 113 +++++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/todo.rs   |   2 +-
 3 files changed, 113 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7c4a74c4182..9c480e419b0 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -644,8 +644,10 @@ space first; changes blocks adapt within the remaining history width.
   local branch explicitly attaches it and is valid only at the marked result.
   Removing the name deletes the branch. Checkout markers are invalid without a
   worktree. Todo generation and application reject an unborn `HEAD`.
-- Only the ancestry ending at `@` and any squash groups are eagerly cherry-picked
-  and re-signed. Other resulting stacks retain their trees, receive pending-rebase
+- Within the ancestry ending at `@`, unchanged picks whose original parent is
+  still their planned parent retain their IDs. Eager cherry-picking and re-signing
+  starts at the first pending or structurally changed commit. Any descendants
+  above `@` and other resulting stacks retain their trees, receive pending-rebase
   markers, and invalidate old signatures for later time travel. With no `@`,
   ordinary steps remain lazy while squash groups are still materialized.
   Any conflict while applying a history todo first remains entirely in memory.
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 6d75fe89f6c..a882c6bcb63 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -876,6 +876,7 @@ pub(crate) fn perform_plan_with_progress(
     let mut produced = Vec::with_capacity(plan.steps.len());
     let mut delete_refs = Vec::new();
     let mut conflict = None;
+    let mut marked = false;
     for (index, step) in plan.steps.iter().enumerate() {
         let parent = match step.parent {
             PlanParent::Existing(id) => {
@@ -932,6 +933,17 @@ pub(crate) fn perform_plan_with_progress(
             PlanCommit::Empty(_) => vec![parent],
         };
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
+        if let PlanCommit::Pick(id) = step.commit
+            && step.squash.is_empty()
+            && !is_pending(&commit)
+            && graph_parents.as_slice() == [parent]
+        {
+            rewritten.insert(id, Some(id));
+            produced.push(id);
+            progress.processed += 1;
+            report(progress);
+            continue;
+        }
         let replay_parents = recorded_parent.map_or_else(
             || graph_parents.clone(),
             |parent| parent.into_iter().collect::<Vec<_>>(),
@@ -1018,6 +1030,7 @@ pub(crate) fn perform_plan_with_progress(
         } else if eager {
             CommitState::Unmarked(Signature::RedoIfNeeded)
         } else {
+            marked = true;
             CommitState::Pending {
                 original_parent: recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
             }
@@ -1132,11 +1145,6 @@ pub(crate) fn perform_plan_with_progress(
         PlanParent::Existing(id) => id,
         PlanParent::Step(index) => produced[index],
     });
-    let marked = plan
-        .steps
-        .iter()
-        .enumerate()
-        .any(|(index, step)| !eager.contains(&index) && step.squash.is_empty());
     let mut prepared = Prepared {
         repo,
         root: Some(plan.base),
@@ -2593,6 +2601,101 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_pending_checkout_rewrites_only_from_the_first_pending_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let clean = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+
+        let mut checkout = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        checkout.extra_headers.retain(|(name, _)| !is_signature(name));
+        checkout.extra_headers.push((
+            gix::objs::commit::signature_field_name(checkout.tree.kind()).into(),
+            BString::default(),
+        ));
+        let checkout = repo.write_object(&checkout)?.detach();
+
+        let mut descendant = repo.find_commit(checkout)?.decode()?.into_owned()?;
+        descendant.parents = [checkout].into_iter().collect();
+        descendant.message = "pending descendant".into();
+        descendant
+            .extra_headers
+            .push((ORIGINAL_PARENT.into(), checkout.to_hex().to_string().into()));
+        let descendant = repo.write_object(&descendant)?.detach();
+        repo.reference(
+            "refs/heads/main",
+            descendant,
+            PreviousValue::MustExistAndMatch(Target::Object(old_tip)),
+            "test pending tip",
+        )?;
+
+        let graph = super::super::loaded_graph(&repo)?;
+        let mut progress = Vec::new();
+        let outcome = perform_plan_with_progress(
+            &repo,
+            &graph,
+            Plan {
+                base,
+                scope: vec![clean, checkout, descendant],
+                steps: vec![
+                    PlanStep {
+                        parent: PlanParent::Existing(base),
+                        commit: PlanCommit::Pick(clean),
+                        squash: Vec::new(),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(0),
+                        commit: PlanCommit::Pick(checkout),
+                        squash: Vec::new(),
+                    },
+                    PlanStep {
+                        parent: PlanParent::Step(1),
+                        commit: PlanCommit::Pick(descendant),
+                        squash: Vec::new(),
+                    },
+                ],
+                checkout: Some(PlanCheckout {
+                    target: PlanParent::Step(1),
+                    reference: None,
+                }),
+                expected_refs: capture_refs(&repo, &[clean, checkout, descendant], &[descendant])?,
+            },
+            |update| progress.push(update),
+        )?
+        .complete()?;
+
+        assert_eq!(
+            outcome.map(clean),
+            Some(clean),
+            "the clean prefix retains its commit ID"
+        );
+        let rewritten_checkout = outcome.map(checkout).context("the pending checkout is retained")?;
+        assert_ne!(rewritten_checkout, checkout, "the empty signature is materialized");
+        assert_eq!(outcome.selected, Some(rewritten_checkout));
+        assert!(
+            !is_pending(&repo.find_commit(rewritten_checkout)?.decode()?.into_owned()?),
+            "the selected commit is no longer pending"
+        );
+        let rewritten_descendant = outcome.map(descendant).context("the descendant is retained")?;
+        let descendant = repo.find_commit(rewritten_descendant)?.decode()?.into_owned()?;
+        assert!(has_marker(&descendant), "history above the checkout remains lazy");
+        assert_eq!(descendant.parents.as_slice(), [rewritten_checkout]);
+        assert_eq!(
+            repo.find_reference("refs/heads/main")?.id().detach(),
+            rewritten_descendant,
+            "the branch follows the lazily rewritten tip"
+        );
+        let progress = progress.last().context("rebase progress is reported")?;
+        assert_eq!(progress.processed, 3);
+        assert_eq!(
+            progress.cherry_picked, 1,
+            "only the pending checkout is replayed eagerly"
+        );
+        Ok(())
+    }
+
     #[test]
     fn a_todo_squash_materializes_one_commit_and_maps_every_source_to_it() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 04a6b42abc5..bfb46438e5f 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -21,7 +21,7 @@ const HELP: &str = r#"
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
 - Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. The current attached branch stays attached while it remains at the `@` command. Prefix one local branch with `@` to attach HEAD to it explicitly; it must point to the `@` command.
-- Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. The ancestry ending at `@` is cherry-picked and re-signed; other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
+- Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. Unchanged picks whose parent stays unchanged retain their IDs; replay starts at the first pending or structurally changed commit. Changed commits through `@` are cherry-picked and re-signed, while descendants and other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
 - Commit states are display-only and editing them has no effect: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, `○` means unsigned, and `🎁` means worktree state is stashed for that commit. Stashes follow rewritten commits automatically; dropping a stashed commit or combining multiple stashes into one result is rejected.

From 8b08c58fa2ebfe42dc8f02be94991ec6182a50be Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:19:21 +0200
Subject: [PATCH 130/282] fix: avoid pinning superseded tix checkout commits

Todo checkout considered the pre-rewrite detached HEAD when preserving the departure. If that commit was rewritten into the selected successor, tix retained an obsolete pin beside the commit it actually checked out.

Carry complete and conflicted rebase mappings into the shared checkout path and map the departure before deciding whether it needs a pin. Skip preservation when it maps to the destination, and otherwise retain only the rewritten identity that still anchors visible history.
---
 gix-tix/spec.md                 |   3 +
 gix-tix/src/command/rebase.rs   |  12 +---
 gix-tix/src/edit/rebase.rs      |   6 ++
 gix-tix/src/edit/time_travel.rs | 110 ++++++++++++++++++++++++--------
 gix-tix/src/edit/todo.rs        |  63 ++++++++++++------
 gix-tix/src/lib.rs              |  26 ++++----
 6 files changed, 148 insertions(+), 72 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 9c480e419b0..fb3b01c63f6 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -223,6 +223,9 @@ The Enter key is written as `<enter>` throughout.
   generated pins start with eight hexadecimal characters from the saved commit.
 - A pin is symbolic when the previous `HEAD` named a local branch, so later branch
   advances move the pinned tip. An already detached `HEAD` receives a direct pin.
+- When a rebase rewrites a detached departure, checkout applies the rebase mapping
+  before deciding whether to pin it. A departure rewritten into the selected `@`
+  successor is not pinned; a distinct departure preserves its rewritten identity.
 - While `HEAD` is detached, every valid pin from the current worktree augments
   implicit and explicit revision tips. While it is attached, only pins at strict
   descendants of `HEAD` do so, preserving rewritten leaves after a history rebase
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 93b8c053b00..4fc5eb9cd69 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -242,16 +242,8 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
     match rebase::perform_plan(&repo, &graph, parsed.plan)? {
         rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
-            if let Some(selected) = outcome.selected {
-                let notice = edit::time_travel::checkout_plan(
-                    &repository_path,
-                    bare,
-                    selected,
-                    outcome.checkout_reference.as_ref(),
-                    &outcome.deferred_ref_deletions,
-                    &revisions,
-                    false,
-                )?;
+            if outcome.selected.is_some() {
+                let notice = edit::time_travel::checkout_plan(&repository_path, bare, &outcome, &revisions, false)?;
                 println!("{}", notice.unwrap_or_else(|| "rebased history".into()));
             } else {
                 println!("rebased history");
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index a882c6bcb63..43d0cfeeaf6 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -303,6 +303,7 @@ impl Conflict {
             merged_tree: self.merged_tree,
             commit: self.commit,
             deferred_ref_deletions: outcome.deferred_ref_deletions,
+            rewritten: outcome.rewritten,
         })
     }
 }
@@ -313,9 +314,14 @@ pub(crate) struct PersistedConflict {
     merged_tree: ObjectId,
     pub(crate) commit: ObjectId,
     pub(crate) deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
+    rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
 impl PersistedConflict {
+    pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
+        self.rewritten.get(&id).copied().unwrap_or(Some(id))
+    }
+
     pub(crate) fn materialize(&mut self) -> Result<()> {
         let mut index = self
             .repo
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 21967208e99..35fecc89b84 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -51,12 +51,14 @@ impl Conflict {
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
     pub(crate) fn accept(self) -> Result<(String, ObjectId)> {
         let mut conflict = self.rebase.persist()?;
-        let notice = move_head(
+        let notice = move_head_to(
             &self.repository_path,
             self.bare,
             conflict.commit,
+            None,
             &self.revisions,
             self.include_worktrees,
+            |id| conflict.map(id),
         )?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
@@ -75,8 +77,16 @@ pub(crate) fn materialize_plan_conflict(
 ) -> Result<(String, ObjectId)> {
     let original = conflict.original();
     let mut conflict = conflict.into_conflict().persist()?;
-    let notice = move_head(repository_path, bare, conflict.commit, revisions, include_worktrees)?
-        .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
+    let notice = move_head_to(
+        repository_path,
+        bare,
+        conflict.commit,
+        None,
+        revisions,
+        include_worktrees,
+        |id| conflict.map(id),
+    )?
+    .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
     delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
     conflict.materialize()?;
     tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
@@ -96,14 +106,21 @@ pub(crate) fn checkout_without_replay(
 pub(crate) fn checkout_plan(
     repository_path: &Path,
     bare: bool,
-    selected: ObjectId,
-    reference: Option<&gix::refs::FullName>,
-    deferred_ref_deletions: &[(gix::refs::FullName, ObjectId)],
+    outcome: &super::rebase::Outcome,
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
-    let notice = move_head_to(repository_path, bare, selected, reference, revisions, include_worktrees)?;
-    delete_deferred_refs(repository_path, bare, deferred_ref_deletions)?;
+    let selected = outcome.selected.context("the rebase plan does not select a checkout")?;
+    let notice = move_head_to(
+        repository_path,
+        bare,
+        selected,
+        outcome.checkout_reference.as_ref(),
+        revisions,
+        include_worktrees,
+        |id| outcome.map(id),
+    )?;
+    delete_deferred_refs(repository_path, bare, &outcome.deferred_ref_deletions)?;
     Ok(notice)
 }
 
@@ -114,17 +131,29 @@ fn move_head(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
-    move_head_to(repository_path, bare, selected, None, revisions, include_worktrees)
+    move_head_to(
+        repository_path,
+        bare,
+        selected,
+        None,
+        revisions,
+        include_worktrees,
+        Some,
+    )
 }
 
-fn move_head_to(
+fn move_head_to<F>(
     repository_path: &Path,
     bare: bool,
     selected: ObjectId,
     reference: Option<&gix::refs::FullName>,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<Option<String>> {
+    map_departure: F,
+) -> Result<Option<String>>
+where
+    F: FnOnce(ObjectId) -> Option<ObjectId>,
+{
     let repository = open_repository(repository_path, bare, false).context("could not open repository for checkout")?;
     let workdir = repository
         .workdir()
@@ -136,13 +165,19 @@ fn move_head_to(
         .map(gix::Id::detach)
         .context("cannot time-travel from an unborn HEAD")?;
     let head_ref = head.referent_name().map(ToOwned::to_owned);
-    let saved_target = head_ref.clone().map_or(Target::Object(head_id), Target::Symbolic);
+    let departure = map_departure(head_id);
     drop(head);
     if selected == head_id && head_ref.as_ref() == reference {
         return Ok(None);
     }
     let destination_pin = selected_pin(&repository, selected)?;
-    let provisional = create_or_reuse_pin(&repository, saved_target, head_id, "tix time-travel")?;
+    let provisional = departure
+        .filter(|departure| *departure != selected)
+        .map(|departure| {
+            let target = head_ref.clone().map_or(Target::Object(departure), Target::Symbolic);
+            create_or_reuse_pin(&repository, target, departure, "tix time-travel")
+        })
+        .transpose()?;
     drop(repository);
     let checkout = match (reference, &destination_pin) {
         (Some(reference), _) => checkout_branch(&workdir, reference),
@@ -150,14 +185,14 @@ fn move_head_to(
         (None, None) => checkout_detached(&workdir, selected),
     };
     if let Err(checkout) = checkout {
-        if provisional.1 {
+        if let Some((pin, true)) = provisional.as_ref() {
             let cleanup = open_repository(repository_path, bare, false)
                 .context("could not reopen repository to remove a provisional pin")
-                .and_then(|repository| delete_pin(&repository, &provisional.0));
+                .and_then(|repository| delete_pin(&repository, pin));
             if let Err(cleanup) = cleanup {
                 return Err(checkout.context(format!(
                     "checkout failed and {} could not be removed: {cleanup:#}",
-                    pin_label(&provisional.0)
+                    pin_label(pin)
                 )));
             }
         }
@@ -184,19 +219,21 @@ fn move_head_to(
         revisions,
         &[],
         include_worktrees,
-        Some(provisional.0.name.as_bstr()),
+        provisional.as_ref().map(|(pin, _)| pin.name.as_bstr()),
     )?;
-    if snapshot
-        .view_tips
-        .iter()
-        .copied()
-        .any(|tip| contains(&repository, head_id, tip))
-    {
-        if let Err(err) = delete_pin(&repository, &provisional.0) {
-            notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&provisional.0));
+    if let Some((provisional, _)) = provisional {
+        if snapshot
+            .view_tips
+            .iter()
+            .copied()
+            .any(|tip| contains(&repository, provisional.id, tip))
+        {
+            if let Err(err) = delete_pin(&repository, &provisional) {
+                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&provisional));
+            }
+        } else {
+            notice = format!("{notice}; saved {}", pin_label(&provisional));
         }
-    } else {
-        notice = format!("{notice}; saved {}", pin_label(&provisional.0));
     }
     Ok(Some(notice))
 }
@@ -218,6 +255,7 @@ pub(crate) fn perform(
     let Some(mut head_id) = head.id().map(gix::Id::detach) else {
         anyhow::bail!("cannot time-travel from an unborn HEAD");
     };
+    let head_was_detached = head.is_detached();
     drop(head);
     if repository
         .index_or_empty()
@@ -284,7 +322,17 @@ pub(crate) fn perform(
     } else {
         None
     };
-    let moved = move_head(repository_path, bare, selected, revisions, include_worktrees);
+    let moved = move_head_to(
+        repository_path,
+        bare,
+        selected,
+        None,
+        revisions,
+        include_worktrees,
+        |actual| {
+            if head_was_detached { Some(head_id) } else { Some(actual) }
+        },
+    );
     let mut notice = match moved {
         Ok(notice) => notice,
         Err(err) => {
@@ -1313,6 +1361,12 @@ mod tests {
         assert_eq!(tip_commit.parents.first().copied(), Some(materialized_middle));
         assert!(super::super::rebase::is_pending(&tip_commit));
         assert!(super::super::rebase::has_marker(&tip_commit));
+        assert!(
+            history::all_pins(&repository)?
+                .iter()
+                .all(|pin| pin.id != pending_middle),
+            "travelling to a rewritten detached HEAD does not pin its predecessor"
+        );
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
 
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index bfb46438e5f..c6cd065b05b 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1696,16 +1696,7 @@ mod tests {
         );
         let graph = super::super::loaded_graph(&repo)?;
         let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
-        let selected = outcome.selected.context("the edited todo retains a checkout")?;
-        super::super::time_travel::checkout_plan(
-            repo.git_dir(),
-            false,
-            selected,
-            outcome.checkout_reference.as_ref(),
-            &outcome.deferred_ref_deletions,
-            &[],
-            false,
-        )?;
+        super::super::time_travel::checkout_plan(repo.git_dir(), false, &outcome, &[], false)?;
 
         assert!(repo.head()?.referent_name().is_none(), "HEAD is detached");
         assert_eq!(
@@ -1726,6 +1717,48 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn rewritten_detached_head_is_not_pinned_before_checkout() -> gix_testtools::Result {
+        let (fixture, repo) = repo()?;
+        let (base, _middle, tip, commits) = commits(&repo)?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "--quiet", "--detach", &tip.to_string()])
+                .status()?
+                .success(),
+            "the fixture HEAD can be detached"
+        );
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let edited = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\n@pick {}\n(main, refs/patches/tip)\n",
+                base.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+            ),
+        );
+        let plan = parse_plan(&repo, &edited)?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+        let selected = outcome.selected.context("the rewritten todo retains @")?;
+        assert_ne!(selected, tip, "dropping the middle commit rewrites the checked-out tip");
+
+        super::super::time_travel::checkout_plan(repo.git_dir(), false, &outcome, &[], false)?;
+
+        assert_eq!(
+            repo.head_id()?.detach(),
+            selected,
+            "HEAD reaches the rewritten successor"
+        );
+        assert!(
+            crate::history::all_pins(&repo)?.iter().all(|pin| pin.id != tip),
+            "the superseded detached HEAD is not retained through a pin"
+        );
+        Ok(())
+    }
+
     #[test]
     fn deleting_the_current_branch_is_deferred_until_head_detaches() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
@@ -1746,15 +1779,7 @@ mod tests {
             repo.try_find_reference("refs/heads/main")?.is_some(),
             "the checked-out branch remains until checkout succeeds"
         );
-        super::super::time_travel::checkout_plan(
-            repo.git_dir(),
-            false,
-            outcome.selected.context("the todo selects HEAD")?,
-            outcome.checkout_reference.as_ref(),
-            &outcome.deferred_ref_deletions,
-            &[],
-            false,
-        )?;
+        super::super::time_travel::checkout_plan(repo.git_dir(), false, &outcome, &[], false)?;
         assert!(repo.head()?.referent_name().is_none(), "HEAD is detached");
         assert!(
             repo.try_find_reference("refs/heads/main")?.is_none(),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d3ab993aaca..9ff28aba438 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2157,21 +2157,17 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(edit::rebase::PlanPerform::Complete(outcome))) => {
-                            let notice = outcome
-                                .selected
-                                .map(|selected| {
-                                    edit::time_travel::checkout_plan(
-                                        &repository_path,
-                                        repository_is_bare,
-                                        selected,
-                                        outcome.checkout_reference.as_ref(),
-                                        &outcome.deferred_ref_deletions,
-                                        &revisions,
-                                        worktrees,
-                                    )
-                                })
-                                .transpose()
-                                .map(Option::flatten);
+                            let notice = if outcome.selected.is_some() {
+                                edit::time_travel::checkout_plan(
+                                    &repository_path,
+                                    repository_is_bare,
+                                    &outcome,
+                                    &revisions,
+                                    worktrees,
+                                )
+                            } else {
+                                Ok(None)
+                            };
                             match notice {
                                 Ok(notice) => {
                                     app.leave_message(notice.unwrap_or_else(|| "rebased history".to_owned()));

From d2176a949f72a6dc65e807e7054218bcada2f90c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:23:09 +0200
Subject: [PATCH 131/282] feat: make @ the direct tix time-travel shortcut

Time travel had become an edit-prefix action even though it is navigation, and removing Shift tracking left no direct key that matched the HEAD marker shown in history.

Handle `@` independently of shortcut prefixes, remove the old edit-group binding, and place the contextual travel or return hint between edit and copy. An expanded edit group remains open so direct navigation does not unexpectedly change modes.
---
 gix-tix/spec.md    | 19 ++++++++++---------
 gix-tix/src/app.rs |  1 +
 gix-tix/src/lib.rs | 18 ++++++++++++++++--
 gix-tix/src/ui.rs  | 23 ++++++++++++-----------
 4 files changed, 39 insertions(+), 22 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index fb3b01c63f6..40a1e10959a 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -191,7 +191,7 @@ without trading responsiveness for metadata that is not visible.
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
-| `t` | Time-travel to the selected commit, or return through its tix pin. |
+| `@` | Time-travel to the selected commit, or return through its tix pin. |
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
@@ -204,8 +204,8 @@ underlines the `v` in `view`; while active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
-actions end at the information prefix while it is closed. Copy
-immediately follows the edit group; the reference toggle immediately precedes
+actions end at the information prefix while it is closed. An available direct
+time-travel action follows the edit group, and copy follows time travel; the reference toggle immediately precedes
 the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
 possible; keys that cannot be expressed naturally in the label remain explicit.
@@ -213,7 +213,7 @@ The Enter key is written as `<enter>` throughout.
 
 ### Time-travel
 
-- On a completed, focused history in a worktree repository, `t` on a non-`HEAD`
+- On a completed, focused history in a worktree repository, `@` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
 - Before every move, tix provisionally retains the previous `HEAD` with a
   `refs/worktree/tix/pins/<suffix>` ref. Git stores these refs privately for the
@@ -235,7 +235,7 @@ The Enter key is written as `<enter>` throughout.
 - One or more worktree pins at a commit are shown as a single blue `📌`
   resource marker immediately after the hash and outside ordinary reference
   decorations. It remains visible when references are hidden, and internal pin
-  names are omitted from history rows. `t` on a pinned
+  names are omitted from history rows. `@` on a pinned
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
@@ -707,11 +707,12 @@ space first; changes blocks adapt within the remaining history width.
   `e u` rebases it onto the newer hidden branch tip when available,
   `e r` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
-  `e d d` confirms forgetting a top commit, and `e t` enters or returns from
-  time travel when each action is available.
+  and `e d d` confirms forgetting a top commit when each action is available.
+- `@` invokes time travel directly, outside the edit group. Invoking it leaves an
+  already expanded edit group open.
 - Edit shortcuts keep the group open. Navigation or another recognized command
-  closes it, matching the `v` display shortcut group. Plain `r` and `t` do not
-  mutate the repository.
+  closes it, matching the `v` display shortcut group. Plain `r` does not mutate
+  the repository, and plain `t` has no action.
 - The footer underlines the `e` in `edit`; while active, `edit (` contains only the
   actions available for the current selection, followed by `)`. An empty group
   says `no actions`.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index b1dd9e21b87..a181000c844 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -3339,6 +3339,7 @@ mod tests {
         app.update(Action::Forget);
         app.update(Action::Rebase);
         app.update(Action::RebaseUpdate);
+        app.update(Action::TimeTravel);
         assert!(app.edit_expanded, "grouped edit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 9ff28aba438..358b011e0b2 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4315,9 +4315,9 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
-        KeyCode::Char('t') if edit_expanded => Some(Action::TimeTravel),
         KeyCode::Char('i') if edit_expanded => Some(Action::Unpin),
         KeyCode::Char('v') if edit_expanded => Some(Action::Review),
+        KeyCode::Char('@') => Some(Action::TimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
@@ -5263,6 +5263,11 @@ mod tests {
             Some(Action::ToggleRefs)
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE)),
+            Some(Action::TimeTravel),
+            "the terminal's direct at-sign event invokes time travel"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
@@ -5326,7 +5331,6 @@ mod tests {
             ('s', Action::Spill),
             ('p', Action::Split),
             ('d', Action::Forget),
-            ('t', Action::TimeTravel),
             ('i', Action::Unpin),
         ] {
             assert_eq!(
@@ -5335,6 +5339,16 @@ mod tests {
                 "{key} is available after the edit prefix"
             );
         }
+        assert_eq!(
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE), false, true),
+            None,
+            "time travel is no longer part of the edit prefix"
+        );
+        assert_eq!(
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE), false, true),
+            Some(Action::TimeTravel),
+            "the direct time-travel key remains available while edit is expanded"
+        );
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL), false, true,),
             Some(Action::PageUp),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 43355ecb7e7..aec98254450 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -774,9 +774,10 @@ pub(crate) fn draw_with_worktree(
             Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         ));
     }
+    let mut time_travel = None;
     let mut edit_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
-        let time_travel = if app.time_travel_shortcut_visible()
+        time_travel = if app.time_travel_shortcut_visible()
             && decorations
                 .values()
                 .flatten()
@@ -793,9 +794,9 @@ pub(crate) fn draw_with_worktree(
                         .iter()
                         .any(|decoration| decoration.kind == DecorationKind::Pin)
                     {
-                        ("return", 't')
+                        "@ return"
                     } else {
-                        ("travel", 't')
+                        "@ travel"
                     },
                 )
             } else {
@@ -850,11 +851,6 @@ pub(crate) fn draw_with_worktree(
                     ("d forget", 'd')
                 });
             }
-            if app.changes_focus.is_none()
-                && let Some(label) = time_travel
-            {
-                options.push(label);
-            }
             if app.changes_focus.is_none()
                 && app
                     .selected
@@ -941,6 +937,10 @@ pub(crate) fn draw_with_worktree(
     let mut ordered = vec![Span::raw(history_position(app))];
     ordered.append(&mut view_prefix_spans);
     ordered.append(&mut edit_prefix_spans);
+    if let Some(label) = time_travel {
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut(label, '@', true));
+    }
     ordered.push(Span::raw(" · "));
     ordered.extend(shortcut("copy", 'y', true));
     ordered.push(Span::raw(" · "));
@@ -2886,14 +2886,15 @@ mod tests {
             "hiding refs retains resource markers: {row:?}"
         );
         assert!(
-            rendered_line(&terminal, 1).contains("edit (reword · new · new-empty · fork · d forget · return · unpin)"),
-            "the active edit prefix contains exactly its actionable commands"
+            rendered_line(&terminal, 1)
+                .contains("edit (reword · new · new-empty · fork · d forget · unpin) · @ return · copy"),
+            "time travel stays outside the active edit prefix"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 1).contains("travel"));
+        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
         Ok(())
     }

From 4b3c211328e32ba7a3661c22891918e0fa18cb1b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:24:21 +0200
Subject: [PATCH 132/282] Document contextual tix commit messages

Recent tix commits often carried only a concise subject, leaving reviewers to reconstruct the motivation, previous behavior, and design constraints from the originating conversation.

Require every tix commit to include a descriptive body with enough context to review the change independently. Keep this alongside the existing semantic-commit and authorship rules so it applies whenever an agent prepares or rewrites a commit.
---
 gix-tix/AGENTS.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index fdddd3e021b..ed31d81dea3 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -16,6 +16,11 @@
 
 - Create one commit per semantically distinct change. Do not combine independent
   behavior changes merely because they were requested together.
+- Write a descriptive commit body for every commit, not only a subject line.
+  Explain the motivation and relevant prior behavior, the context needed to
+  review the change, and any important constraints or decisions. The message
+  should let a reviewer understand why the change exists without reconstructing
+  the conversation that produced it.
 - Keep each change's implementation, tests, snapshots, and corresponding
   `spec.md` updates in that change's commit.
 - A commit created or materially rewritten by an AI agent must use that agent's own name and email as its author. Do not silently inherit the repository owner's configured identity.

From 2b38ec5ac2872c1c817d5fba2173f4c32170f142 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:40:02 +0200
Subject: [PATCH 133/282] fix: accept Shift-2 for tix time travel

Enhanced keyboard reporting is not consistent across terminals when the user types an at sign. Some report the resulting '@' character, while others preserve the physical '2' key and attach the Shift modifier. Tix previously recognized only the first form, making the documented shortcut inert in the latter terminals.

Recognize Shift-2 alongside the direct at-sign event without restoring any global Shift tracking. Keep plain 2 and standalone Shift inert, and document both terminal encodings under the same @ action.
---
 gix-tix/spec.md    |  2 +-
 gix-tix/src/lib.rs | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 40a1e10959a..5b527c68fe2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -191,7 +191,7 @@ without trading responsiveness for metadata that is not visible.
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
-| `@` | Time-travel to the selected commit, or return through its tix pin. |
+| `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 358b011e0b2..dad90b2438e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4318,6 +4318,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('i') if edit_expanded => Some(Action::Unpin),
         KeyCode::Char('v') if edit_expanded => Some(Action::Review),
         KeyCode::Char('@') => Some(Action::TimeTravel),
+        KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::TimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
@@ -5268,6 +5269,16 @@ mod tests {
             Some(Action::TimeTravel),
             "the terminal's direct at-sign event invokes time travel"
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::SHIFT)),
+            Some(Action::TimeTravel),
+            "terminals which preserve the base character map Shift-2 to time travel"
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE)),
+            None,
+            "an unshifted 2 has no time-travel behavior"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),

From 1c5c8372211720056ad74be39cb5d5a122a6811d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:44:04 +0200
Subject: [PATCH 134/282] feat: add safe command-line time travel to tix

Tix time travel was available only from the interactive history, even though scripts and agents need the same pending-rebase replay, stash handling, and pin-safe checkout behavior for a resolved revision. Calling git checkout directly would bypass those invariants and could lose sight of detached descendants.

Add tix travel REVSPEC as a thin wrapper around the shared time-travel primitive. Attached departures use normal symbolic pins, while detached past or sideways travel requires an existing pin at the source lineage; forward travel and same-HEAD no-ops remain frictionless. Replay conflicts stay unobservable unless --materialize-conflicts explicitly accepts the standard conflicting checkout and index.
---
 gix-tix/spec.md               |   9 ++
 gix-tix/src/command.rs        |  13 ++
 gix-tix/src/command/travel.rs | 227 ++++++++++++++++++++++++++++++++++
 gix-tix/src/edit/mod.rs       |   7 ++
 4 files changed, 256 insertions(+)
 create mode 100644 gix-tix/src/command/travel.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 5b527c68fe2..ebe19634f31 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -13,6 +13,15 @@ without trading responsiveness for metadata that is not visible.
 
 - `tix [REVISION]...` shows commits reachable from the supplied revisions, or
   from `HEAD` when none are supplied.
+- `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
+  checkout, pending-rebase replay, stash handling, and pin reconciliation as
+  TUI time travel. Travelling to the current `HEAD` is a no-op. A detached
+  source may travel to a descendant without a pin, but travelling to an ancestor
+  or unrelated commit requires an existing current-worktree pin at `HEAD` or a
+  descendant. An attached source is preserved through the normal symbolic-pin
+  rules. Replay conflicts change nothing unless explicitly materialized; an
+  accepted conflict writes the checkout and unmerged index, then exits with an
+  error so resolution cannot be mistaken for completion.
 - `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-w/--worktrees` adds every successfully resolved main and linked worktree
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index bade7d745b0..032de8460cf 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -5,6 +5,7 @@ use clap::Parser;
 use gix::prelude::{ObjectIdExt, ReferenceExt};
 
 mod rebase;
+mod travel;
 
 /// Arguments and commands shared by the standalone `tix` binary and `gix tix`.
 #[derive(Debug, clap::Args)]
@@ -38,6 +39,8 @@ enum Command {
     Split,
     /// Pin one or more commits as persistent history tips.
     Pin(Pin),
+    /// Travel to a commit while preserving reachable history through tix pins.
+    Travel(travel::Args),
     /// Generate or apply a self-contained history-rebase todo.
     #[command(subcommand)]
     Rebase(rebase::Command),
@@ -106,6 +109,7 @@ impl Platform {
                 split(repository, &graph)?;
             }
             Command::Pin(args) => pin(&repository, args)?,
+            Command::Travel(args) => return travel::run(repository, args),
             Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
@@ -257,6 +261,15 @@ mod tests {
             panic!("pin was expected")
         };
         assert_eq!(pin.revisions, ["main", "HEAD~2"]);
+        let travel = Cli::try_parse_from(["tix", "travel", "--materialize-conflicts", "HEAD~1"])
+            .expect("travel parses")
+            .platform
+            .command;
+        let Some(Command::Travel(travel)) = travel else {
+            panic!("travel was expected")
+        };
+        assert!(travel.materialize_conflicts);
+        assert_eq!(travel.revision, "HEAD~1");
         assert!(matches!(
             Cli::try_parse_from([
                 "tix",
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
new file mode 100644
index 00000000000..68782e4562f
--- /dev/null
+++ b/gix-tix/src/command/travel.rs
@@ -0,0 +1,227 @@
+use std::ffi::OsString;
+
+use anyhow::{Context, Result};
+
+#[derive(Debug, clap::Args)]
+pub(super) struct Args {
+    /// Check out an encountered replay conflict and write its unmerged index.
+    #[arg(long)]
+    pub(super) materialize_conflicts: bool,
+    /// Revision resolving to the commit to visit.
+    #[arg(value_name = "REVSPEC")]
+    pub(super) revision: OsString,
+}
+
+pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
+    let revision = gix::path::os_str_into_bstr(&args.revision)
+        .with_context(|| format!("revision {} is not valid UTF-8", args.revision.to_string_lossy()))?;
+    let selected = repository
+        .rev_parse_single(revision)
+        .with_context(|| format!("could not resolve revision {revision:?}"))?
+        .object()
+        .context("could not read time-travel destination")?
+        .peel_to_commit()
+        .context("time-travel destination does not resolve to a commit")?
+        .id;
+    let head = repository.head().context("could not read HEAD before time-travel")?;
+    let head_id = head
+        .id()
+        .map(gix::Id::detach)
+        .context("cannot time-travel from an unborn HEAD")?;
+    let detached = head.is_detached();
+    drop(head);
+    if selected == head_id {
+        println!("already at {}", selected.to_hex_with_len(7));
+        return Ok(());
+    }
+
+    let revisions = vec![OsString::from("HEAD"), OsString::from(selected.to_string())];
+    let graph = crate::edit::loaded_view_graph_with(&repository, &revisions)?;
+    let forward = graph.is_ancestor(head_id, selected);
+    if detached && !forward {
+        let source_is_pinned = crate::history::all_pins(&repository)?
+            .into_iter()
+            .any(|pin| graph.is_ancestor(head_id, pin.id));
+        if !source_is_pinned {
+            anyhow::bail!(
+                "detached HEAD or one of its descendants must be pinned before travelling into the past or sideways"
+            );
+        }
+    }
+
+    let reviews = crate::history::all_reviews(&repository)?
+        .into_iter()
+        .map(|review| review.id)
+        .collect::<Vec<_>>();
+    let repository_path = repository.git_dir().to_owned();
+    let bare = repository.is_bare();
+    drop(repository);
+    match crate::edit::time_travel::perform(&repository_path, bare, selected, &graph, &reviews, &[], false)? {
+        crate::edit::time_travel::Perform::Complete(Some(notice)) => println!("{notice}"),
+        crate::edit::time_travel::Perform::Complete(None) => {
+            println!("already at {}", selected.to_hex_with_len(7));
+        }
+        crate::edit::time_travel::Perform::Conflict(conflict) if args.materialize_conflicts => {
+            let (notice, _) = conflict.accept()?;
+            anyhow::bail!("{notice}");
+        }
+        crate::edit::time_travel::Perform::Conflict(_) => {
+            anyhow::bail!("time-travel would conflict; retry with --materialize-conflicts to check it out")
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use gix::bstr::ByteSlice;
+
+    use super::*;
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!("git {} failed: {}", args.join(" "), output.stderr.trim().to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    fn args(revision: &str) -> Args {
+        Args {
+            materialize_conflicts: false,
+            revision: revision.into(),
+        }
+    }
+
+    #[test]
+    fn attached_past_travel_saves_and_returns_to_the_branch() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        run(repository, args("HEAD~1"))?;
+
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(repository.head_id()?.detach(), middle);
+        assert!(repository.head()?.is_detached());
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "leaving the attached tip creates one source pin");
+        assert_eq!(
+            pins[0].target.try_name().expect("the source pin is symbolic").as_bstr(),
+            b"refs/heads/main".as_bstr(),
+            "the source pin follows the departed branch"
+        );
+
+        run(repository, args("main"))?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert_eq!(
+            repository.head()?.referent_name().map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".as_bstr().to_owned()),
+            "travelling to the pinned destination reattaches HEAD"
+        );
+        assert!(crate::history::all_pins(&repository)?.is_empty());
+        run(repository, args("HEAD"))?;
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert!(
+            !repository.head()?.is_detached(),
+            "travelling to the current attached HEAD is a no-op"
+        );
+        assert!(crate::history::all_pins(&repository)?.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn detached_travel_needs_a_source_pin_except_toward_descendants() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        git(path, &["branch", "side", "HEAD~2"])?;
+        git(path, &["checkout", "-q", "side"])?;
+        git(path, &["commit", "-q", "--allow-empty", "-m", "side"])?;
+        git(path, &["checkout", "-q", "--detach", "main~1"])?;
+        let repository = crate::open_test_repository(path)?;
+        run(repository, args("main"))?;
+        let repository = crate::open_test_repository(path)?;
+        assert!(repository.head()?.is_detached());
+        assert!(crate::history::all_pins(&repository)?.is_empty());
+
+        let before_rejected = repository.head_id()?.detach();
+        let err = run(repository, args("HEAD~1")).expect_err("past travel from detached HEAD needs a pin");
+        assert!(format!("{err:#}").contains("must be pinned"));
+        let repository = crate::open_test_repository(path)?;
+        assert_eq!(
+            repository.head_id()?.detach(),
+            before_rejected,
+            "the rejected command does not move HEAD"
+        );
+        let err = run(repository, args("side")).expect_err("sideways travel from detached HEAD needs a pin");
+        assert!(format!("{err:#}").contains("must be pinned"));
+        let repository = crate::open_test_repository(path)?;
+        let tip = repository.head_id()?.detach();
+        repository.reference(
+            "refs/worktree/tix/pins/keep",
+            tip,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test pin",
+        )?;
+        run(repository, args("side"))?;
+        Ok(())
+    }
+
+    #[test]
+    fn replay_conflicts_are_unobservable_until_materialization_is_requested() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let path = fixture.path();
+        git(
+            path,
+            &["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000"],
+        )?;
+        let repository = crate::open_test_repository(path)?;
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        std::fs::write(path.join("after"), "after\n")?;
+        git(path, &["add", "after"])?;
+        git(path, &["commit", "-q", "-m", "after"])?;
+        let graph = crate::edit::loaded_graph(&repository)?;
+        crate::edit::rebase::perform(
+            &repository,
+            &graph,
+            crate::edit::rebase::Edit::Remove { target: middle },
+            crate::edit::rebase::Signature::RedoIfNeeded,
+            crate::edit::rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let tip = repository.find_reference("refs/heads/main")?.id().detach();
+        drop(repository);
+
+        run(crate::open_test_repository(path)?, args(&root.to_string()))?;
+        let before = gix_testtools::repository::snapshot(path)?;
+        let err = run(crate::open_test_repository(path)?, args(&tip.to_string()))
+            .expect_err("a conflict needs explicit materialization");
+        assert!(format!("{err:#}").contains("--materialize-conflicts"));
+        assert_eq!(
+            gix_testtools::repository::snapshot(path)?,
+            before,
+            "declining materialization leaves the complete repository unchanged"
+        );
+
+        let err = run(
+            crate::open_test_repository(path)?,
+            Args {
+                materialize_conflicts: true,
+                revision: tip.to_string().into(),
+            },
+        )
+        .expect_err("a materialized conflict remains an incomplete command");
+        assert!(format!("{err:#}").contains("ready to resolve conflicts"));
+        assert!(
+            crate::open_test_repository(path)?
+                .index_or_empty()?
+                .entries()
+                .iter()
+                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted),
+            "opt-in materialization writes the unresolved index"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 74b0a9f1bf0..88c3e321fca 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -43,6 +43,13 @@ pub(super) fn loaded_view_graph(repo: &gix::Repository) -> Result<crate::history
     load_graph(repo, &[])
 }
 
+pub(super) fn loaded_view_graph_with(
+    repo: &gix::Repository,
+    revisions: &[std::ffi::OsString],
+) -> Result<crate::history::HistoryGraph> {
+    load_graph(repo, revisions)
+}
+
 fn load_graph(repo: &gix::Repository, revisions: &[std::ffi::OsString]) -> Result<crate::history::HistoryGraph> {
     use std::sync::atomic::AtomicBool;
 

From c9d9d4f1957f149fb099f5b335f70f10cc4a4646 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 20:47:27 +0200
Subject: [PATCH 135/282] feat: reword pinned history from the tix command line

The TUI can reword any safely scoped commit, but command-line users and agents could edit only HEAD-oriented operations. Rewording an arbitrary revision without a visible descendant scope would risk leaving required forks behind or broadening the rewrite through unrelated refs.

Add tix reword REVSPEC with eligibility checks before editor launch. An attached HEAD may edit itself directly; every other target needs a current-worktree pin at that commit or a descendant. Load HEAD and all pin tips into the edit graph, then reuse the existing Markdown editor, signing, lazy-rebase, ref transaction, and worktree preflight paths so covered forks move together.
---
 gix-tix/spec.md               |   7 ++
 gix-tix/src/command.rs        |  14 ++-
 gix-tix/src/command/reword.rs | 203 ++++++++++++++++++++++++++++++++++
 3 files changed, 223 insertions(+), 1 deletion(-)
 create mode 100644 gix-tix/src/command/reword.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ebe19634f31..c87215d326b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -22,6 +22,13 @@ without trading responsiveness for metadata that is not visible.
   rules. Replay conflicts change nothing unless explicitly materialized; an
   accepted conflict writes the checkout and unmerged index, then exits with an
   error so resolution cannot be mistaken for completion.
+- `tix reword REVSPEC` opens the standard Markdown reword document and applies
+  the same signing, lazy-rebase, mutable-ref, and worktree-safety rules as the
+  TUI. An attached `HEAD` may reword itself without a pin. Every other target
+  requires an existing current-worktree tix pin at that commit or a descendant;
+  every such covering pin participates so retained forks are rewritten together.
+  Eligibility is checked before the editor opens, and an unchanged document is
+  an explicit no-op.
 - `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-w/--worktrees` adds every successfully resolved main and linked worktree
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 032de8460cf..21003c16c80 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -5,6 +5,7 @@ use clap::Parser;
 use gix::prelude::{ObjectIdExt, ReferenceExt};
 
 mod rebase;
+mod reword;
 mod travel;
 
 /// Arguments and commands shared by the standalone `tix` binary and `gix tix`.
@@ -41,6 +42,8 @@ enum Command {
     Pin(Pin),
     /// Travel to a commit while preserving reachable history through tix pins.
     Travel(travel::Args),
+    /// Edit a commit and lazily rebase every descendant retained by a tix pin.
+    Reword(reword::Args),
     /// Generate or apply a self-contained history-rebase todo.
     #[command(subcommand)]
     Rebase(rebase::Command),
@@ -56,7 +59,7 @@ struct Pin {
 #[derive(Debug, clap::Parser)]
 #[command(
     name = "tix",
-    about = "Browse commits or edit the checked-out commit",
+    about = "Browse or edit commit history",
     disable_help_flag = true,
     after_long_help = "Commands which open an editor use Git's normal editor selection. Set GIT_EDITOR=<command> to override it."
 )]
@@ -110,6 +113,7 @@ impl Platform {
             }
             Command::Pin(args) => pin(&repository, args)?,
             Command::Travel(args) => return travel::run(repository, args),
+            Command::Reword(args) => return reword::run(repository, args),
             Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
@@ -270,6 +274,14 @@ mod tests {
         };
         assert!(travel.materialize_conflicts);
         assert_eq!(travel.revision, "HEAD~1");
+        let reword = Cli::try_parse_from(["tix", "reword", "HEAD~2"])
+            .expect("reword parses")
+            .platform
+            .command;
+        let Some(Command::Reword(reword)) = reword else {
+            panic!("reword was expected")
+        };
+        assert_eq!(reword.revision, "HEAD~2");
         assert!(matches!(
             Cli::try_parse_from([
                 "tix",
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
new file mode 100644
index 00000000000..3adb371c550
--- /dev/null
+++ b/gix-tix/src/command/reword.rs
@@ -0,0 +1,203 @@
+use std::ffi::OsString;
+
+use anyhow::{Context, Result};
+
+#[derive(Debug, clap::Args)]
+pub(super) struct Args {
+    /// Revision resolving to the commit whose message should be edited.
+    #[arg(value_name = "REVSPEC")]
+    pub(super) revision: OsString,
+}
+
+pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
+    let revision = gix::path::os_str_into_bstr(&args.revision)
+        .with_context(|| format!("revision {} is not valid UTF-8", args.revision.to_string_lossy()))?;
+    let target = repository
+        .rev_parse_single(revision)
+        .with_context(|| format!("could not resolve revision {revision:?}"))?
+        .object()
+        .context("could not read reword target")?
+        .peel_to_commit()
+        .context("reword target does not resolve to a commit")?
+        .id;
+    let head = repository.head().context("could not read HEAD before rewording")?;
+    let head_id = head.id().map(gix::Id::detach).context("cannot reword an unborn HEAD")?;
+    let attached_head = !head.is_detached() && target == head_id;
+    drop(head);
+
+    let pins = crate::history::all_pins(&repository)?;
+    let mut revisions = vec![OsString::from("HEAD"), OsString::from(target.to_string())];
+    revisions.extend(
+        pins.iter()
+            .map(|pin| gix::path::from_bstr(pin.name.as_bstr()).into_owned().into_os_string()),
+    );
+    let graph = crate::edit::loaded_view_graph_with(&repository, &revisions)?;
+    let covering_pin = pins.iter().any(|pin| graph.is_ancestor(target, pin.id));
+    if !attached_head && !covering_pin {
+        anyhow::bail!("the reword target or one of its descendants must be pinned");
+    }
+
+    let repository_path = repository.git_dir().to_owned();
+    let bare = repository.is_bare();
+    let (editor, document) = crate::edit::reword::document(&repository, target)?;
+    drop(repository);
+    let Some(edited) = crate::edit::edit_document_without_terminal(
+        &editor,
+        &document,
+        &format!("tix-reword-{}-{}.md", std::process::id(), target.to_hex_with_len(7)),
+    )?
+    else {
+        println!("no reword performed: the editor document was unchanged");
+        return Ok(());
+    };
+
+    let mut repository = crate::open_repository(&repository_path, bare, false)
+        .context("could not reopen repository after editing commit")?;
+    repository.object_cache_size(None);
+    match crate::edit::reword::apply(repository, &graph, target, &edited)? {
+        Some(id) => println!("{}", id.to_hex_with_len(7)),
+        None => println!("no reword performed: the edited commit was unchanged"),
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use gix::bstr::ByteSlice;
+
+    use super::*;
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!("git {} failed: {}", args.join(" "), output.stderr.trim().to_str_lossy()).into());
+        }
+        Ok(output.stdout)
+    }
+
+    fn open(path: &Path, editor: &str) -> gix_testtools::Result<gix::Repository> {
+        Ok(gix::open_opts(
+            path,
+            gix::open::Options::isolated()
+                .config_overrides([format!("core.editor={editor}"), "commit.gpgSign=false".to_owned()]),
+        )?)
+    }
+
+    fn args(revision: &str) -> Args {
+        Args {
+            revision: revision.into(),
+        }
+    }
+
+    #[test]
+    fn attached_head_needs_no_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        run(
+            open(fixture.path(), "sed -i.bak -e 's/^tip$/rewritten tip/'")?,
+            args("HEAD"),
+        )?;
+
+        assert_eq!(git(fixture.path(), &["log", "-1", "--format=%s"])?, b"rewritten tip\n");
+        let repository = crate::open_test_repository(fixture.path())?;
+        assert!(!repository.head()?.is_detached());
+        assert!(crate::history::all_pins(&repository)?.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn detached_head_requires_a_pin_before_the_editor() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        git(fixture.path(), &["checkout", "-q", "--detach", "HEAD"])?;
+        let err = run(open(fixture.path(), "false")?, args("HEAD"))
+            .expect_err("a detached HEAD does not provide a durable rewrite tip");
+        assert!(format!("{err:#}").contains("must be pinned"));
+        assert!(crate::history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty());
+        Ok(())
+    }
+
+    #[test]
+    fn other_targets_require_a_covering_pin_before_the_editor() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        let err = run(open(path, "false")?, args("HEAD~1")).expect_err("an ancestor without a pin is rejected");
+        assert!(format!("{err:#}").contains("must be pinned"));
+
+        let repository = crate::open_test_repository(path)?;
+        let old_tip = repository.head_id()?.detach();
+        repository.reference(
+            "refs/worktree/tix/pins/keep",
+            old_tip,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test pin",
+        )?;
+        drop(repository);
+        run(
+            open(path, "sed -i.bak -e 's/^middle$/rewritten middle/'")?,
+            args("HEAD~1"),
+        )?;
+
+        let repository = crate::open_test_repository(path)?;
+        let new_tip = repository.head_id()?.detach();
+        assert_ne!(new_tip, old_tip, "the descendant is lazily reparented");
+        assert_eq!(
+            repository
+                .find_commit(new_tip)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(repository.rev_parse_single("HEAD~1")?.detach()),
+            "the rewritten descendant points to the edited commit"
+        );
+        assert_eq!(
+            crate::history::all_pins(&repository)?[0].id,
+            new_tip,
+            "the covering pin follows its rewritten descendant"
+        );
+        assert!(
+            repository
+                .find_commit(new_tip)?
+                .decode()?
+                .extra_headers()
+                .find("tix-rebase-parent")
+                .is_some(),
+            "the descendant remains marked for lazy replay"
+        );
+        assert_eq!(
+            git(path, &["log", "-1", "--format=%s", "HEAD~1"])?,
+            b"rewritten middle\n"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn a_pin_can_expose_an_unrelated_reword_stack() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        git(path, &["branch", "side", "HEAD~2"])?;
+        git(path, &["checkout", "-q", "side"])?;
+        git(path, &["commit", "-q", "--allow-empty", "-m", "side"])?;
+        let side = String::from_utf8(git(path, &["rev-parse", "HEAD"])?)?;
+        let side = side.trim();
+        git(path, &["checkout", "-q", "main"])?;
+        git(path, &["update-ref", "refs/worktree/tix/pins/side", side])?;
+        let main = git(path, &["rev-parse", "main"])?;
+
+        run(open(path, "sed -i.bak -e 's/^side$/rewritten side/'")?, args("side"))?;
+
+        assert_eq!(
+            git(path, &["rev-parse", "main"])?,
+            main,
+            "the unrelated checkout stack is untouched"
+        );
+        assert_eq!(git(path, &["log", "-1", "--format=%s", "side"])?, b"rewritten side\n");
+        let repository = crate::open_test_repository(path)?;
+        assert_eq!(
+            crate::history::all_pins(&repository)?[0].id,
+            repository.rev_parse_single("side")?.detach(),
+            "the explicit unrelated pin follows the rewritten commit"
+        );
+        Ok(())
+    }
+}

From e02ff5177a8ccc96b8b09144ce5654d666d23db4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 15 Aug 2026 21:09:05 +0200
Subject: [PATCH 136/282] feat: reword commits without opening an editor

Command-line rewording previously always opened Git's configured editor, even when an agent or script already had the complete replacement message. That made otherwise automatable history edits depend on terminal editor setup and temporary files.

Add mutually exclusive -m/--message and -f/--file inputs. Repeated messages form paragraphs, while -f - consumes standard input. Explicit messages bypass editor discovery and suggested trailers, retain comment-looking content, and reuse the existing signing, lazy-rebase, mutable-reference, pin, and worktree-safety path.

Normalize explicit messages with the same whitespace rules as editor input, but without editor-only comment stripping. Avoid rewriting an unchanged message so its committer timestamp and identity remain stable, and document and test file, stdin, repeated-message, no-op, and validation behavior.
---
 gix-tix/spec.md               |  15 +++--
 gix-tix/src/command.rs        |  14 ++++
 gix-tix/src/command/reword.rs | 117 +++++++++++++++++++++++++++++++++-
 gix-tix/src/edit/reword.rs    |  46 +++++++++++--
 4 files changed, 182 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c87215d326b..6812cc7ead2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -22,10 +22,14 @@ without trading responsiveness for metadata that is not visible.
   rules. Replay conflicts change nothing unless explicitly materialized; an
   accepted conflict writes the checkout and unmerged index, then exits with an
   error so resolution cannot be mistaken for completion.
-- `tix reword REVSPEC` opens the standard Markdown reword document and applies
-  the same signing, lazy-rebase, mutable-ref, and worktree-safety rules as the
-  TUI. An attached `HEAD` may reword itself without a pin. Every other target
-  requires an existing current-worktree tix pin at that commit or a descendant;
+- `tix reword REVSPEC [-m MESSAGE ... | -f FILE]` applies the same signing,
+  lazy-rebase, mutable-ref, and worktree-safety rules as the TUI. Without either
+  message option it opens the standard Markdown reword document. Repeated
+  `-m/--message` values form paragraphs; `-f/--file` reads the complete message
+  from a file, or from standard input when given `-`. Explicit sources bypass
+  the editor and do not add suggested trailers. An attached `HEAD` may reword
+  itself without a pin. Every other target requires an existing current-worktree
+  tix pin at that commit or a descendant;
   every such covering pin participates so retained forks are rewritten together.
   Eligibility is checked before the editor opens, and an unchanged document is
   an explicit no-op.
@@ -404,6 +408,9 @@ space first; changes blocks adapt within the remaining history width.
   time travel; the edited commit itself needs no replay marker.
   Mutable refs follow every rewritten commit; tags and remote-tracking refs remain
   unchanged.
+- Command-line message inputs replace only the message, retain
+  editor-comment-looking lines as content, and are a no-op when their cleaned
+  message already matches the commit.
 - Editor, signing, parsing, writing, or reference-update failures are shown in
   the main status line and do not leave a repository retained by the UI.
 
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 21003c16c80..cbd5acd15b1 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -282,6 +282,20 @@ mod tests {
             panic!("reword was expected")
         };
         assert_eq!(reword.revision, "HEAD~2");
+        assert!(reword.message.is_empty());
+        assert!(reword.file.is_none());
+        let reword = Cli::try_parse_from(["tix", "reword", "HEAD~2", "-m", "title", "-m", "body"])
+            .expect("reword messages parse")
+            .platform
+            .command;
+        let Some(Command::Reword(reword)) = reword else {
+            panic!("reword was expected")
+        };
+        assert_eq!(reword.message, ["title", "body"]);
+        assert!(
+            Cli::try_parse_from(["tix", "reword", "HEAD", "-m", "message", "-f", "message.txt"]).is_err(),
+            "message and file inputs are mutually exclusive"
+        );
         assert!(matches!(
             Cli::try_parse_from([
                 "tix",
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 3adb371c550..d496976dedb 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -1,4 +1,8 @@
-use std::ffi::OsString;
+use std::{
+    ffi::OsString,
+    io::Read,
+    path::{Path, PathBuf},
+};
 
 use anyhow::{Context, Result};
 
@@ -7,6 +11,12 @@ pub(super) struct Args {
     /// Revision resolving to the commit whose message should be edited.
     #[arg(value_name = "REVSPEC")]
     pub(super) revision: OsString,
+    /// Use this message instead of opening an editor; repeat to add paragraphs.
+    #[arg(short = 'm', long, value_name = "MESSAGE", conflicts_with = "file")]
+    pub(super) message: Vec<OsString>,
+    /// Read the new message from this file, or from standard input with `-`.
+    #[arg(short = 'f', long, value_name = "FILE", conflicts_with = "message")]
+    pub(super) file: Option<PathBuf>,
 }
 
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
@@ -37,6 +47,12 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         anyhow::bail!("the reword target or one of its descendants must be pinned");
     }
 
+    if let Some(message) = explicit_message(&args, std::io::stdin())? {
+        return finish(crate::edit::reword::apply_message(
+            repository, &graph, target, &message,
+        )?);
+    }
+
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
     let (editor, document) = crate::edit::reword::document(&repository, target)?;
@@ -54,7 +70,41 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    match crate::edit::reword::apply(repository, &graph, target, &edited)? {
+    finish(crate::edit::reword::apply(repository, &graph, target, &edited)?)
+}
+
+fn explicit_message(args: &Args, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
+    if !args.message.is_empty() {
+        let mut out = Vec::new();
+        for (index, message) in args.message.iter().enumerate() {
+            if index > 0 {
+                out.extend_from_slice(b"\n\n");
+            }
+            out.extend_from_slice(
+                gix::path::os_str_into_bstr(message)
+                    .with_context(|| format!("message {} is not valid UTF-8", index + 1))?,
+            );
+        }
+        return Ok(Some(out));
+    }
+    let Some(path) = args.file.as_deref() else {
+        return Ok(None);
+    };
+    if path == Path::new("-") {
+        let mut out = Vec::new();
+        stdin
+            .read_to_end(&mut out)
+            .context("could not read the commit message from standard input")?;
+        Ok(Some(out))
+    } else {
+        std::fs::read(path)
+            .with_context(|| format!("could not read commit message at {}", path.display()))
+            .map(Some)
+    }
+}
+
+fn finish(outcome: Option<gix::ObjectId>) -> Result<()> {
+    match outcome {
         Some(id) => println!("{}", id.to_hex_with_len(7)),
         None => println!("no reword performed: the edited commit was unchanged"),
     }
@@ -88,9 +138,72 @@ mod tests {
     fn args(revision: &str) -> Args {
         Args {
             revision: revision.into(),
+            message: Vec::new(),
+            file: None,
         }
     }
 
+    #[test]
+    fn explicit_message_sources_are_complete_and_git_like() -> gix_testtools::Result {
+        let mut message_args = args("HEAD");
+        message_args.message = vec!["title".into(), "body".into()];
+        assert_eq!(
+            explicit_message(&message_args, &b"ignored"[..])?,
+            Some(b"title\n\nbody".to_vec()),
+            "repeated messages become paragraphs without reading stdin"
+        );
+
+        let mut file_args = args("HEAD");
+        file_args.file = Some("-".into());
+        assert_eq!(
+            explicit_message(&file_args, &b"from stdin\n"[..])?,
+            Some(b"from stdin\n".to_vec()),
+            "a dash reads the entire message from stdin"
+        );
+
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path().join("message.md");
+        std::fs::write(&path, b"from file\n\nbody\n")?;
+        let mut file_args = args("HEAD");
+        file_args.file = Some(path);
+        assert_eq!(
+            explicit_message(&file_args, &b"ignored"[..])?,
+            Some(b"from file\n\nbody\n".to_vec()),
+            "a file supplies the complete message"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn message_bypasses_the_editor_and_rewords_head() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let mut initial = args("HEAD");
+        initial.message = vec!["replacement title".into(), ";literal body".into()];
+        run(open(fixture.path(), "false")?, initial)?;
+
+        assert_eq!(
+            git(fixture.path(), &["log", "-1", "--format=%B"])?,
+            b"replacement title\n\n;literal body\n\n",
+            "an explicit message bypasses the editor and retains editor-comment-looking lines"
+        );
+        let rewritten = git(fixture.path(), &["rev-parse", "HEAD"])?;
+        let mut same = args("HEAD");
+        same.message = vec!["replacement title\n\n;literal body".into()];
+        run(open(fixture.path(), "false")?, same)?;
+        assert_eq!(
+            git(fixture.path(), &["rev-parse", "HEAD"])?,
+            rewritten,
+            "an unchanged explicit message does not rewrite the commit"
+        );
+
+        let mut empty = args("HEAD");
+        empty.message = vec!["   ".into()];
+        let err = run(open(fixture.path(), "false")?, empty)
+            .expect_err("an empty cleaned message must not replace the commit message");
+        assert!(format!("{err:#}").contains("message is empty"));
+        Ok(())
+    }
+
     #[test]
     fn attached_head_needs_no_pin() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 8bea2efd2f5..99dffd8fcbf 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -90,8 +90,43 @@ pub(crate) fn apply(
     commit.author = actor(edit.author, edit.author_time, "author")?;
     commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
     commit.message = edit.message;
+    apply_commit(&repo, graph, old_id, commit)
+}
+
+#[tracing::instrument(skip_all, fields(commit_id = %old_id))]
+pub(crate) fn apply_message(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    message: &[u8],
+) -> Result<Option<gix::ObjectId>> {
+    let message = cleanup_message(message, None);
+    if message.is_empty() {
+        anyhow::bail!("the edited commit message is empty");
+    }
+    let mut commit = repo
+        .find_commit(old_id)
+        .context("could not find commit to reword")?
+        .decode()
+        .context("could not decode commit to reword")?
+        .into_owned()
+        .context("could not own commit to reword")?;
+    if commit.message == message {
+        return Ok(None);
+    }
+    commit.committer.time = gix::date::Time::now_local_or_utc();
+    commit.message = message;
+    apply_commit(&repo, graph, old_id, commit)
+}
+
+fn apply_commit(
+    repo: &gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    commit: gix::objs::Commit,
+) -> Result<Option<gix::ObjectId>> {
     let outcome = rebase::perform(
-        &repo,
+        repo,
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
@@ -148,7 +183,10 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
     if parts.next().map(trim_cr) != Some(&[][..]) {
         anyhow::bail!("expected an empty line after the commit headers");
     }
-    let message = cleanup_message(parts.next().context("the commit message is missing")?, comment_char);
+    let message = cleanup_message(
+        parts.next().context("the commit message is missing")?,
+        Some(comment_char),
+    );
     Ok(Edit {
         author,
         author_time,
@@ -158,12 +196,12 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
     })
 }
 
-fn cleanup_message(input: &[u8], comment_char: &[u8]) -> BString {
+fn cleanup_message(input: &[u8], comment_char: Option<&[u8]>) -> BString {
     let mut out = Vec::new();
     let mut empty_lines = 0;
     for line in input.lines_with_terminator() {
         let line = trim_cr(line.strip_suffix(b"\n").unwrap_or(line));
-        if line.starts_with(comment_char) {
+        if comment_char.is_some_and(|comment_char| line.starts_with(comment_char)) {
             continue;
         }
         let line = &line[..line

From bc01f726cf0dcf586238410fdbee40eccb6d168b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 04:47:36 +0200
Subject: [PATCH 137/282] fix: use the current committer for rewritten commits

Rewording previously retained the selected commit's old or editor-provided committer while only some descendant rewrite paths installed the repository identity. Inserted, split, and review-related paths also depended on their callers remembering to update the actor before signing.

Make the configured operation committer a required argument of the shared commit writer and assign it before signature handling. This gives every newly written rewrite the same current identity and date, ensures signatures cover those final fields, and leaves truly untouched objects alone. Reword templates still expose committer fields for context, but initialize them from repository configuration and cannot use them to override the write-time identity.
---
 gix-tix/spec.md                               |  7 ++-
 gix-tix/src/edit/rebase.rs                    | 35 +++++++++----
 gix-tix/src/edit/reword.rs                    | 50 ++++++++++++++++---
 ..._rebase__tests__reworded-middle-stack.snap |  6 +--
 4 files changed, 77 insertions(+), 21 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6812cc7ead2..c5dcf5208d2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -393,7 +393,8 @@ space first; changes blocks adapt within the remaining history width.
 - The configured Git editor receives a document containing `Author`,
   `AuthorDate`, `Committer`, `CommitterDate`, `CommentChar`, and the complete
   message in a temporary `.md` file for syntax highlighting. Author identity and
-  time are retained; committer time defaults to now.
+  time are retained; the committer fields show the repository's configured
+  current committer.
 - `CommentChar` is a non-empty single-line byte prefix, defaults to `;`, and is
   recognized only at column zero. Parsing removes those lines and applies
   Git-style whitespace cleanup.
@@ -408,6 +409,10 @@ space first; changes blocks adapt within the remaining history width.
   time travel; the edited commit itself needs no replay marker.
   Mutable refs follow every rewritten commit; tags and remote-tracking refs remain
   unchanged.
+- Every commit object actually rewritten by an edit receives the repository's
+  current committer identity and date immediately before signing and writing.
+  Edited committer fields cannot override it; untouched commit objects retain
+  their existing identity and object ID.
 - Command-line message inputs replace only the message, retain
   editor-comment-looking lines as content, and are a no-op when their cleaned
   message already matches the commit.
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 43d0cfeeaf6..d391ecabf05 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -510,7 +510,13 @@ fn perform_inner(
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        let id = write_commit(&repo, commit, CommitState::Unmarked(signature), signing.clone())?;
+        let id = write_commit(
+            &repo,
+            commit,
+            &committer,
+            CommitState::Unmarked(signature),
+            signing.clone(),
+        )?;
         selected = Some(id);
         if inserted {
             if let Some(root) = root {
@@ -559,9 +565,6 @@ fn perform_inner(
             .iter()
             .filter_map(|parent| rewritten.get(parent).copied().unwrap_or(Some(*parent)))
             .collect();
-        if Some(old_id) != root || repeat {
-            commit.committer = committer.clone();
-        }
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
         let original_parents =
             recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
@@ -617,7 +620,7 @@ fn perform_inner(
         } else {
             CommitState::Unmarked(signature)
         };
-        let new_id = write_commit(&repo, commit, state, signing.clone())?;
+        let new_id = write_commit(&repo, commit, &committer, state, signing.clone())?;
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
@@ -628,6 +631,7 @@ fn perform_inner(
                 let upper_id = write_commit(
                     &repo,
                     upper,
+                    &committer,
                     CommitState::Unmarked(Signature::RedoIfNeeded),
                     signing.clone(),
                 )?;
@@ -736,7 +740,6 @@ pub(super) fn finish_review(
                 .collect()
         };
         commit.parents = new_parents.into_iter().collect();
-        commit.committer = committer.clone();
         if *old == review {
             commit.extra_headers.retain(|(name, value)| {
                 !(name.as_slice() == MARKER
@@ -746,6 +749,7 @@ pub(super) fn finish_review(
         let new = write_commit(
             &repo,
             commit,
+            &committer,
             CommitState::Unmarked(Signature::RedoIfNeeded),
             signing.clone(),
         )?;
@@ -786,10 +790,10 @@ pub(super) fn finish_review(
             })
             .collect();
         commit.parents = new_parents.into_iter().collect();
-        commit.committer = committer.clone();
         let new = write_commit(
             &repo,
             commit,
+            &committer,
             CommitState::Pending {
                 original_parent: old_parents.first().copied(),
             },
@@ -1030,7 +1034,6 @@ pub(crate) fn perform_plan_with_progress(
             squash_message(&repo, &mut commit, &squashed[..applied])?;
         }
         commit.parents = [parent].into_iter().collect();
-        commit.committer = committer.clone();
         let state = if step_conflict.is_some() {
             CommitState::Unmarked(Signature::InvalidateExisting)
         } else if eager {
@@ -1041,7 +1044,7 @@ pub(crate) fn perform_plan_with_progress(
                 original_parent: recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
             }
         };
-        let (new_id, signing_time) = write_commit_timed(&repo, commit, state, signing.clone())?;
+        let (new_id, signing_time) = write_commit_timed(&repo, commit, &committer, state, signing.clone())?;
         if let Some(elapsed) = signing_time {
             progress.signed += 1;
             progress.signing_time += elapsed;
@@ -1696,18 +1699,21 @@ pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
 fn write_commit(
     repo: &gix::Repository,
     commit: gix::objs::Commit,
+    committer: &gix::actor::Signature,
     state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<ObjectId> {
-    Ok(write_commit_timed(repo, commit, state, signing)?.0)
+    Ok(write_commit_timed(repo, commit, committer, state, signing)?.0)
 }
 
 fn write_commit_timed(
     repo: &gix::Repository,
     mut commit: gix::objs::Commit,
+    committer: &gix::actor::Signature,
     state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<(ObjectId, Option<Duration>)> {
+    commit.committer = committer.clone();
     let signature = match state {
         CommitState::Unmarked(signature) => {
             marker(&mut commit, false, None);
@@ -2090,6 +2096,15 @@ mod tests {
             old_tip_tree,
             "a reword preserves descendant trees"
         );
+        for id in [new_middle, new_tip] {
+            let commit = repo.find_commit(id)?.decode()?.into_owned()?;
+            assert_eq!(commit.committer.name, b"rebasing committer".as_bstr());
+            assert_eq!(commit.committer.email, b"rebasing@example.com".as_bstr());
+            assert_eq!(
+                commit.committer.time.seconds, 978_307_200,
+                "every rewritten commit receives the operation's current committer date"
+            );
+        }
         insta::assert_snapshot!(
             "reworded-middle-stack",
             gix_testtools::repository::snapshot(fixture.path())?.to_string()
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 99dffd8fcbf..ff332b099fc 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -23,17 +23,22 @@ pub(super) struct Edit<'a> {
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
     let editor = repo.editor().context("no Git editor is available")?;
-    let mut commit = repo
+    let commit = repo
         .find_commit(id)
         .context("could not find commit to reword")?
         .decode()
         .context("could not decode commit to reword")?
         .into_owned()
         .context("could not own commit to reword")?;
-    commit.committer.time = gix::date::Time::now_local_or_utc();
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()
+        .context("could not own the Git committer")?;
 
     let mut out = Vec::new();
-    write_headers(&mut out, &commit.author, &commit.committer)?;
+    write_headers(&mut out, &commit.author, &committer)?;
     out.push(b'\n');
     out.extend_from_slice(&commit.message);
     if !out.ends_with(b"\n") {
@@ -114,7 +119,6 @@ pub(crate) fn apply_message(
     if commit.message == message {
         return Ok(None);
     }
-    commit.committer.time = gix::date::Time::now_local_or_utc();
     commit.message = message;
     apply_commit(&repo, graph, old_id, commit)
 }
@@ -292,11 +296,25 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
         let repository = gix::open_opts(
             fixture,
-            gix::open::Options::isolated().config_overrides(["core.editor=:".to_owned()]),
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "committer.name=Current Committer".to_owned(),
+                "committer.email=current@example.com".to_owned(),
+                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
+            ]),
         )?;
         let topic = repository.find_reference("refs/heads/topic")?.id().detach();
         let (editor, document) = document(&repository, topic)?;
         assert_eq!(editor, ":", "the configured editor is returned");
+        let edit = parse(&document)?;
+        assert_eq!(
+            edit.committer, b"Current Committer <current@example.com>",
+            "the template shows the repository's current committer"
+        );
+        assert_eq!(
+            edit.committer_time.seconds, 978_307_200,
+            "the configured committer date is shown"
+        );
         assert!(
             document
                 .windows(b"CommentChar: ;\n\n".len())
@@ -354,14 +372,32 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repository = gix::open_opts(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides(["core.editor=:".to_owned()]),
+            gix::open::Options::isolated().config_overrides([
+                "core.editor=:".to_owned(),
+                "committer.name=Current Committer".to_owned(),
+                "committer.email=current@example.com".to_owned(),
+                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
+            ]),
         )?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         let (_, document) = document(&repository, middle)?;
-        let edited = document.replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
+        let edited = document
+            .replacen(
+                b"Committer: Current Committer <current@example.com>",
+                b"Committer: Edited Committer <edited@example.com>",
+                1,
+            )
+            .replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
         let graph = super::super::loaded_graph(&repository)?;
         let new_middle = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
         let new_tip = repository.head_id()?.detach();
+        let rewritten = repository.find_commit(new_middle)?.decode()?.into_owned()?;
+        assert_eq!(rewritten.committer.name, b"Current Committer".as_bstr());
+        assert_eq!(rewritten.committer.email, b"current@example.com".as_bstr());
+        assert_eq!(
+            rewritten.committer.time.seconds, 978_307_200,
+            "edited committer fields cannot override the current repository committer"
+        );
         assert!(
             !rebase::is_pending(&repository.find_commit(new_middle)?.decode()?.into_owned()?),
             "the reworded commit already has its final tree, parent, and signature"
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
index 33e89295f05..a338b704d01 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
@@ -21,7 +21,7 @@ C1
   tree T0
   parent C0
   author author <author@example.com> 946771200 +0000
-  committer committer <committer@example.com> 946771200 +0000
+  committer rebasing committer <rebasing@example.com> 978307200 +0000
   
   rewritten middle
 
@@ -45,12 +45,12 @@ tree = T1
 100644 file "tip" = "tip\n"
 
 [objects]
-C1 = 347d88644e1829f6255a5d6dc8721a29fa8352f4
 C0 = 5295d5ce934d18b6a1f48c3b7d836d53b55304e5
 T0 = 559dc660acc84805fedbcb75588371240372c173
 T1 = 569961a34e2a909d8c7a2940ed4ad365504e64ed
+C2 = 5d165c738be9924177bbbcd2e6a6060b488828ca
+C1 = 77dcc6c97954f7c6ffada274193c390913821435
 T2 = 8552142164d268c95f60dabb74465a2f4ffb51b7
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
-C2 = e2722ab1d7aeafc5fb8cddb4a8e504cfa7855b85
 B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a

From cbe08dac0ab8e0946eee3a156355dcc96613e9c3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 04:49:39 +0200
Subject: [PATCH 138/282] feat: emphasize active tix shortcut prefixes

Expanded shortcut groups previously differed from their collapsed form primarily through parentheses and an underlined key. That cue was easy to miss in the dense history footer, particularly when deciding whether the next key would invoke a direct action or a prefixed one.

Reverse every cell belonging to the open view, edit, or information group while preserving its existing colors, dimmed toggles, and underlines. Keep separators and neighboring top-level actions outside the reversed range so the active mode has a strong, theme-independent boundary.
---
 gix-tix/spec.md   |  5 +++--
 gix-tix/src/ui.rs | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c5dcf5208d2..ab246b5ba73 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -219,8 +219,9 @@ for signature verification, alignment, message, and changes actions, but these
 actions retain their direct shortcuts while the group is closed. While expanded,
 the group visually contains every following status action through `<enter> diff`,
 including pane switching and navigation; none of those hints is visible while
-the group is closed, and quit remains outside it. The footer
-underlines the `v` in `view`; while active, `view (` contains
+the group is closed, and quit remains outside it. The footer underlines the `v`
+in `view`; an open prefix reverses its complete expanded group for a strong,
+terminal-theme-independent cue. While active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index aec98254450..5642fbbf0b5 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -878,6 +878,7 @@ pub(crate) fn draw_with_worktree(
                 }
             }
             edit_prefix_spans.push(Span::raw(")"));
+            emphasize_prefix(&mut edit_prefix_spans[1..]);
         } else if !app.history_display_expanded {
             edit_prefix_spans.push(Span::raw(" · "));
             edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
@@ -929,6 +930,7 @@ pub(crate) fn draw_with_worktree(
             ));
         }
         view_prefix_spans.push(Span::raw(")"));
+        emphasize_prefix(&mut view_prefix_spans[1..]);
     } else {
         view_prefix_spans.push(Span::raw(" · "));
         view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
@@ -946,6 +948,7 @@ pub(crate) fn draw_with_worktree(
     ordered.push(Span::raw(" · "));
     ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     ordered.push(Span::raw(" · "));
+    let information_prefix_start = app.information_expanded.then_some(ordered.len());
     ordered.push(Span::styled("?", Style::default().add_modifier(Modifier::UNDERLINED)));
     if app.information_expanded {
         ordered.push(Span::raw(" ("));
@@ -981,6 +984,7 @@ pub(crate) fn draw_with_worktree(
             footer_spans.push(Span::raw(" · <enter> diff"));
         }
         footer_spans.push(Span::raw(")"));
+        emphasize_prefix(&mut footer_spans[information_prefix_start.expect("the prefix is expanded")..]);
     }
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · "));
@@ -1623,6 +1627,12 @@ fn shortcut(label: &'static str, key: char, enabled: bool) -> Vec<Span<'static>>
     ]
 }
 
+fn emphasize_prefix(spans: &mut [Span<'_>]) {
+    for span in spans {
+        span.style = span.style.add_modifier(Modifier::REVERSED);
+    }
+}
+
 fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
     let mut out = Vec::with_capacity(spans.len());
     for span in spans {
@@ -2924,6 +2934,7 @@ mod tests {
                 .contains(Modifier::UNDERLINED),
             "the prefix key is underlined in its verb"
         );
+        assert_reversed_group(&terminal, 1, view);
 
         app.history_display_expanded = false;
         app.edit_expanded = true;
@@ -2932,6 +2943,7 @@ mod tests {
             rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · refs · ?"),
             "the edit prefix follows the view prefix even when no action is available"
         );
+        assert_reversed_group(&terminal, 1, "edit (no actions)");
 
         app.edit_expanded = false;
         app.information_expanded = true;
@@ -2943,6 +2955,11 @@ mod tests {
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
+        assert_reversed_group(
+            &terminal,
+            1,
+            "? ([ align · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
+        );
         Ok(())
     }
 
@@ -5108,6 +5125,24 @@ mod tests {
         })
     }
 
+    fn assert_reversed_group(terminal: &Terminal<TestBackend>, y: u16, group: &str) {
+        let line = rendered_line(terminal, y);
+        let start = line[..line.find(group).expect("the active prefix group is visible")]
+            .chars()
+            .count() as u16;
+        let end = start + group.chars().count() as u16;
+        let buffer = terminal.backend().buffer();
+        assert!(
+            (start..end).all(|x| buffer[(x, y)].modifier.contains(Modifier::REVERSED)),
+            "every cell in {group:?} is reversed"
+        );
+        assert!(
+            !buffer[(start - 1, y)].modifier.contains(Modifier::REVERSED)
+                && !buffer[(end, y)].modifier.contains(Modifier::REVERSED),
+            "the active treatment is bounded to {group:?}"
+        );
+    }
+
     fn footer_is_dim(terminal: &Terminal<TestBackend>, label: &str) -> bool {
         let y = terminal.backend().buffer().area.height - 1;
         let footer = rendered_line(terminal, y);

From 8212d3a8d6d1005cf685a9e7f63b41332196c84c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 04:56:36 +0200
Subject: [PATCH 139/282] Cover review splicing below existing successors

Review completion has to combine two independently evolving lines: review commits created from the chosen base and the target history already descending from the reviewed commit. Losing either side would silently discard work even though the review model specifies that the review line is inserted between them.

Exercise base <- B <- A while reviewing B from base, add new review content, and create a review-side successor before finishing. The assertions and complete repository snapshot require the result to remain base <- B <- review <- review successor <- A, with A still at the target branch tip and marked for lazy replay. Fix the fixture clock so commit IDs and the recorded original-parent marker remain deterministic.
---
 gix-tix/src/edit/review.rs                    | 126 +++++++++++++++++-
 ...tests__changed-review-with-successors.snap |  72 ++++++++++
 2 files changed, 197 insertions(+), 1 deletion(-)
 create mode 100644 gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap

diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 60d4a8149f2..102a35bda59 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -291,7 +291,13 @@ mod tests {
     use super::*;
 
     fn run(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
-        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        let output = Command::new("git")
+            .arg("-C")
+            .arg(path)
+            .args(args)
+            .env("GIT_AUTHOR_DATE", "2001-01-01T00:00:00 +0000")
+            .env("GIT_COMMITTER_DATE", "2001-01-01T00:00:00 +0000")
+            .output()?;
         if !output.status.success() {
             return Err(format!(
                 "git {} failed: {}",
@@ -465,4 +471,122 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn a_changed_review_and_its_successors_are_spliced_before_target_successors() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        run(fixture.path(), &["init", "-q", "-b", "main"])?;
+        run(fixture.path(), &["config", "user.name", "reviewer"])?;
+        run(fixture.path(), &["config", "user.email", "reviewer@example.com"])?;
+        run(
+            fixture.path(),
+            &["config", "gitoxide.commit.authorDate", "2001-01-01T00:00:00 +0000"],
+        )?;
+        run(
+            fixture.path(),
+            &["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000"],
+        )?;
+        std::fs::write(fixture.path().join("file"), "base\n")?;
+        run(fixture.path(), &["add", "file"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "base"],
+        )?;
+        let base = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("file"), "B\n")?;
+        run(fixture.path(), &["-c", "commit.gpgSign=false", "commit", "-qam", "B"])?;
+        let reviewed = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("successor"), "A\n")?;
+        run(fixture.path(), &["add", "successor"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "A"],
+        )?;
+        let old_successor = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+
+        let open = || {
+            gix::open_opts(
+                fixture.path(),
+                gix::open::Options::isolated().config_overrides([
+                    "user.name=reviewer".to_owned(),
+                    "user.email=reviewer@example.com".to_owned(),
+                    "commit.gpgSign=false".to_owned(),
+                ]),
+            )
+        };
+        let repo = open()?;
+        let graph = super::super::loaded_graph(&repo)?;
+        drop(repo);
+        start(fixture.path(), false, &graph, reviewed, base)?;
+
+        std::fs::write(fixture.path().join("reviewed"), "new review change\n")?;
+        run(fixture.path(), &["add", "file", "reviewed"])?;
+        let repo = open()?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let review = super::super::head::perform(repo, &graph, super::super::head::Kind::Amend, None)?
+            .expect("the staged review change amends the review commit");
+        let review_successor = ObjectId::from_hex(
+            run(
+                fixture.path(),
+                &[
+                    "-c",
+                    "commit.gpgSign=false",
+                    "commit-tree",
+                    &format!("{review}^{{tree}}"),
+                    "-p",
+                    &review.to_string(),
+                    "-m",
+                    "review successor",
+                ],
+            )?
+            .trim(),
+        )?;
+        run(
+            fixture.path(),
+            &[
+                "update-ref",
+                "refs/heads/review-successor",
+                &review_successor.to_string(),
+            ],
+        )?;
+
+        let repo = open()?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let finished = finish(repo, &graph, review)?;
+        let repo = open()?;
+        let successor = repo.find_reference("refs/heads/main")?.id().detach();
+        assert_ne!(successor, old_successor, "the branch successor is rewritten");
+        assert_eq!(
+            repo.find_commit(finished)?.parent_ids().next().map(gix::Id::detach),
+            Some(reviewed),
+            "the finished review is inserted directly after B"
+        );
+        assert_eq!(
+            repo.find_commit(successor)?.parent_ids().next().map(gix::Id::detach),
+            Some(repo.find_reference("refs/heads/review-successor")?.id().detach()),
+            "A remains the branch tip and follows the review-side history"
+        );
+        let review_successor = repo.find_reference("refs/heads/review-successor")?.id().detach();
+        assert_eq!(
+            repo.find_commit(review_successor)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(finished),
+            "the review successor is inserted before the target history successor"
+        );
+        assert_eq!(
+            repo.find_commit(successor)?.message_raw()?,
+            b"A\n".as_bstr(),
+            "the target history successor is retained"
+        );
+        assert!(super::super::rebase::has_marker(
+            &repo.find_commit(successor)?.decode()?.into_owned()?
+        ));
+        insta::assert_snapshot!(
+            "changed-review-with-successors",
+            gix_testtools::repository::snapshot(fixture.path())?.to_string()
+        );
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
new file mode 100644
index 00000000000..e6c0193f8cb
--- /dev/null
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -0,0 +1,72 @@
+---
+source: gix-tix/src/edit/review.rs
+expression: "gix_testtools::repository::snapshot(fixture.path())?.to_string()"
+---
+HEAD detached C2
+
+[refs]
+refs/heads/main = C4
+refs/heads/review-successor = C3
+
+[commits]
+C0
+  tree T1
+  author reviewer <reviewer@example.com> 978307200 +0000
+  committer reviewer <reviewer@example.com> 978307200 +0000
+  
+  base
+
+C1
+  tree T0
+  parent C0
+  author reviewer <reviewer@example.com> 978307200 +0000
+  committer reviewer <reviewer@example.com> 978307200 +0000
+  
+  B
+
+C2
+  tree T3
+  parent C1
+  author reviewer <reviewer@example.com> 978307200 +0000
+  committer reviewer <reviewer@example.com> 978307200 +0000
+  
+  review
+
+C3
+  tree T3
+  parent C2
+  author reviewer <reviewer@example.com> 978307200 +0000
+  committer reviewer <reviewer@example.com> 978307200 +0000
+  
+  review successor
+
+C4
+  tree T2
+  parent C3
+  author reviewer <reviewer@example.com> 978307200 +0000
+  committer reviewer <reviewer@example.com> 978307200 +0000
+  tix-rebase-parent 2cb49e443aa675eab8add679938ca6cd303ae353
+  
+  A
+
+[index]
+tree = T3
+100644 B0 stage=0 "file"
+100644 B1 stage=0 "reviewed"
+
+[worktree]
+100644 file "file" = "B\n"
+100644 file "reviewed" = "new review change\n"
+
+[objects]
+C2 = 066adf4b205850540218e32e44576bcb33249572
+B0 = 223b7836fb19fdf64ba2d3cd6173c6a283141f78
+C1 = 2cb49e443aa675eab8add679938ca6cd303ae353
+T0 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
+C4 = 4ec5d7b25bc7415d9243067e231d934cc6952501
+T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+T2 = 74c148aa829dcd83ad2608b6d0862ae1e6981501
+B1 = 8ab2a145f1f16e50d78eaced3311ac16027db494
+T3 = 93664bfc7cc096fcc0d1ac962596031e10f26906
+C0 = c38a9f7427b84ed8ba5e187ec385489d82d71695
+C3 = e0b1ce8b2ac673ea0cc153ca4b8958a3aa315dd0

From 04f271ec018abf1f4c49a5cc3ac7540cb8db85e6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:06:53 +0200
Subject: [PATCH 140/282] Centralize isolated tix test repositories

Tix tests repeatedly assembled isolated open options and copied the same author, committer, signing, editor, and timestamp overrides. That made write-capable fixtures easy to configure inconsistently and obscured the handful of settings that were actually significant to each scenario.

Provide one test-only repository opener with deterministic defaults and an override path whose case-specific settings win. Route fixture-backed tests through it, retain explicit signing and diff configuration where behavior depends on it, and document the convention for future tests.

This reduces fixture boilerplate while preserving isolation from user and environment configuration.
---
 gix-tix/AGENTS.md               |  7 ++++
 gix-tix/src/command.rs          | 11 ++----
 gix-tix/src/command/rebase.rs   | 27 ++++---------
 gix-tix/src/command/reword.rs   | 15 ++++----
 gix-tix/src/command/travel.rs   | 26 ++++++-------
 gix-tix/src/edit/create.rs      |  9 +----
 gix-tix/src/edit/forget.rs      |  8 +---
 gix-tix/src/edit/head.rs        |  8 +---
 gix-tix/src/edit/mod.rs         |  4 +-
 gix-tix/src/edit/rebase.rs      | 15 +++-----
 gix-tix/src/edit/review.rs      | 43 ++++++---------------
 gix-tix/src/edit/reword.rs      | 38 +++++++++----------
 gix-tix/src/edit/split.rs       |  9 +----
 gix-tix/src/edit/stash.rs       |  6 +--
 gix-tix/src/edit/time_travel.rs | 67 +++++++++++++++++----------------
 gix-tix/src/edit/todo.rs        |  9 +----
 gix-tix/src/history.rs          | 44 +++++++++++-----------
 gix-tix/src/lib.rs              | 49 +++++++++---------------
 gix-tix/src/test_repository.rs  | 46 ++++++++++++++++++++++
 19 files changed, 204 insertions(+), 237 deletions(-)
 create mode 100644 gix-tix/src/test_repository.rs

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index ed31d81dea3..fb1e6a7973b 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -12,6 +12,13 @@
   or resource-ownership change to tix. Update the specification and its
   regression coverage in the same semantic patch as the implementation.
 
+## Test repositories
+
+- Open fixture repositories through `crate::test_repository::open()` or
+  `open_with()`. They isolate configuration and provide deterministic author,
+  committer, signing, editor, and date defaults; pass only behavior-specific
+  overrides to `open_with()`, which take precedence over those defaults.
+
 ## Commit authorship
 
 - Create one commit per semantically distinct change. Do not combine independent
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index cbd5acd15b1..5f6aa46978d 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -385,7 +385,7 @@ mod tests {
     #[test]
     fn pin_follows_direct_references_and_keeps_derived_revisions_fixed() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let revisions = |values: &[&str]| values.iter().map(OsString::from).collect::<Vec<_>>();
         let main = repository.rev_parse_single("main")?.detach();
 
@@ -470,13 +470,8 @@ mod tests {
         }
 
         let fixture = gix_testtools::scripted_fixture_writable("split_commit.sh")?;
-        let repository = gix::open_opts(
-            fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=sed -i.bak -e 's/^what$/split/'".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
-        )?;
+        let repository =
+            crate::test_repository::open_with(fixture.path(), ["core.editor=sed -i.bak -e 's/^what$/split/'"])?;
         let graph = crate::edit::loaded_view_graph(&repository)?;
         split(repository, &graph)?;
 
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 4fc5eb9cd69..77241d9984c 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -315,14 +315,9 @@ mod tests {
 
     fn repository() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "core.abbrev=7".to_owned(),
-                "user.name=todo author".to_owned(),
-                "user.email=todo@example.com".to_owned(),
-            ]),
+            ["core.abbrev=7", "user.name=todo author", "user.email=todo@example.com"],
         )?;
         Ok((fixture, repo))
     }
@@ -375,13 +370,9 @@ mod tests {
     #[test]
     fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "commit.gpgSign=false".to_owned(),
-                "user.name=todo author".to_owned(),
-                "user.email=todo@example.com".to_owned(),
-            ]),
+            ["user.name=todo author", "user.email=todo@example.com"],
         )?;
         let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
@@ -435,7 +426,7 @@ mod tests {
             unresolved.stdout, b"file\n",
             "materialization writes the unmerged index"
         );
-        let materialized = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let materialized = crate::test_repository::open(fixture.path())?;
         let conflict_commit = materialized.head_commit()?;
         assert_eq!(
             conflict_commit.tree_id()?.detach(),
@@ -458,13 +449,9 @@ mod tests {
                 .status()?
                 .success()
         );
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "commit.gpgSign=false".to_owned(),
-                "user.name=todo author".to_owned(),
-                "user.email=todo@example.com".to_owned(),
-            ]),
+            ["user.name=todo author", "user.email=todo@example.com"],
         )?;
         apply_document(repo, &continuation, None)?;
         assert!(
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index d496976dedb..952685b687c 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -128,10 +128,9 @@ mod tests {
     }
 
     fn open(path: &Path, editor: &str) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
+        Ok(crate::test_repository::open_with(
             path,
-            gix::open::Options::isolated()
-                .config_overrides([format!("core.editor={editor}"), "commit.gpgSign=false".to_owned()]),
+            [format!("core.editor={editor}")],
         )?)
     }
 
@@ -213,7 +212,7 @@ mod tests {
         )?;
 
         assert_eq!(git(fixture.path(), &["log", "-1", "--format=%s"])?, b"rewritten tip\n");
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert!(!repository.head()?.is_detached());
         assert!(crate::history::all_pins(&repository)?.is_empty());
         Ok(())
@@ -226,7 +225,7 @@ mod tests {
         let err = run(open(fixture.path(), "false")?, args("HEAD"))
             .expect_err("a detached HEAD does not provide a durable rewrite tip");
         assert!(format!("{err:#}").contains("must be pinned"));
-        assert!(crate::history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty());
+        assert!(crate::history::all_pins(&crate::test_repository::open(fixture.path())?)?.is_empty());
         Ok(())
     }
 
@@ -237,7 +236,7 @@ mod tests {
         let err = run(open(path, "false")?, args("HEAD~1")).expect_err("an ancestor without a pin is rejected");
         assert!(format!("{err:#}").contains("must be pinned"));
 
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         let old_tip = repository.head_id()?.detach();
         repository.reference(
             "refs/worktree/tix/pins/keep",
@@ -251,7 +250,7 @@ mod tests {
             args("HEAD~1"),
         )?;
 
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         let new_tip = repository.head_id()?.detach();
         assert_ne!(new_tip, old_tip, "the descendant is lazily reparented");
         assert_eq!(
@@ -305,7 +304,7 @@ mod tests {
             "the unrelated checkout stack is untouched"
         );
         assert_eq!(git(path, &["log", "-1", "--format=%s", "side"])?, b"rewritten side\n");
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         assert_eq!(
             crate::history::all_pins(&repository)?[0].id,
             repository.rev_parse_single("side")?.detach(),
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 68782e4562f..405f1665958 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -98,11 +98,11 @@ mod tests {
     #[test]
     fn attached_past_travel_saves_and_returns_to_the_branch() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repository = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         run(repository, args("HEAD~1"))?;
 
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), middle);
         assert!(repository.head()?.is_detached());
         let pins = crate::history::all_pins(&repository)?;
@@ -114,7 +114,7 @@ mod tests {
         );
 
         run(repository, args("main"))?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head()?.referent_name().map(|name| name.as_bstr().to_owned()),
             Some(b"refs/heads/main".as_bstr().to_owned()),
@@ -122,7 +122,7 @@ mod tests {
         );
         assert!(crate::history::all_pins(&repository)?.is_empty());
         run(repository, args("HEAD"))?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert!(
             !repository.head()?.is_detached(),
             "travelling to the current attached HEAD is a no-op"
@@ -139,16 +139,16 @@ mod tests {
         git(path, &["checkout", "-q", "side"])?;
         git(path, &["commit", "-q", "--allow-empty", "-m", "side"])?;
         git(path, &["checkout", "-q", "--detach", "main~1"])?;
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         run(repository, args("main"))?;
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         assert!(repository.head()?.is_detached());
         assert!(crate::history::all_pins(&repository)?.is_empty());
 
         let before_rejected = repository.head_id()?.detach();
         let err = run(repository, args("HEAD~1")).expect_err("past travel from detached HEAD needs a pin");
         assert!(format!("{err:#}").contains("must be pinned"));
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         assert_eq!(
             repository.head_id()?.detach(),
             before_rejected,
@@ -156,7 +156,7 @@ mod tests {
         );
         let err = run(repository, args("side")).expect_err("sideways travel from detached HEAD needs a pin");
         assert!(format!("{err:#}").contains("must be pinned"));
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         let tip = repository.head_id()?.detach();
         repository.reference(
             "refs/worktree/tix/pins/keep",
@@ -176,7 +176,7 @@ mod tests {
             path,
             &["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000"],
         )?;
-        let repository = crate::open_test_repository(path)?;
+        let repository = crate::test_repository::open(path)?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         std::fs::write(path.join("after"), "after\n")?;
         git(path, &["add", "after"])?;
@@ -194,9 +194,9 @@ mod tests {
         let tip = repository.find_reference("refs/heads/main")?.id().detach();
         drop(repository);
 
-        run(crate::open_test_repository(path)?, args(&root.to_string()))?;
+        run(crate::test_repository::open(path)?, args(&root.to_string()))?;
         let before = gix_testtools::repository::snapshot(path)?;
-        let err = run(crate::open_test_repository(path)?, args(&tip.to_string()))
+        let err = run(crate::test_repository::open(path)?, args(&tip.to_string()))
             .expect_err("a conflict needs explicit materialization");
         assert!(format!("{err:#}").contains("--materialize-conflicts"));
         assert_eq!(
@@ -206,7 +206,7 @@ mod tests {
         );
 
         let err = run(
-            crate::open_test_repository(path)?,
+            crate::test_repository::open(path)?,
             Args {
                 materialize_conflicts: true,
                 revision: tip.to_string().into(),
@@ -215,7 +215,7 @@ mod tests {
         .expect_err("a materialized conflict remains an incomplete command");
         assert!(format!("{err:#}").contains("ready to resolve conflicts"));
         assert!(
-            crate::open_test_repository(path)?
+            crate::test_repository::open(path)?
                 .index_or_empty()?
                 .entries()
                 .iter()
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 7e33bee446b..88cbf8d2ea7 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -305,14 +305,7 @@ mod tests {
     use super::*;
 
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
-            path,
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "user.name=author".to_owned(),
-                "user.email=author@example.com".to_owned(),
-            ]),
-        )?)
+        Ok(crate::test_repository::open(path)?)
     }
 
     fn object_count(path: &Path) -> gix_testtools::Result<Vec<u8>> {
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index 75e743a35f0..eb88a3dddf4 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -113,13 +113,7 @@ mod tests {
     use super::*;
 
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
-            path,
-            gix::open::Options::isolated().config_overrides([
-                "user.name=author".to_owned(),
-                "user.email=author@example.com".to_owned(),
-            ]),
-        )?)
+        Ok(crate::test_repository::open(path)?)
     }
 
     #[test]
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 8e0a0af1d7a..3d36299471b 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -227,13 +227,9 @@ mod tests {
     use super::*;
 
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
+        Ok(crate::test_repository::open_with(
             path,
-            gix::open::Options::isolated().config_overrides([
-                "user.name=editor".to_owned(),
-                "user.email=editor@example.com".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=editor", "user.email=editor@example.com"],
         )?)
     }
 
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 88c3e321fca..3d6ad33e2f0 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -158,7 +158,7 @@ mod tests {
     fn edit_graph_ignores_refs_that_do_not_point_to_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
         git(fixture.path(), &["update-ref", "refs/cache/tree", "HEAD^{tree}"])?;
-        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let head = repo.head_id()?.detach();
         let graph = loaded_graph(&repo)?;
         assert!(graph.parents_of(head).is_some(), "HEAD remains part of the edit graph");
@@ -184,7 +184,7 @@ mod tests {
         git(path, &["update-ref", "refs/heads/unrelated", merge])?;
         git(path, &["checkout", "--detach", head])?;
 
-        let repo = gix::open_opts(path, gix::open::Options::isolated())?;
+        let repo = crate::test_repository::open(path)?;
         let graph = loaded_view_graph(&repo)?;
         let pinned = gix::ObjectId::from_hex(pinned.as_bytes())?;
         let merge = gix::ObjectId::from_hex(merge.as_bytes())?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index d391ecabf05..62e457c1aa2 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -2053,14 +2053,9 @@ mod tests {
     use super::*;
 
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
+        Ok(crate::test_repository::open_with(
             path,
-            gix::open::Options::isolated().config_overrides([
-                "user.name=rebasing committer".to_owned(),
-                "user.email=rebasing@example.com".to_owned(),
-                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=rebasing committer", "user.email=rebasing@example.com"],
         )?)
     }
 
@@ -2783,9 +2778,9 @@ mod tests {
         }
         let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
+            [
                 "user.name=rebasing committer".to_owned(),
                 "user.email=rebasing@example.com".to_owned(),
                 "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
@@ -2796,7 +2791,7 @@ mod tests {
                     "gpg.ssh.allowedSignersFile={}",
                     gix_testtools::signature::fixture("ssh-allowed-signers").display()
                 ),
-            ]),
+            ],
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         let base = repo.rev_parse_single("HEAD~2")?.detach();
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 102a35bda59..28608b1c007 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -334,18 +334,15 @@ mod tests {
         run(fixture.path(), &["branch", "natural"])?;
         run(fixture.path(), &["reset", "--hard", &tip.to_string()])?;
 
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "user.name=reviewer".to_owned(),
-                "user.email=reviewer@example.com".to_owned(),
-            ]),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         drop(repo);
         let started = start(fixture.path(), false, &graph, tip, base)?;
 
-        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repo.head_id()?.detach(),
             started.commit,
@@ -376,24 +373,16 @@ mod tests {
         assert!(run(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty());
 
         run(fixture.path(), &["add", "file"])?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "user.name=reviewer".to_owned(),
-                "user.email=reviewer@example.com".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         let amended = super::super::head::perform(repo, &graph, super::super::head::Kind::Amend, None)?
             .expect("staging the reviewed delta amends it into the review commit");
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "user.name=reviewer".to_owned(),
-                "user.email=reviewer@example.com".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
         assert!(is_review(&repo.find_commit(amended)?.decode()?.into_owned()?));
         assert!(run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty());
@@ -425,17 +414,13 @@ mod tests {
             ],
         )?;
         drop(repo);
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "user.name=reviewer".to_owned(),
-                "user.email=reviewer@example.com".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         let finished = finish(repo, &graph, amended)?;
-        let repo = gix::open_opts(fixture.path(), gix::open::Options::isolated())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert_eq!(repo.head_id()?.detach(), finished);
         assert_eq!(
             repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
@@ -505,13 +490,9 @@ mod tests {
         let old_successor = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
 
         let open = || {
-            gix::open_opts(
+            crate::test_repository::open_with(
                 fixture.path(),
-                gix::open::Options::isolated().config_overrides([
-                    "user.name=reviewer".to_owned(),
-                    "user.email=reviewer@example.com".to_owned(),
-                    "commit.gpgSign=false".to_owned(),
-                ]),
+                ["user.name=reviewer", "user.email=reviewer@example.com"],
             )
         };
         let repo = open()?;
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index ff332b099fc..5a4a3d88792 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -294,14 +294,12 @@ mod tests {
     #[test]
     fn document_does_not_repeat_existing_agent_trailers() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let repository = gix::open_opts(
+        let repository = crate::test_repository::open_with(
             fixture,
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "committer.name=Current Committer".to_owned(),
-                "committer.email=current@example.com".to_owned(),
-                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
-            ]),
+            [
+                "committer.name=Current Committer",
+                "committer.email=current@example.com",
+            ],
         )?;
         let topic = repository.find_reference("refs/heads/topic")?.id().detach();
         let (editor, document) = document(&repository, topic)?;
@@ -370,14 +368,12 @@ mod tests {
     #[test]
     fn marks_only_reworded_descendants_for_lazy_replay() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repository = gix::open_opts(
+        let repository = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "committer.name=Current Committer".to_owned(),
-                "committer.email=current@example.com".to_owned(),
-                "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000".to_owned(),
-            ]),
+            [
+                "committer.name=Current Committer",
+                "committer.email=current@example.com",
+            ],
         )?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         let (_, document) = document(&repository, middle)?;
@@ -416,9 +412,9 @@ mod tests {
         }
         let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repository = gix::open_opts(
+        let repository = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
+            [
                 "commit.gpgSign=true".to_owned(),
                 "gpg.format=ssh".to_owned(),
                 format!("user.signingKey={}", key.display()),
@@ -426,7 +422,7 @@ mod tests {
                     "gpg.ssh.allowedSignersFile={}",
                     gix_testtools::signature::fixture("ssh-allowed-signers").display()
                 ),
-            ]),
+            ],
         )?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         let (_, document) = document(&repository, middle)?;
@@ -462,7 +458,7 @@ mod tests {
         }
         let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let old_id = crate::open_test_repository(fixture.path())?.head_id()?.detach();
+        let old_id = crate::test_repository::open(fixture.path())?.head_id()?.detach();
         let git = |args: &[&str]| -> std::io::Result<std::process::ExitStatus> {
             Command::new("git").arg("-C").arg(fixture.path()).args(args).status()
         };
@@ -473,9 +469,9 @@ mod tests {
             );
         }
 
-        let repository = gix::open_opts(
+        let repository = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
+            [
                 "commit.gpgSign=true".to_owned(),
                 "gpg.format=ssh".to_owned(),
                 format!("user.signingKey={}", key.display()),
@@ -483,7 +479,7 @@ mod tests {
                     "gpg.ssh.allowedSignersFile={}",
                     gix_testtools::signature::fixture("ssh-allowed-signers").display()
                 ),
-            ]),
+            ],
         )?;
         let edited = b"Author: New Author <new-author@example.com>\n\
                        AuthorDate: 2026-08-12 10:20:30 +0200\n\
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 3615776448d..4ff1e74cef7 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -102,14 +102,9 @@ mod tests {
     use super::*;
 
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
-        Ok(gix::open_opts(
+        Ok(crate::test_repository::open_with(
             path,
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "user.name=editor".to_owned(),
-                "user.email=editor@example.com".to_owned(),
-                "commit.gpgSign=false".to_owned(),
-            ]),
+            ["user.name=editor", "user.email=editor@example.com"],
         )?)
     }
 
diff --git a/gix-tix/src/edit/stash.rs b/gix-tix/src/edit/stash.rs
index 4ef2d113857..246146cf3c6 100644
--- a/gix-tix/src/edit/stash.rs
+++ b/gix-tix/src/edit/stash.rs
@@ -403,13 +403,13 @@ mod tests {
         std::fs::write(fixture.path().join("untracked"), "untracked\n")?;
         std::fs::write(fixture.path().join("ignored"), "ignored\n")?;
 
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let repository_path = repo.git_dir().to_owned();
         drop(repo);
         let notice = save_manual(&repository_path, false, head)?;
         assert!(notice.contains("stashed changes"));
 
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), ordinary);
         let name = reference(head)?;
         assert!(repo.try_find_reference(name.as_ref())?.is_some());
@@ -433,7 +433,7 @@ mod tests {
             b"existing worktree change\n",
             "unstashing leaves unrelated worktree changes intact"
         );
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert!(repo.try_find_reference(name.as_ref())?.is_none());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), ordinary);
         Ok(())
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 35fecc89b84..0214e6a8cc1 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -695,7 +695,7 @@ mod tests {
             &["update-ref", name.as_bstr().to_str_lossy().as_ref(), "refs/stash"],
         )?;
         git(fixture.path(), &["stash", "drop", "-q", "stash@{0}"])?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let repository_path = repo.git_dir().to_owned();
         let target = repo.find_reference(name.as_ref())?.target().into_owned();
         Ok((
@@ -758,7 +758,7 @@ mod tests {
             &["stash", "push", "--include-untracked", "-q", "-m", "existing"],
         )?;
         let existing_stash = ObjectId::from_hex(git(fixture.path(), &["rev-parse", "refs/stash"])?.trim())?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let graph = loaded_graph(&repo, &[])?;
         drop(repo);
         let started = super::super::review::start(fixture.path(), false, &graph, tip, base)?;
@@ -786,7 +786,7 @@ mod tests {
             fixture.path(),
             &["update-ref", "refs/worktree/tix/pins/child", &child.to_string()],
         )?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let repository_path = repo.git_dir().to_owned();
         let graph = loaded_graph(&repo, &[])?;
         assert_eq!(
@@ -807,14 +807,14 @@ mod tests {
         );
         let stash_name = super::super::review::stash_reference(started.reference.as_bstr())?;
         assert!(
-            crate::open_test_repository(fixture.path())?
+            crate::test_repository::open(fixture.path())?
                 .try_find_reference(stash_name.as_ref())?
                 .is_none(),
             "no stash is created inside the review tree"
         );
 
         perform(&repository_path, false, tip, &graph, &[started.commit], &[], false)?.complete()?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert!(repo.try_find_reference(stash_name.as_ref())?.is_some());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
         assert!(
@@ -829,7 +829,7 @@ mod tests {
             before,
             "returning through any review descendant restores exact review state"
         );
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert!(repo.try_find_reference(stash_name.as_ref())?.is_none());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
         Ok(())
@@ -845,7 +845,7 @@ mod tests {
         )?;
         let notice = apply_review_stash(&repository_path, false, fixture.path(), stash.clone())?;
         assert!(notice.contains("needs attention"), "the conflict is reported: {notice}");
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         assert!(repo.try_find_reference(stash.name.as_ref())?.is_none());
         assert!(
             repo.index_or_empty()?
@@ -863,7 +863,7 @@ mod tests {
             "the fatal apply failure is reported: {notice}"
         );
         assert!(
-            crate::open_test_repository(fixture.path())?
+            crate::test_repository::open(fixture.path())?
                 .try_find_reference(stash.name.as_ref())?
                 .is_none(),
             "the review stash ref is consumed even when Git cannot apply it"
@@ -874,7 +874,7 @@ mod tests {
     #[test]
     fn nested_review_trees_use_the_nearest_review_root() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let original = repo.head_id()?.detach();
         let mut commit = repo.find_commit(original)?.decode()?.into_owned()?;
         commit.parents = [original].into_iter().collect();
@@ -919,7 +919,7 @@ mod tests {
     #[test]
     fn travels_with_symbolic_and_direct_pins_and_returns() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
@@ -938,7 +938,7 @@ mod tests {
             .complete()?
             .context("time-travel changed HEAD")?;
         assert!(notice.contains("saved pin:"), "{notice}");
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert!(repository.head()?.is_detached(), "travel detaches HEAD");
         assert_eq!(repository.head_id()?.detach(), root);
         let pins = history::all_pins(&repository)?;
@@ -962,7 +962,7 @@ mod tests {
         drop(repository);
 
         perform(&repository_path, false, topic, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
             Some(b"refs/heads/main".into()),
@@ -976,14 +976,14 @@ mod tests {
             .args(["checkout", "--detach", &main.to_hex().to_string()])
             .status()?;
         assert!(detach.success());
-        let graph = loaded_graph(&crate::open_test_repository(fixture.path())?, &[])?;
+        let graph = loaded_graph(&crate::test_repository::open(fixture.path())?, &[])?;
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let pin = history::all_pins(&crate::open_test_repository(fixture.path())?)?
+        let pin = history::all_pins(&crate::test_repository::open(fixture.path())?)?
             .pop()
             .context("direct pin is present")?;
         assert_eq!(pin.target.try_id().map(ToOwned::to_owned), Some(main));
         perform(&repository_path, false, main, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
             "a direct pin returns to detached HEAD"
@@ -996,7 +996,7 @@ mod tests {
     #[test]
     fn returning_to_a_commit_restores_its_manual_stash() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let head = repository.head_id()?.detach();
         let parent = repository
@@ -1019,7 +1019,7 @@ mod tests {
         perform(&repository_path, false, head, &graph, &[], &[], false)?.complete()?;
         assert_eq!(std::fs::read(fixture.path().join("manual-stash"))?, b"saved\n");
         assert!(
-            crate::open_test_repository(fixture.path())?
+            crate::test_repository::open(fixture.path())?
                 .try_find_reference(super::super::stash::reference(head)?.as_ref())?
                 .is_none(),
             "returning consumes the manual stash association"
@@ -1030,7 +1030,7 @@ mod tests {
     #[test]
     fn removes_every_pin_at_the_selected_commit() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let selected = repository.rev_parse_single("main")?.detach();
         let other = repository.rev_parse_single("topic")?.detach();
@@ -1044,7 +1044,7 @@ mod tests {
         drop(repository);
 
         assert_eq!(remove_pins(&repository_path, false, selected)?, 2);
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             history::all_pins(&repository)?
                 .into_iter()
@@ -1059,7 +1059,7 @@ mod tests {
     #[test]
     fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let main = repository.rev_parse_single("main")?.detach();
         let topic = repository.rev_parse_single("topic")?.detach();
@@ -1083,7 +1083,7 @@ mod tests {
         );
 
         perform(&repository_path, false, topic, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), topic);
         let pins = history::all_pins(&repository)?;
         assert_eq!(pins.len(), 1, "sideways travel retains the otherwise lost departure");
@@ -1098,7 +1098,7 @@ mod tests {
     #[test]
     fn explicit_tips_avoid_redundant_pins_and_failed_checkouts_clean_up() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
@@ -1108,7 +1108,7 @@ mod tests {
 
         perform(&repository_path, false, root, &graph, &[], &revisions, false)?.complete()?;
         assert!(
-            history::all_pins(&crate::open_test_repository(fixture.path())?)?.is_empty(),
+            history::all_pins(&crate::test_repository::open(fixture.path())?)?.is_empty(),
             "an explicit tip already retains the former HEAD"
         );
 
@@ -1131,7 +1131,7 @@ mod tests {
             .and_then(Perform::complete)
             .expect_err("Git rejects a conflicting checkout");
         assert!(format!("{err:#}").contains("git checkout failed"));
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
         let pins = history::all_pins(&repository)?;
         assert_eq!(pins.len(), 1, "the destination pin survives a failed checkout");
@@ -1150,7 +1150,7 @@ mod tests {
                 .status()?
                 .success()
         );
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         std::fs::write(fixture.path().join("after"), "after\n")?;
@@ -1186,7 +1186,7 @@ mod tests {
         let tip = repository.find_reference("refs/heads/main")?.id().detach();
         drop(repository);
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         let graph = super::super::loaded_graph(&repository)?;
         let before = gix_testtools::repository::snapshot(fixture.path())?;
 
@@ -1200,7 +1200,7 @@ mod tests {
         );
 
         let (_notice, conflict_id) = conflict.accept()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_id()?.detach(),
             conflict_id,
@@ -1277,7 +1277,8 @@ mod tests {
                 allowed_signers.to_string_lossy().as_ref(),
             ],
         )?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let open = || crate::test_repository::open_with(fixture.path(), ["commit.gpgSign=true"]);
+        let repository = open()?;
         let repository_path = repository.git_dir().to_owned();
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
         let root = repository.rev_parse_single("HEAD~2")?.detach();
@@ -1299,7 +1300,7 @@ mod tests {
             &["checkout", "-q", "--detach", &signed_middle.to_string()],
         )?;
 
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = open()?;
         let graph = super::super::loaded_graph(&repository)?;
         let pending_middle =
             super::super::head::perform(repository.clone(), &graph, super::super::head::Kind::Spill, None)?
@@ -1325,10 +1326,10 @@ mod tests {
         assert!(super::super::rebase::has_marker(&tip_commit));
         drop(repository);
 
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = open()?;
         let graph = super::super::loaded_graph(&repository)?;
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = open()?;
         assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), pending_tip);
         assert!(super::super::rebase::is_pending(
             &repository.find_commit(pending_middle)?.decode()?.into_owned()?
@@ -1341,7 +1342,7 @@ mod tests {
 
         perform(&repository_path, false, pending_middle, &graph, &[], &[], false)?.complete()?;
 
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = open()?;
         let materialized_middle = repository.head_id()?.detach();
         let still_pending_tip = repository.find_reference("refs/heads/main")?.id().detach();
         assert_ne!(materialized_middle, pending_middle);
@@ -1371,7 +1372,7 @@ mod tests {
         drop(repository);
 
         perform(&repository_path, false, still_pending_tip, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::open_test_repository(fixture.path())?;
+        let repository = open()?;
         let tip_commit = repository.find_commit(repository.head_id()?)?;
         assert!(!super::super::rebase::is_pending(&tip_commit.decode()?.into_owned()?));
         assert!(
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index c6cd065b05b..6d0910d7ac9 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1104,14 +1104,9 @@ mod tests {
 
     fn repo() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "core.editor=:".to_owned(),
-                "core.abbrev=7".to_owned(),
-                "user.name=todo author".to_owned(),
-                "user.email=todo@example.com".to_owned(),
-            ]),
+            ["core.abbrev=7", "user.name=todo author", "user.email=todo@example.com"],
         )?;
         Ok((fixture, repo))
     }
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 3f8cdab6689..de629ac2c1d 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1786,7 +1786,7 @@ mod tests {
         let mut events = Vec::new();
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let repo = crate::open_test_repository(path)?;
+        let repo = crate::test_repository::open(path)?;
         load(
             &repo,
             &revisions.iter().map(OsString::from).collect::<Vec<_>>(),
@@ -1871,7 +1871,7 @@ mod tests {
     #[test]
     fn ignores_missing_hidden_revisions_only_if_another_one_resolves() -> gix_testtools::Result {
         let fixture = fixture()?;
-        let repo = crate::open_test_repository(&fixture)?;
+        let repo = crate::test_repository::open(&fixture)?;
         let revisions = ["unknown".into(), "main".into()];
 
         let (available, unavailable) = available_hidden_revisions(&repo, &revisions)?;
@@ -1963,7 +1963,7 @@ mod tests {
     #[test]
     fn snapshots_references_and_symbolic_targets_from_revisions() -> gix_testtools::Result {
         let fixture = fixture()?;
-        let repo = crate::open_test_repository(fixture)?;
+        let repo = crate::test_repository::open(fixture)?;
         let implicit = snapshot(&repo, &[], &[], false)?;
         assert!(
             implicit.view.contains_key(b"HEAD".as_bstr()),
@@ -1997,7 +1997,7 @@ mod tests {
             "not a ref or object id\n",
         )?;
 
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let main = repo.rev_parse_single("main")?.detach();
         let topic = repo.rev_parse_single("topic")?.detach();
         let root = repo.rev_parse_single("main~2")?.detach();
@@ -2058,7 +2058,7 @@ mod tests {
         assert!(with.view_tips.contains(&root));
 
         let linked_path = fixture.path().join("topic-wt");
-        let linked_repo = crate::open_test_repository(&linked_path)?;
+        let linked_repo = crate::test_repository::open(&linked_path)?;
         let linked_worktrees = worktree_checkouts(&linked_repo);
         assert!(
             linked_worktrees
@@ -2084,7 +2084,7 @@ mod tests {
             .args(["checkout", "-q", "--detach", "main~1"])
             .status()?;
         assert!(status.success(), "git detaches the current linked worktree");
-        let detached_repo = crate::open_test_repository(&linked_path)?;
+        let detached_repo = crate::test_repository::open(&linked_path)?;
         let detached_worktrees = worktree_checkouts(&detached_repo);
         let current = detached_worktrees
             .iter()
@@ -2143,7 +2143,7 @@ mod tests {
             .find(|row| !row.metadata_loaded)
             .expect("older graph commits defer metadata");
 
-        let repo = crate::open_test_repository(fixture_path)?;
+        let repo = crate::test_repository::open(fixture_path)?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
         let (metadata, _) = load_metadata(&repo, deferred.id, &authors)?;
@@ -2174,7 +2174,7 @@ mod tests {
             let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
             assert!(status.success(), "git prepares one new commit");
         }
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
         let first = graph.refresh(&repo, &["main".into()], &[], false, &HashSet::new(), &authors)?;
@@ -2190,7 +2190,7 @@ mod tests {
     #[test]
     fn refresh_stops_at_cached_tracking_ancestry() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let main = crate::open_test_repository(fixture.path())?
+        let main = crate::test_repository::open(fixture.path())?
             .rev_parse_single("main")?
             .detach();
         for args in [
@@ -2211,7 +2211,7 @@ mod tests {
                 _ => None,
             })
             .expect("history loading returns the persistent graph");
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let index = graph.index(main).expect("the tracking tip was scheduled");
         let fake_parent = graph.intern(id(255)).expect("the small test graph fits in u32");
         let mut parents = graph.parents(index).to_vec();
@@ -2255,19 +2255,19 @@ mod tests {
         git(&["config", "commit.gpgsign", "false"])?;
         git(&["switch", "-q", "-c", "relation-base", "main"])?;
         commit("base-0")?;
-        let base = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        let base = crate::test_repository::open(path)?.rev_parse_single("HEAD")?.detach();
         for name in ["base-1", "base-2", "base-3"] {
             commit(name)?;
         }
         git(&["switch", "-q", "-c", "hidden"])?;
         commit("hidden-only")?;
-        let hidden_only = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        let hidden_only = crate::test_repository::open(path)?.rev_parse_single("HEAD")?.detach();
         git(&["switch", "-q", "-c", "local", "relation-base"])?;
         commit("local-only")?;
-        let local = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        let local = crate::test_repository::open(path)?.rev_parse_single("HEAD")?.detach();
         git(&["switch", "-q", "--detach", &base.to_hex().to_string()])?;
         commit("upstream-only")?;
-        let upstream = crate::open_test_repository(path)?.rev_parse_single("HEAD")?.detach();
+        let upstream = crate::test_repository::open(path)?.rev_parse_single("HEAD")?.detach();
         git(&["switch", "-q", "local"])?;
         for args in [
             &["config", "remote.origin.url", "https://example.com/repo"][..],
@@ -2324,7 +2324,7 @@ mod tests {
             "hidden tips do not truncate either side of the tracking relation"
         );
 
-        let repo = crate::open_test_repository(path)?;
+        let repo = crate::test_repository::open(path)?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
         let refresh = graph.refresh(&repo, &["local".into()], &[], false, &boundary, &authors)?;
@@ -2367,7 +2367,7 @@ mod tests {
         );
         let expected = String::from_utf8(output.stdout)?.lines().map(str::to_owned).collect();
         assert_eq!(actual, expected, "hidden tips use Git's exclusion semantics");
-        let repo = crate::open_test_repository(&fixture)?;
+        let repo = crate::test_repository::open(&fixture)?;
         let connected: Vec<_> = events
             .iter()
             .flat_map(|event| match event {
@@ -2412,7 +2412,7 @@ mod tests {
         let mut cancelled = Vec::new();
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
-        let repo = crate::open_test_repository(&fixture)?;
+        let repo = crate::test_repository::open(&fixture)?;
         load(&repo, &[], &[], false, &authors, &AtomicBool::new(true), |event| {
             cancelled.push(event);
             true
@@ -2442,7 +2442,7 @@ mod tests {
     #[test]
     fn ignores_malformed_and_non_commit_pins() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let head = repo.head_id()?.detach();
         let blob = repo.write_blob(b"not a commit")?.detach();
         repo.reference(
@@ -2465,7 +2465,7 @@ mod tests {
     #[test]
     fn review_stashes_are_not_history_tips_or_decorations() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let head = repo.head_id()?.detach();
         let stash = repo.rev_parse_single("topic")?.detach();
         repo.reference(
@@ -2496,7 +2496,7 @@ mod tests {
     #[test]
     fn commit_stashes_decorate_the_associated_commit_without_becoming_tips() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repo = crate::open_test_repository(fixture.path())?;
+        let repo = crate::test_repository::open(fixture.path())?;
         let head = repo.head_id()?.detach();
         let stash = repo.rev_parse_single("topic")?.detach();
         let name = super::super::edit::stash::reference(head)?;
@@ -2540,8 +2540,8 @@ mod tests {
                 .success(),
             "the linked-worktree fixture is created"
         );
-        let main = crate::open_test_repository(fixture.path())?;
-        let linked = crate::open_test_repository(&linked_path)?;
+        let main = crate::test_repository::open(fixture.path())?;
+        let linked = crate::test_repository::open(&linked_path)?;
         let main_id = main.head_id()?.detach();
         let linked_id = linked.head_id()?.detach();
         for (repo, id) in [(&main, main_id), (&linked, linked_id)] {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index dad90b2438e..b63243c530f 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -8,6 +8,8 @@ pub mod command;
 mod edit;
 mod history;
 mod logging;
+#[cfg(test)]
+mod test_repository;
 mod ui;
 
 use std::{
@@ -4384,11 +4386,6 @@ fn mouse_scroll_action(kind: MouseEventKind, distance: usize) -> Option<Action>
     }
 }
 
-#[cfg(test)]
-fn open_test_repository(path: impl AsRef<Path>) -> Result<gix::Repository, gix::open::Error> {
-    gix::open_opts(path.as_ref(), gix::open::Options::isolated())
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -4426,7 +4423,7 @@ mod tests {
     #[test]
     fn reference_watcher_observes_new_loose_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = open_test_repository(fixture.path())?;
+        let repository = test_repository::open(fixture.path())?;
         let watcher = start_ref_watcher(repository.git_dir(), repository.common_dir())?;
         let topic = repository.rev_parse_single("topic")?.detach();
         let status = Command::new("git")
@@ -4569,7 +4566,7 @@ mod tests {
     #[test]
     fn loads_commit_messages_from_an_existing_repository() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let repository = open_test_repository(&fixture)?;
+        let repository = test_repository::open(&fixture)?;
         let id = repository.rev_parse_single("topic")?.detach();
 
         assert!(
@@ -4582,7 +4579,7 @@ mod tests {
     #[test]
     fn selection_relation_prefers_tracking_counts_and_handles_missing_upstreams() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let repository = open_test_repository(&fixture)?;
+        let repository = test_repository::open(&fixture)?;
         let topic = repository.rev_parse_single("topic")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let authors =
@@ -4654,7 +4651,7 @@ mod tests {
                 .status()?;
             assert!(status.success(), "git config prepares the tracking relationship");
         }
-        let repository = open_test_repository(path)?;
+        let repository = test_repository::open(path)?;
         let topic = repository.rev_parse_single("topic")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let status = std::process::Command::new("git")
@@ -4662,7 +4659,7 @@ mod tests {
             .args(["update-ref", "refs/remotes/origin/main", &main.to_hex().to_string()])
             .status()?;
         assert!(status.success(), "the configured tracking ref exists");
-        let repository = open_test_repository(path)?;
+        let repository = test_repository::open(path)?;
         let authors =
             gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
         let mut graph = None;
@@ -4694,7 +4691,7 @@ mod tests {
     #[test]
     fn loads_changes_against_each_merge_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let repository = gix::open_opts(&fixture, gix::open::Options::isolated())?;
+        let repository = crate::test_repository::open(&fixture)?;
         let mut line_diff_pool = None;
         sync_line_diff_pool(&mut line_diff_pool, true, &fixture, false, 2)?;
         assert_eq!(
@@ -4739,10 +4736,7 @@ mod tests {
             FileDiff::Pager { .. } => unreachable!("isolated repositories have no pager"),
         }
 
-        let external_repository = gix::open_opts(
-            &fixture,
-            gix::open::Options::isolated().config_overrides(["diff.external=test --flag"]),
-        )?;
+        let external_repository = crate::test_repository::open_with(&fixture, ["diff.external=test --flag"])?;
         match prepare_file_diff_with_repository(&external_repository, &root.diffs[0], &root.paths[0])? {
             FileDiff::External(command) => assert!(
                 command
@@ -4754,10 +4748,7 @@ mod tests {
             FileDiff::Pager { .. } => unreachable!("configured external diffs take precedence"),
         }
 
-        let pager_repository = gix::open_opts(
-            &fixture,
-            gix::open::Options::isolated().config_overrides(["core.pager=delta --dark"]),
-        )?;
+        let pager_repository = crate::test_repository::open_with(&fixture, ["core.pager=delta --dark"])?;
         match prepare_file_diff_with_repository(&pager_repository, &root.diffs[0], &root.paths[0])? {
             FileDiff::Pager { command, diff } => {
                 assert!(
@@ -4777,7 +4768,7 @@ mod tests {
         }
 
         for setting in ["core.pager=", "core.pager=cat"] {
-            let repository = gix::open_opts(&fixture, gix::open::Options::isolated().config_overrides([setting]))?;
+            let repository = test_repository::open_with(&fixture, [setting])?;
             assert!(
                 matches!(
                     prepare_file_diff_with_repository(&repository, &root.diffs[0], &root.paths[0])?,
@@ -4999,7 +4990,7 @@ mod tests {
     #[test]
     fn configures_a_common_repository_as_bare_for_tree_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let git_dir = open_test_repository(&fixture)?.git_dir().to_owned();
+        let git_dir = test_repository::open(&fixture)?.git_dir().to_owned();
         let repository = open_repository(&git_dir, true, false)?;
 
         assert_eq!(
@@ -5036,7 +5027,7 @@ mod tests {
     #[test]
     fn normalizes_a_common_directory_through_a_missing_per_worktree_directory() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let git_dir = open_test_repository(&fixture)?.git_dir().to_owned();
+        let git_dir = test_repository::open(&fixture)?.git_dir().to_owned();
         let indirect = git_dir.join("worktrees/missing/../..");
         assert!(
             !git_dir.join("worktrees/missing").exists(),
@@ -5079,7 +5070,7 @@ mod tests {
         }
 
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
-        let git_dir = open_test_repository(&fixture)?.git_dir().canonicalize()?;
+        let git_dir = test_repository::open(&fixture)?.git_dir().canonicalize()?;
         let status = Command::new(std::env::current_exe()?)
             .env(COMMON_DIR, git_dir)
             .args([
@@ -5122,7 +5113,7 @@ mod tests {
         std::fs::write(path.join(".git/info/exclude"), "ignored\n")?;
         std::fs::write(path.join("ignored"), "ignored\n")?;
 
-        let repository = open_test_repository(path)?;
+        let repository = test_repository::open(path)?;
         let mut line_diff_pool = LineDiffPool::new(path, false, 2)?;
         let changes = load_worktree_changes(&repository, &mut line_diff_pool)?;
         let rows: Vec<_> = changes
@@ -5685,7 +5676,7 @@ mod tests {
         std::fs::create_dir_all(root.join("target/nested"))?;
         std::fs::write(root.join(".gitignore"), "target/\nvisible/ignored/\n")?;
 
-        let repository = open_test_repository(root)?;
+        let repository = test_repository::open(root)?;
         let directories = worktree_watch_directories(&repository)?;
         let root = repository.workdir().expect("the fixture has a worktree");
         assert!(directories.contains(root), "the worktree root is always watched");
@@ -5799,13 +5790,9 @@ mod tests {
     #[test]
     fn todo_conflict_preview_selects_the_partial_result_in_memory() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
-        let repo = gix::open_opts(
+        let repo = crate::test_repository::open_with(
             fixture.path(),
-            gix::open::Options::isolated().config_overrides([
-                "commit.gpgSign=false".to_owned(),
-                "user.name=preview author".to_owned(),
-                "user.email=preview@example.com".to_owned(),
-            ]),
+            ["user.name=preview author", "user.email=preview@example.com"],
         )?;
         let graph = edit::loaded_graph(&repo)?;
         let base = repo.rev_parse_single("HEAD~2")?.detach();
diff --git a/gix-tix/src/test_repository.rs b/gix-tix/src/test_repository.rs
new file mode 100644
index 00000000000..2598eb9df5a
--- /dev/null
+++ b/gix-tix/src/test_repository.rs
@@ -0,0 +1,46 @@
+use std::path::Path;
+
+const DEFAULT_OVERRIDES: &[&str] = &[
+    "user.name=author",
+    "user.email=author@example.com",
+    "gitoxide.commit.authorDate=2001-01-01T00:00:00 +0000",
+    "gitoxide.commit.committerDate=2001-01-01T00:00:00 +0000",
+    "commit.gpgSign=false",
+    "core.editor=:",
+];
+
+pub(crate) fn open(path: impl AsRef<Path>) -> Result<gix::Repository, gix::open::Error> {
+    open_with(path, std::iter::empty::<String>())
+}
+
+pub(crate) fn open_with<I, S>(path: impl AsRef<Path>, overrides: I) -> Result<gix::Repository, gix::open::Error>
+where
+    I: IntoIterator<Item = S>,
+    S: Into<String>,
+{
+    let mut config: Vec<String> = DEFAULT_OVERRIDES.iter().map(ToString::to_string).collect();
+    config.extend(overrides.into_iter().map(Into::into));
+    gix::open_opts(
+        path.as_ref().to_owned(),
+        gix::open::Options::isolated().config_overrides(config),
+    )
+}
+
+#[test]
+fn defaults_are_deterministic_and_case_specific_overrides_win() -> gix_testtools::Result {
+    let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+    let repo = open_with(fixture, ["user.name=reviewer"])?;
+    let author = repo.author().expect("the default author is configured")?.to_owned()?;
+    let committer = repo
+        .committer()
+        .expect("the default committer is configured")?
+        .to_owned()?;
+    assert_eq!(author.name, "reviewer", "a case-specific override wins");
+    assert_eq!(author.email, "author@example.com");
+    assert_eq!(author.time.seconds, 978_307_200);
+    assert_eq!(committer.name, "reviewer");
+    assert_eq!(committer.time.seconds, 978_307_200);
+    assert!(repo.commit_signing_options_if_enabled()?.is_none());
+    assert_eq!(repo.editor(), Some(":".into()));
+    Ok(())
+}

From 35e62c97eff0474e4b868865a13cd67d31441ddb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:07:48 +0200
Subject: [PATCH 141/282] feat: start unambiguous reviews immediately

Review setup previously entered base-selection mode even when the selected commit had only one selectable strict ancestor. In a two-commit range this required an extra navigation and confirmation step despite there being no decision to make.

Detect that sole candidate from the same reachable and selectable rows used by review navigation, then start the review directly. Preserve the guided selection flow whenever multiple bases remain possible, and document the distinction in the tix behavior specification.
---
 gix-tix/spec.md    |  7 ++++---
 gix-tix/src/app.rs | 30 ++++++++++++++++++++++++++++++
 2 files changed, 34 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ab246b5ba73..26055da088d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -530,9 +530,10 @@ space first; changes blocks adapt within the remaining history width.
 ### Reviews
 
 - `e v` starts a review from any non-boundary commit without merge descendants.
-  It limits navigation to the selected commit's ancestry; the connected hidden
-  base remains selectable, `<enter>` confirms it, and Escape cancels before any
-  repository change.
+  If exactly one selectable strict ancestor can be the review base, review starts
+  with it immediately. Otherwise tix limits navigation to the selected commit's
+  ancestry; the connected hidden base remains selectable, `<enter>` confirms it,
+  and Escape cancels before any repository change.
 - Starting requires a completely clean index and worktree, including no untracked
   files, and non-pending reviewed-tip and base commits. Only after confirmation,
   tix creates the first unused `refs/worktree/tix/review/N` ref at the reviewed
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index a181000c844..221725543aa 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1079,6 +1079,18 @@ impl App {
                 self.review_tip = Some(tip);
                 self.reachability_anchor = Some(tip);
                 self.compute_reachable_rows();
+                let mut bases = self
+                    .rows
+                    .iter()
+                    .enumerate()
+                    .filter(|(index, row)| {
+                        row.id != tip && self.is_row_reachable(*index) && self.reachable_row_selectable(*index)
+                    })
+                    .map(|(_, row)| row.id);
+                if let Some(base) = bases.next().filter(|_| bases.next().is_none()) {
+                    self.clear_review_selection();
+                    return vec![Effect::StartReview { tip, base }];
+                }
                 self.leave_message("review base · j/k select ancestor · <enter> start · Esc cancel");
             }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
@@ -2928,6 +2940,24 @@ mod tests {
         );
     }
 
+    #[test]
+    fn review_starts_immediately_with_only_one_possible_base() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        app.selected = Some(0);
+
+        assert_eq!(
+            app.update(Action::Review),
+            vec![Effect::StartReview {
+                tip: id(2),
+                base: id(1),
+            }],
+            "the sole strict ancestor needs no separate selection step"
+        );
+        assert!(!app.review_selection_active());
+    }
+
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);

From 2d6b7efaa096f00a3700ac1cbf07036232bffcd7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:38:50 +0200
Subject: [PATCH 142/282] fix: preserve the history tip when starting reviews

Starting a review performed a private detached checkout instead of preserving the position being left. When the reviewed commit was below the checked-out tip and that tip was not otherwise part of the requested view, refreshing from the review ref made the descendant history disappear.

Create or reuse the same worktree-local pins used by time travel before leaving HEAD. Attached departures use symbolic pins so they continue following their branch, detached departures use direct pins, and failed review setup removes only a pin created by that attempt.

Keep the regression's descendant tip visible and document that review setup retains the departure independently of the review anchor.
---
 gix-tix/spec.md                               |  5 +-
 gix-tix/src/edit/review.rs                    | 52 ++++++++++++++++---
 ...tests__changed-review-with-successors.snap |  1 +
 gix-tix/src/edit/time_travel.rs               |  2 +-
 4 files changed, 52 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 26055da088d..cc75934018b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -540,7 +540,10 @@ space first; changes blocks adapt within the remaining history width.
   tip and an unsigned ordinary `review` commit at the base with
   `tix-rebase: onto refs/worktree/tix/review/N`. HEAD is detached at that commit,
   its base tree fills the index, and the reviewed tip tree remains in the worktree
-  as unstaged changes. If attached HEAD pointed directly to the reviewed tip when
+  as unstaged changes. Leaving a different HEAD preserves that departure with a
+  normal worktree-local tix pin, symbolic for an attached branch and direct for a
+  detached checkout, so descendants above the reviewed commit remain visible.
+  If attached HEAD pointed directly to the reviewed tip when
   starting, the review ref symbolically targets that ref instead. Finishing then
   reattaches HEAD after confirming the ref moved to the finished review commit;
   otherwise the review ref remains a direct anchor and HEAD stays detached.
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 28608b1c007..298c99d04b1 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -4,6 +4,7 @@ use anyhow::{Context, Result};
 use gix::{
     ObjectId,
     bstr::{BStr, BString, ByteSlice},
+    refs::Target,
 };
 
 use crate::{history, open_repository};
@@ -88,7 +89,7 @@ pub(crate) fn start(
     let workdir = repo.workdir().context("review requires a worktree")?.to_owned();
     let head = repo.head().context("could not read HEAD before review")?;
     let restore = (
-        head.referent_name().map(|name| name.as_bstr().to_owned()),
+        head.referent_name().map(ToOwned::to_owned),
         head.id().map(gix::Id::detach),
     );
     let reattach = (restore.1 == Some(tip)).then(|| restore.0.clone()).flatten();
@@ -107,6 +108,19 @@ pub(crate) fn start(
     }
     ensure_clean(&workdir)?;
 
+    let departure_pin = match restore.1.filter(|id| *id != tip) {
+        Some(id) => {
+            let target = restore.0.clone().map_or(Target::Object(id), Target::Symbolic);
+            Some(super::time_travel::create_or_reuse_pin(
+                &repo,
+                target,
+                id,
+                "tix review departure",
+            )?)
+        }
+        None => None,
+    };
+
     let name = next_reference(&repo)?;
     let mut commit = gix::objs::Commit {
         tree: repo.find_commit(base)?.tree_id()?.detach(),
@@ -134,18 +148,25 @@ pub(crate) fn start(
         .detach();
     drop(repo);
 
-    git(&workdir, ["checkout", "--quiet", "--detach", &tip.to_string()])
-        .context("could not check out the reviewed commit")?;
+    if let Err(err) = git(&workdir, ["checkout", "--quiet", "--detach", &tip.to_string()]) {
+        remove_new_departure_pin(repository_path, bare, departure_pin.as_ref())?;
+        return Err(err.context("could not check out the reviewed commit"));
+    }
     let review_name = name.as_bstr().to_str_lossy();
     let create_ref = match reattach.as_ref() {
         Some(target) => git(
             &workdir,
-            ["symbolic-ref", review_name.as_ref(), target.to_str_lossy().as_ref()],
+            [
+                "symbolic-ref",
+                review_name.as_ref(),
+                target.as_bstr().to_str_lossy().as_ref(),
+            ],
         ),
         None => git(&workdir, ["update-ref", review_name.as_ref(), &tip.to_string()]),
     };
     if let Err(err) = create_ref {
         restore_checkout(&workdir, &restore)?;
+        remove_new_departure_pin(repository_path, bare, departure_pin.as_ref())?;
         return Err(err.context("could not create review reference"));
     }
     if let Err(err) = git(
@@ -154,6 +175,7 @@ pub(crate) fn start(
     ) {
         let _ = git(&workdir, ["update-ref", "--no-deref", "-d", review_name.as_ref()]);
         restore_checkout(&workdir, &restore)?;
+        remove_new_departure_pin(repository_path, bare, departure_pin.as_ref())?;
         return Err(err.context("could not attach the worktree to the review commit"));
     }
     if let Err(err) = git(&workdir, ["read-tree", &id.to_string()]) {
@@ -163,6 +185,7 @@ pub(crate) fn start(
         );
         let _ = git(&workdir, ["update-ref", "--no-deref", "-d", review_name.as_ref()]);
         restore_checkout(&workdir, &restore)?;
+        remove_new_departure_pin(repository_path, bare, departure_pin.as_ref())?;
         return Err(err.context("could not reset the index to the review base"));
     }
     Ok(Started {
@@ -263,12 +286,19 @@ fn git<const N: usize>(workdir: &Path, args: [&str; N]) -> Result<()> {
     }
 }
 
-fn restore_checkout(workdir: &Path, restore: &(Option<BString>, Option<ObjectId>)) -> Result<()> {
+fn remove_new_departure_pin(repository_path: &Path, bare: bool, pin: Option<&(history::Pin, bool)>) -> Result<()> {
+    let Some((pin, true)) = pin else { return Ok(()) };
+    let repo =
+        open_repository(repository_path, bare, false).context("could not reopen repository to remove review pin")?;
+    super::time_travel::delete_pin(&repo, pin).context("could not remove review departure pin")
+}
+
+fn restore_checkout(workdir: &Path, restore: &(Option<gix::refs::FullName>, Option<ObjectId>)) -> Result<()> {
     let mut command = Command::new("git");
     command.arg("-C").arg(workdir).args(["checkout", "--quiet", "--force"]);
     match restore {
         (Some(name), _) => {
-            let name = gix::path::from_bstr(name);
+            let name = gix::path::from_bstr(name.as_bstr());
             command.arg(name.as_ref());
         }
         (None, Some(id)) => {
@@ -499,6 +529,16 @@ mod tests {
         let graph = super::super::loaded_graph(&repo)?;
         drop(repo);
         start(fixture.path(), false, &graph, reviewed, base)?;
+        let repo = open()?;
+        let pins = history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "review start preserves the checked-out descendant tip");
+        assert_eq!(pins[0].id, old_successor);
+        assert_eq!(
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "an attached review departure remains attached through a symbolic pin"
+        );
+        drop(repo);
 
         std::fs::write(fixture.path().join("reviewed"), "new review change\n")?;
         run(fixture.path(), &["add", "file", "reviewed"])?;
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
index e6c0193f8cb..dd5aa5235fd 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -7,6 +7,7 @@ HEAD detached C2
 [refs]
 refs/heads/main = C4
 refs/heads/review-successor = C3
+refs/worktree/tix/pins/2eab5bd4 = -> refs/heads/main
 
 [commits]
 C0
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 0214e6a8cc1..0fd06b7179d 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -533,7 +533,7 @@ pub(crate) fn create_or_reuse_pin(
     Ok((history::Pin { name, target, id }, true))
 }
 
-fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
+pub(super) fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     repository
         .edit_references([delete_pin_edit(pin)])
         .context("could not remove tix pin")?;

From 20163a57957e8cc88ad7b9a057d79c7d29757b81 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:40:59 +0200
Subject: [PATCH 143/282] fix: return to the original checkout after reviews

A review ref cannot simultaneously anchor a commit below the checked-out tip and remember the branch that should be restored. Using it symbolically worked only when the branch pointed directly at the reviewed commit, leaving descendant reviews detached after completion.

Record the intended action as tix-review-return-to while keeping new review refs direct. Map that destination through review insertion, return through the standard time-travel checkout path, and remove the metadata from the finished commit. This also consumes the departure pin and keeps HEAD, index, and worktree synchronized with the rewritten branch tip.

Continue accepting symbolic review refs created by older tix versions, and distinguish a completed review whose return checkout failed from an unapplied review.
---
 gix-tix/spec.md                               |  15 +-
 gix-tix/src/edit/rebase.rs                    |   9 +-
 gix-tix/src/edit/review.rs                    | 128 +++++++++++++-----
 ...tests__changed-review-with-successors.snap |  11 +-
 gix-tix/src/lib.rs                            |  21 ++-
 5 files changed, 132 insertions(+), 52 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index cc75934018b..6bd3ae8ac3d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -536,17 +536,18 @@ space first; changes blocks adapt within the remaining history width.
   and Escape cancels before any repository change.
 - Starting requires a completely clean index and worktree, including no untracked
   files, and non-pending reviewed-tip and base commits. Only after confirmation,
-  tix creates the first unused `refs/worktree/tix/review/N` ref at the reviewed
-  tip and an unsigned ordinary `review` commit at the base with
-  `tix-rebase: onto refs/worktree/tix/review/N`. HEAD is detached at that commit,
+  tix creates the first unused direct `refs/worktree/tix/review/N` ref at the
+  reviewed tip and an unsigned ordinary `review` commit at the base with
+  `tix-rebase: onto refs/worktree/tix/review/N`. A `tix-review-return-to` header
+  names the departure pin, or the checked-out branch when no pin is needed. HEAD
+  is detached at that commit,
   its base tree fills the index, and the reviewed tip tree remains in the worktree
   as unstaged changes. Leaving a different HEAD preserves that departure with a
   normal worktree-local tix pin, symbolic for an attached branch and direct for a
   detached checkout, so descendants above the reviewed commit remain visible.
-  If attached HEAD pointed directly to the reviewed tip when
-  starting, the review ref symbolically targets that ref instead. Finishing then
-  reattaches HEAD after confirming the ref moved to the finished review commit;
-  otherwise the review ref remains a direct anchor and HEAD stays detached.
+  Finishing maps the recorded return target through the rewrite and uses normal
+  time-travel checkout semantics to restore attached or detached HEAD and consume
+  its pin. Existing symbolic review refs remain readable.
 - Review refs are always traversal tips and remain visible in every ref mode. One
   active ref is shown as `review`; multiple refs are shown as `review:N`. Review
   commits replace the signature disc with a filled diamond while retaining independent
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 62e457c1aa2..870a969491a 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -693,6 +693,7 @@ pub(super) fn finish_review(
     tip: ObjectId,
     review_ref: gix::refs::FullName,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
+    checkout: Option<(ObjectId, Option<gix::refs::FullName>)>,
 ) -> Result<Outcome> {
     let mut repo = repo.clone();
     let signing = repo
@@ -744,6 +745,7 @@ pub(super) fn finish_review(
             commit.extra_headers.retain(|(name, value)| {
                 !(name.as_slice() == MARKER
                     && value.as_slice().strip_prefix(b"onto ") == Some(review_ref.as_bstr().as_ref()))
+                    && name.as_slice() != super::review::RETURN_TO
             });
         }
         let new = write_commit(
@@ -802,19 +804,22 @@ pub(super) fn finish_review(
         rewritten.insert(old, Some(new));
     }
 
+    let (selected, checkout_reference) = checkout.map_or((finished_review, None), |(old, reference)| {
+        (rewritten.get(&old).copied().flatten().unwrap_or(old), reference)
+    });
     let mut prepared = Prepared {
         repo,
         root: Some(review),
         reset_index: false,
         reset_index_paths: None,
         skip_worktree_transitions: false,
-        selected: Some(finished_review),
+        selected: Some(selected),
         stash_rewritten: rewritten.clone(),
         rewritten,
         removed: HashSet::new(),
         committer,
         expected_refs: None,
-        checkout_reference: None,
+        checkout_reference,
         checkout_after_finish: false,
         pins: Vec::new(),
         delete_refs,
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 298c99d04b1..41993a484cf 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -11,6 +11,7 @@ use crate::{history, open_repository};
 
 const HEADER: &[u8] = b"tix-rebase";
 const ONTO: &[u8] = b"onto ";
+pub(super) const RETURN_TO: &[u8] = b"tix-review-return-to";
 
 #[derive(Debug)]
 pub(crate) struct Started {
@@ -18,6 +19,11 @@ pub(crate) struct Started {
     pub reference: gix::refs::FullName,
 }
 
+pub(crate) struct Finished {
+    pub commit: ObjectId,
+    pub outcome: super::rebase::Outcome,
+}
+
 pub(crate) fn reference(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
     commit
         .extra_headers
@@ -42,6 +48,17 @@ pub(crate) fn is_review(commit: &gix::objs::Commit) -> bool {
     reference(commit).ok().flatten().is_some()
 }
 
+fn return_to(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
+    commit
+        .extra_headers
+        .iter()
+        .find(|(name, _)| name.as_slice() == RETURN_TO)
+        .map(|(_, value)| {
+            gix::refs::FullName::try_from(value.clone()).context("review commit names an invalid return reference")
+        })
+        .transpose()
+}
+
 pub(super) fn deletions(
     repo: &gix::Repository,
     commit: &gix::objs::Commit,
@@ -92,7 +109,6 @@ pub(crate) fn start(
         head.referent_name().map(ToOwned::to_owned),
         head.id().map(gix::Id::detach),
     );
-    let reattach = (restore.1 == Some(tip)).then(|| restore.0.clone()).flatten();
     if tip == base || !graph.is_ancestor(base, tip) {
         anyhow::bail!("the review base must be an ancestor of the reviewed commit");
     }
@@ -142,6 +158,15 @@ pub(crate) fn start(
     commit
         .extra_headers
         .push((HEADER.into(), format!("onto {name}").into()));
+    let return_to = departure_pin
+        .as_ref()
+        .map(|(pin, _)| pin.name.clone())
+        .or_else(|| (restore.1 == Some(tip)).then(|| restore.0.clone()).flatten());
+    if let Some(return_to) = return_to {
+        commit
+            .extra_headers
+            .push((RETURN_TO.into(), return_to.as_bstr().to_owned()));
+    }
     let id = repo
         .write_object(&commit)
         .context("could not write review commit")?
@@ -153,17 +178,7 @@ pub(crate) fn start(
         return Err(err.context("could not check out the reviewed commit"));
     }
     let review_name = name.as_bstr().to_str_lossy();
-    let create_ref = match reattach.as_ref() {
-        Some(target) => git(
-            &workdir,
-            [
-                "symbolic-ref",
-                review_name.as_ref(),
-                target.as_bstr().to_str_lossy().as_ref(),
-            ],
-        ),
-        None => git(&workdir, ["update-ref", review_name.as_ref(), &tip.to_string()]),
-    };
+    let create_ref = git(&workdir, ["update-ref", review_name.as_ref(), &tip.to_string()]);
     if let Err(err) = create_ref {
         restore_checkout(&workdir, &restore)?;
         remove_new_departure_pin(repository_path, bare, departure_pin.as_ref())?;
@@ -195,7 +210,7 @@ pub(crate) fn start(
 }
 
 #[tracing::instrument(skip_all, fields(%review))]
-pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, review: ObjectId) -> Result<ObjectId> {
+pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, review: ObjectId) -> Result<Finished> {
     let workdir = repo
         .workdir()
         .context("finishing review requires a worktree")?
@@ -214,35 +229,47 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
     let mut reference = repo
         .find_reference(review_ref.as_ref())
         .context("the review reference is missing")?;
-    let reattach = reference.target().try_name().map(ToOwned::to_owned);
+    let legacy_reattach = reference.target().try_name().map(ToOwned::to_owned);
     let tip = reference
         .peel_to_id()
         .context("the review reference does not resolve")?
         .detach();
     let delete_refs = resources(&repo, review_ref.clone())?;
+    let return_to = return_to(&commit)?.or(legacy_reattach);
+    let checkout = return_to
+        .map(|name| {
+            let mut reference = repo
+                .find_reference(name.as_ref())
+                .context("the review return reference is missing")?;
+            let id = reference
+                .peel_to_id()
+                .context("the review return reference does not resolve")?
+                .detach();
+            if !graph.is_ancestor(tip, id) {
+                anyhow::bail!("the review return reference no longer descends from the reviewed commit");
+            }
+            let checkout_reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
+                reference.target().try_name().map(ToOwned::to_owned)
+            } else {
+                Some(name)
+            };
+            Ok((id, checkout_reference))
+        })
+        .transpose()?;
     for (label, id) in [("reviewed commit", tip), ("review base", base)] {
         let endpoint = repo.find_commit(id)?.decode()?.into_owned()?;
         if super::rebase::is_pending(&endpoint) {
             anyhow::bail!("{label} has a pending rebase");
         }
     }
-    let finished = super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs)?
-        .selected
+    let outcome = super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs, checkout)?;
+    let finished = outcome
+        .map(review)
         .context("finishing review did not produce a commit")?;
-    if let Some(reattach) = reattach {
-        let mut reference = repo
-            .find_reference(reattach.as_ref())
-            .context("the branch to restore after review is missing")?;
-        if reference.peel_to_id()?.detach() != finished {
-            anyhow::bail!("the branch to restore after review no longer points to the finished commit");
-        }
-        git(
-            &workdir,
-            ["symbolic-ref", "HEAD", reattach.as_bstr().to_str_lossy().as_ref()],
-        )
-        .context("could not reattach HEAD after review")?;
-    }
-    Ok(finished)
+    Ok(Finished {
+        commit: finished,
+        outcome,
+    })
 }
 
 pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
@@ -384,12 +411,17 @@ mod tests {
         );
         let review_ref = repo.find_reference(started.reference.as_ref())?;
         assert_eq!(
-            review_ref.target().try_name().map(gix::refs::FullNameRef::as_bstr),
-            Some(BStr::new(b"refs/heads/main")),
-            "the review resource remembers the branch to restore"
+            review_ref.id().detach(),
+            tip,
+            "the review resource remains anchored to the reviewed commit"
         );
         let commit = repo.find_commit(started.commit)?.decode()?.into_owned()?;
         assert_eq!(reference(&commit)?, Some(started.reference.clone()));
+        assert_eq!(
+            return_to(&commit)?.as_ref().map(gix::refs::FullName::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "the review commit records the checkout to restore"
+        );
         assert_eq!(
             std::fs::read(fixture.path().join("file"))?,
             b"tip\n",
@@ -414,7 +446,13 @@ mod tests {
             fixture.path(),
             ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
-        assert!(is_review(&repo.find_commit(amended)?.decode()?.into_owned()?));
+        let amended_commit = repo.find_commit(amended)?.decode()?.into_owned()?;
+        assert!(is_review(&amended_commit));
+        assert_eq!(
+            return_to(&amended_commit)?.as_ref().map(gix::refs::FullName::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "review amendments preserve the return action"
+        );
         assert!(run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty());
         let child = run(
             fixture.path(),
@@ -450,6 +488,8 @@ mod tests {
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         let finished = finish(repo, &graph, amended)?;
+        super::super::time_travel::checkout_plan(fixture.path(), false, &finished.outcome, &[], false)?;
+        let finished = finished.commit;
         let repo = crate::test_repository::open(fixture.path())?;
         assert_eq!(repo.head_id()?.detach(), finished);
         assert_eq!(
@@ -462,6 +502,10 @@ mod tests {
             Some(tip)
         );
         assert!(!is_review(&repo.find_commit(finished)?.decode()?.into_owned()?));
+        assert!(
+            return_to(&repo.find_commit(finished)?.decode()?.into_owned()?)?.is_none(),
+            "finished commits contain no review return action"
+        );
         let child = repo.find_reference("refs/heads/review-child")?.id().detach();
         assert_eq!(
             repo.find_commit(child)?.parent_ids().next().map(gix::Id::detach),
@@ -574,8 +618,24 @@ mod tests {
         let repo = open()?;
         let graph = super::super::loaded_graph(&repo)?;
         let finished = finish(repo, &graph, review)?;
+        super::super::time_travel::checkout_plan(fixture.path(), false, &finished.outcome, &[], false)?;
+        let finished = finished.commit;
         let repo = open()?;
         let successor = repo.find_reference("refs/heads/main")?.id().detach();
+        assert_eq!(
+            repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "finishing returns to the branch that contained the reviewed commit"
+        );
+        assert_eq!(repo.head_id()?.detach(), successor);
+        assert!(
+            history::all_pins(&repo)?.is_empty(),
+            "returning consumes the departure pin"
+        );
+        assert!(
+            run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty(),
+            "the restored branch has a matching index and worktree"
+        );
         assert_ne!(successor, old_successor, "the branch successor is rewritten");
         assert_eq!(
             repo.find_commit(finished)?.parent_ids().next().map(gix::Id::detach),
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
index dd5aa5235fd..fe936a8651e 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -2,12 +2,11 @@
 source: gix-tix/src/edit/review.rs
 expression: "gix_testtools::repository::snapshot(fixture.path())?.to_string()"
 ---
-HEAD detached C2
+HEAD refs/heads/main -> C4
 
 [refs]
 refs/heads/main = C4
 refs/heads/review-successor = C3
-refs/worktree/tix/pins/2eab5bd4 = -> refs/heads/main
 
 [commits]
 C0
@@ -51,13 +50,13 @@ C4
   A
 
 [index]
-tree = T3
+tree = T2
 100644 B0 stage=0 "file"
-100644 B1 stage=0 "reviewed"
+100644 B1 stage=0 "successor"
 
 [worktree]
 100644 file "file" = "B\n"
-100644 file "reviewed" = "new review change\n"
+100644 file "successor" = "A\n"
 
 [objects]
 C2 = 066adf4b205850540218e32e44576bcb33249572
@@ -67,7 +66,7 @@ T0 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
 C4 = 4ec5d7b25bc7415d9243067e231d934cc6952501
 T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T2 = 74c148aa829dcd83ad2608b6d0862ae1e6981501
-B1 = 8ab2a145f1f16e50d78eaced3311ac16027db494
 T3 = 93664bfc7cc096fcc0d1ac962596031e10f26906
 C0 = c38a9f7427b84ed8ba5e187ec385489d82d71695
 C3 = e0b1ce8b2ac673ea0cc153ca4b8958a3aa315dd0
+B1 = f70f10e4db19068f79bc43844b49f3eece45c4e8
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b63243c530f..e2929b19461 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2235,9 +2235,24 @@ fn event_loop(
                             edit::review::finish(repo, graph, id)
                         });
                     match result {
-                        Ok(new_id) => {
-                            app.leave_message(format!("finished review as {}", new_id.to_hex_with_len(7)));
-                            app.select_commit_after_refresh(new_id);
+                        Ok(finished) => {
+                            let checkout = edit::time_travel::checkout_plan(
+                                &repository_path,
+                                repository_is_bare,
+                                &finished.outcome,
+                                &revisions,
+                                worktrees,
+                            );
+                            match checkout {
+                                Ok(_) => app.leave_message(format!(
+                                    "finished review as {}",
+                                    finished.commit.to_hex_with_len(7)
+                                )),
+                                Err(err) => {
+                                    app.leave_message(format!("review applied, return checkout failed: {err:#}"))
+                                }
+                            }
+                            app.select_commit_after_refresh(finished.outcome.selected.unwrap_or(finished.commit));
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }

From 57c4a37949f4cad37d28c57b6c254e5e4d727a22 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:45:27 +0200
Subject: [PATCH 144/282] fix: make deleting a review return to its departure

Deleting a review commit removed its resource refs but left HEAD at the review base with the review checkout still present. In a narrow view this could leave no useful history visible and provided no complete cancellation path.

Capture the recorded return action before the review resources are deleted, discard the tracked review checkout, and return through the same branch-and-pin machinery used by time travel. Detached reviews now preserve an exact-tip departure as a direct pin as well, so cancellation restores both attached and detached starting states and consumes the temporary pin.

Cover both forms with a repository-state regression and document deletion of a review leaf as review cancellation.
---
 gix-tix/spec.md                 | 10 ++--
 gix-tix/src/edit/forget.rs      | 36 ++++++++++----
 gix-tix/src/edit/review.rs      | 85 ++++++++++++++++++++++++++++++++-
 gix-tix/src/edit/time_travel.rs | 39 +++++++++++++++
 gix-tix/src/lib.rs              | 32 ++++++++++---
 5 files changed, 181 insertions(+), 21 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6bd3ae8ac3d..3ae7748fb45 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -564,10 +564,12 @@ space first; changes blocks adapt within the remaining history width.
   after it; with multiple leaves they branch directly after the finished review.
   The review ref is deleted in the same atomic ref/worktree transaction.
 - Forget is unavailable for a review commit with descendants. Forgetting a review
-  leaf, finishing a review, or dropping a review commit through a rebase todo also
-  deletes its review ref and optional saved-worktree ref atomically; reordering or
-  rewriting it preserves the header and resources. Review stash refs are internal:
-  they are neither traversal tips nor decorations.
+  leaf cancels the review: tracked review changes are discarded, its recorded
+  return checkout is restored, and the departure pin is consumed. Finishing a
+  review or dropping one through a rebase todo also deletes its review ref and
+  optional saved-worktree ref atomically; reordering or rewriting it preserves the
+  headers and resources. Review stash refs are internal: they are neither traversal
+  tips nor decorations.
 
 ### Forget commits
 
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index eb88a3dddf4..c1335c41cb5 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -5,18 +5,33 @@ use gix::{ObjectId, bstr::ByteSlice};
 
 use super::rebase;
 
+pub(crate) struct Outcome {
+    pub selected: Option<ObjectId>,
+    pub review_return: Option<gix::refs::FullName>,
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
-pub(crate) fn perform(
-    repo: gix::Repository,
-    graph: &crate::history::HistoryGraph,
-    id: ObjectId,
-) -> Result<Option<ObjectId>> {
+pub(crate) fn perform(repo: gix::Repository, graph: &crate::history::HistoryGraph, id: ObjectId) -> Result<Outcome> {
     let commit = repo
         .find_commit(id)
         .context("could not find the commit to forget")?
         .decode()?
         .into_owned()?;
     let deletions = super::review::deletions(&repo, &commit)?;
+    let review_return = if repo.head_id().ok().map(gix::Id::detach) == Some(id) && !deletions.is_empty() {
+        match super::review::return_to(&commit)? {
+            Some(name) => Some(name),
+            None => {
+                let review = super::review::reference(&commit)?.context("the review return anchor is missing")?;
+                repo.find_reference(review.as_ref())?
+                    .target()
+                    .try_name()
+                    .map(ToOwned::to_owned)
+            }
+        }
+    } else {
+        None
+    };
     let result = if deletions.is_empty() {
         rebase::perform(
             &repo,
@@ -35,7 +50,10 @@ pub(crate) fn perform(
             deletions,
         )
     }?;
-    Ok(result.complete()?.selected)
+    Ok(Outcome {
+        selected: result.complete()?.selected,
+        review_return,
+    })
 }
 
 pub(super) fn preflight_tree_transition(
@@ -129,7 +147,7 @@ mod tests {
             .detach();
 
         let graph = super::super::loaded_graph(&repository)?;
-        assert_eq!(perform(repository.clone(), &graph, top)?, Some(parent));
+        assert_eq!(perform(repository.clone(), &graph, top)?.selected, Some(parent));
         let state = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             state.head,
@@ -211,7 +229,7 @@ mod tests {
         let root = repository.head_id()?.detach();
 
         let graph = super::super::loaded_graph(&repository)?;
-        assert_eq!(perform(repository.clone(), &graph, root)?, None);
+        assert_eq!(perform(repository.clone(), &graph, root)?.selected, None);
         let state = gix_testtools::repository::snapshot(fixture.path())?;
         assert_eq!(
             state.head,
@@ -249,7 +267,7 @@ mod tests {
             .expect("top has a parent")
             .detach();
         let graph = super::super::loaded_graph(&repository)?;
-        assert_eq!(perform(repository.clone(), &graph, top)?, Some(parent));
+        assert_eq!(perform(repository.clone(), &graph, top)?.selected, Some(parent));
         assert_eq!(
             repository.head_id()?.detach(),
             parent,
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 41993a484cf..577b07c5fab 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -48,7 +48,7 @@ pub(crate) fn is_review(commit: &gix::objs::Commit) -> bool {
     reference(commit).ok().flatten().is_some()
 }
 
-fn return_to(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
+pub(super) fn return_to(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
     commit
         .extra_headers
         .iter()
@@ -124,7 +124,7 @@ pub(crate) fn start(
     }
     ensure_clean(&workdir)?;
 
-    let departure_pin = match restore.1.filter(|id| *id != tip) {
+    let departure_pin = match restore.1.filter(|id| *id != tip || restore.0.is_none()) {
         Some(id) => {
             let target = restore.0.clone().map_or(Target::Object(id), Target::Symbolic);
             Some(super::time_travel::create_or_reuse_pin(
@@ -670,4 +670,85 @@ mod tests {
         );
         Ok(())
     }
+
+    #[test]
+    fn deleting_a_review_returns_to_the_preserved_departure() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        run(fixture.path(), &["init", "-q", "-b", "main"])?;
+        run(fixture.path(), &["config", "user.name", "reviewer"])?;
+        run(fixture.path(), &["config", "user.email", "reviewer@example.com"])?;
+        std::fs::write(fixture.path().join("file"), "base\n")?;
+        run(fixture.path(), &["add", "file"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "base"],
+        )?;
+        let base = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("file"), "reviewed\n")?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-qam", "reviewed"],
+        )?;
+        let reviewed = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+        std::fs::write(fixture.path().join("tip"), "tip\n")?;
+        run(fixture.path(), &["add", "tip"])?;
+        run(
+            fixture.path(),
+            &["-c", "commit.gpgSign=false", "commit", "-q", "-m", "tip"],
+        )?;
+        let tip = ObjectId::from_hex(run(fixture.path(), &["rev-parse", "HEAD"])?.trim())?;
+
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+        drop(repo);
+        let started = start(fixture.path(), false, &graph, reviewed, base)?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let forgotten = super::super::forget::perform(repo, &graph, started.commit)?;
+        let return_to = forgotten
+            .review_return
+            .context("review deletion has a return checkout")?;
+        let (returned, _) =
+            super::super::time_travel::checkout_review_return(fixture.path(), false, &return_to, &[], false)?;
+
+        let repo = crate::test_repository::open(fixture.path())?;
+        assert_eq!(returned, tip);
+        assert_eq!(repo.head_id()?.detach(), tip);
+        assert_eq!(
+            repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "cancelling reattaches the original branch"
+        );
+        assert!(history::all_pins(&repo)?.is_empty(), "the return consumes its pin");
+        assert!(
+            repo.try_find_reference(started.reference.as_ref())?.is_none(),
+            "the cancelled review resource is removed"
+        );
+        assert!(
+            run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty(),
+            "cancelling restores the original checkout without review changes"
+        );
+
+        drop(repo);
+        run(fixture.path(), &["checkout", "-q", "--detach", &tip.to_string()])?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        drop(repo);
+        let started = start(fixture.path(), false, &graph, reviewed, base)?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let forgotten = super::super::forget::perform(repo, &graph, started.commit)?;
+        let return_to = forgotten
+            .review_return
+            .context("detached review deletion has a return checkout")?;
+        super::super::time_travel::checkout_review_return(fixture.path(), false, &return_to, &[], false)?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        assert!(repo.head()?.is_detached(), "cancelling restores detached HEAD");
+        assert_eq!(repo.head_id()?.detach(), tip);
+        assert!(history::all_pins(&repo)?.is_empty());
+        Ok(())
+    }
 }
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 0fd06b7179d..ac46f343300 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -103,6 +103,45 @@ pub(crate) fn checkout_without_replay(
     move_head(repository_path, bare, selected, revisions, include_worktrees)
 }
 
+pub(crate) fn checkout_review_return(
+    repository_path: &Path,
+    bare: bool,
+    name: &gix::refs::FullName,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(ObjectId, Option<String>)> {
+    let repository = open_repository(repository_path, bare, false).context("could not open review return checkout")?;
+    let workdir = repository
+        .workdir()
+        .context("review cancellation requires a worktree")?
+        .to_owned();
+    let mut target = repository
+        .find_reference(name.as_ref())
+        .context("the review return reference is missing")?;
+    let selected = target
+        .peel_to_id()
+        .context("the review return reference does not resolve")?
+        .detach();
+    let reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
+        target.target().try_name().map(ToOwned::to_owned)
+    } else {
+        Some(name.clone())
+    };
+    drop(repository);
+    checkout(&workdir, [OsString::from("--force"), OsString::from("HEAD")])
+        .context("could not discard the cancelled review checkout")?;
+    let notice = move_head_to(
+        repository_path,
+        bare,
+        selected,
+        reference.as_ref(),
+        revisions,
+        include_worktrees,
+        |_| None,
+    )?;
+    Ok((selected, notice))
+}
+
 pub(crate) fn checkout_plan(
     repository_path: &Path,
     bare: bool,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index e2929b19461..8f7de8c51e7 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2113,10 +2113,30 @@ fn event_loop(
                         .context("forget requires a completed history graph")
                         .and_then(|graph| forget_commit(&repository_path, repository_is_bare, graph, id));
                     match result {
-                        Ok(parent) => {
-                            app.leave_message(format!("forgot {}", id.to_hex_with_len(7)));
-                            if let Some(parent) = parent {
-                                app.select_commit(parent);
+                        Ok(outcome) => {
+                            let returned = outcome.review_return.as_ref().map(|name| {
+                                edit::time_travel::checkout_review_return(
+                                    &repository_path,
+                                    repository_is_bare,
+                                    name,
+                                    &revisions,
+                                    worktrees,
+                                )
+                            });
+                            match returned.transpose() {
+                                Ok(Some((selected, _))) => {
+                                    app.leave_message("cancelled review");
+                                    app.select_commit_after_refresh(selected);
+                                }
+                                Err(err) => {
+                                    app.leave_message(format!("review cancelled, return checkout failed: {err:#}"));
+                                }
+                                Ok(None) => {
+                                    app.leave_message(format!("forgot {}", id.to_hex_with_len(7)));
+                                    if let Some(selected) = outcome.selected {
+                                        app.select_commit(selected);
+                                    }
+                                }
                             }
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
@@ -2249,7 +2269,7 @@ fn event_loop(
                                     finished.commit.to_hex_with_len(7)
                                 )),
                                 Err(err) => {
-                                    app.leave_message(format!("review applied, return checkout failed: {err:#}"))
+                                    app.leave_message(format!("review applied, return checkout failed: {err:#}"));
                                 }
                             }
                             app.select_commit_after_refresh(finished.outcome.selected.unwrap_or(finished.commit));
@@ -3577,7 +3597,7 @@ fn forget_commit(
     bare: bool,
     graph: &HistoryGraph,
     id: gix::ObjectId,
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<edit::forget::Outcome> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before forgetting commit")?;
     repository.object_cache_size(None);

From 8b17e9445ea3c16797aae7eb122e9fc6aaee9456 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:52:36 +0200
Subject: [PATCH 145/282] fix: let pins alone retain review history

Review references served two unrelated purposes: they identified the commit being reviewed and also acted as unconditional traversal tips. Once review setup learned to preserve the departure through normal pins, the second role made review resources retain history independently of the standard pin lifecycle.

Always create or reuse a departure pin, including when attached HEAD points directly at the reviewed commit, and store that pin in tix-review-return-to. Remove review refs from history tip and watched reference-chain construction while retaining their review decorations and lifecycle role.

Capture symbolic return targets before peeling their pins so finishing and cancelling exact-tip reviews reliably reattach the original branch. Cover the separation between review resources and traversal tips and document pins as the sole retention mechanism.
---
 gix-tix/spec.md                 | 16 ++++++-------
 gix-tix/src/edit/review.rs      | 40 ++++++++++++++++++++++-----------
 gix-tix/src/edit/time_travel.rs |  8 +++----
 gix-tix/src/history.rs          | 19 +++++++---------
 4 files changed, 47 insertions(+), 36 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3ae7748fb45..d1dd3e3e0e1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -538,18 +538,18 @@ space first; changes blocks adapt within the remaining history width.
   files, and non-pending reviewed-tip and base commits. Only after confirmation,
   tix creates the first unused direct `refs/worktree/tix/review/N` ref at the
   reviewed tip and an unsigned ordinary `review` commit at the base with
-  `tix-rebase: onto refs/worktree/tix/review/N`. A `tix-review-return-to` header
-  names the departure pin, or the checked-out branch when no pin is needed. HEAD
-  is detached at that commit,
+  `tix-rebase: onto refs/worktree/tix/review/N`. Starting always creates or reuses
+  a normal worktree-local tix pin for the departure, symbolic for an attached
+  branch and direct for a detached checkout, and names it in the
+  `tix-review-return-to` header. HEAD is detached at the review commit,
   its base tree fills the index, and the reviewed tip tree remains in the worktree
-  as unstaged changes. Leaving a different HEAD preserves that departure with a
-  normal worktree-local tix pin, symbolic for an attached branch and direct for a
-  detached checkout, so descendants above the reviewed commit remain visible.
+  as unstaged changes. The pin keeps the departure and its ancestry visible.
   Finishing maps the recorded return target through the rewrite and uses normal
   time-travel checkout semantics to restore attached or detached HEAD and consume
   its pin. Existing symbolic review refs remain readable.
-- Review refs are always traversal tips and remain visible in every ref mode. One
-  active ref is shown as `review`; multiple refs are shown as `review:N`. Review
+- Review refs are resources, not traversal tips; pins alone retain history. They
+  remain visible in every ref mode: one active ref is shown as `review`, while
+  multiple refs are shown as `review:N`. Review
   commits replace the signature disc with a filled diamond while retaining independent
   signature state. Ordinary edits preserve the review header and otherwise keep
   their normal signing and lazy-rebase behavior.
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 577b07c5fab..d00b11cc1a0 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -124,7 +124,7 @@ pub(crate) fn start(
     }
     ensure_clean(&workdir)?;
 
-    let departure_pin = match restore.1.filter(|id| *id != tip || restore.0.is_none()) {
+    let departure_pin = match restore.1 {
         Some(id) => {
             let target = restore.0.clone().map_or(Target::Object(id), Target::Symbolic);
             Some(super::time_travel::create_or_reuse_pin(
@@ -158,10 +158,7 @@ pub(crate) fn start(
     commit
         .extra_headers
         .push((HEADER.into(), format!("onto {name}").into()));
-    let return_to = departure_pin
-        .as_ref()
-        .map(|(pin, _)| pin.name.clone())
-        .or_else(|| (restore.1 == Some(tip)).then(|| restore.0.clone()).flatten());
+    let return_to = departure_pin.as_ref().map(|(pin, _)| pin.name.clone());
     if let Some(return_to) = return_to {
         commit
             .extra_headers
@@ -241,6 +238,11 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
             let mut reference = repo
                 .find_reference(name.as_ref())
                 .context("the review return reference is missing")?;
+            let checkout_reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
+                reference.target().try_name().map(ToOwned::to_owned)
+            } else {
+                Some(name)
+            };
             let id = reference
                 .peel_to_id()
                 .context("the review return reference does not resolve")?
@@ -248,11 +250,6 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
             if !graph.is_ancestor(tip, id) {
                 anyhow::bail!("the review return reference no longer descends from the reviewed commit");
             }
-            let checkout_reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
-                reference.target().try_name().map(ToOwned::to_owned)
-            } else {
-                Some(name)
-            };
             Ok((id, checkout_reference))
         })
         .transpose()?;
@@ -417,10 +414,18 @@ mod tests {
         );
         let commit = repo.find_commit(started.commit)?.decode()?.into_owned()?;
         assert_eq!(reference(&commit)?, Some(started.reference.clone()));
+        let pins = history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "review start preserves its departure with a pin");
+        assert_eq!(pins[0].id, tip);
         assert_eq!(
-            return_to(&commit)?.as_ref().map(gix::refs::FullName::as_bstr),
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
             Some(BStr::new(b"refs/heads/main")),
-            "the review commit records the checkout to restore"
+            "an attached departure uses a symbolic pin"
+        );
+        assert_eq!(
+            return_to(&commit)?.as_ref().map(gix::refs::FullName::as_bstr),
+            Some(pins[0].name.as_bstr()),
+            "the review commit records its departure pin"
         );
         assert_eq!(
             std::fs::read(fixture.path().join("file"))?,
@@ -450,7 +455,7 @@ mod tests {
         assert!(is_review(&amended_commit));
         assert_eq!(
             return_to(&amended_commit)?.as_ref().map(gix::refs::FullName::as_bstr),
-            Some(BStr::new(b"refs/heads/main")),
+            Some(pins[0].name.as_bstr()),
             "review amendments preserve the return action"
         );
         assert!(run(fixture.path(), &["status", "--porcelain=v1", "--untracked-files=all"])?.is_empty());
@@ -488,6 +493,15 @@ mod tests {
         )?;
         let graph = super::super::loaded_graph(&repo)?;
         let finished = finish(repo, &graph, amended)?;
+        assert_eq!(
+            finished
+                .outcome
+                .checkout_reference
+                .as_ref()
+                .map(gix::refs::FullName::as_bstr),
+            Some(BStr::new(b"refs/heads/main")),
+            "finishing retains the branch named by the symbolic departure pin"
+        );
         super::super::time_travel::checkout_plan(fixture.path(), false, &finished.outcome, &[], false)?;
         let finished = finished.commit;
         let repo = crate::test_repository::open(fixture.path())?;
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index ac46f343300..7f768f4e639 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -118,15 +118,15 @@ pub(crate) fn checkout_review_return(
     let mut target = repository
         .find_reference(name.as_ref())
         .context("the review return reference is missing")?;
-    let selected = target
-        .peel_to_id()
-        .context("the review return reference does not resolve")?
-        .detach();
     let reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
         target.target().try_name().map(ToOwned::to_owned)
     } else {
         Some(name.clone())
     };
+    let selected = target
+        .peel_to_id()
+        .context("the review return reference does not resolve")?
+        .detach();
     drop(repository);
     checkout(&workdir, [OsString::from("--force"), OsString::from("HEAD")])
         .context("could not discard the cancelled review checkout")?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index de629ac2c1d..0d63915d79d 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1168,18 +1168,13 @@ pub(crate) fn snapshot_ignoring_pin(
         .into_iter()
         .filter(|pin| ignored_pin != Some(pin.name.as_bstr()))
         .collect::<Vec<_>>();
-    let reviews = all_reviews(repo)?;
     let worktrees = worktree_checkouts(repo);
     let mut view = referenced_refs(repo, revisions)?;
     for pin in &pins {
         insert_ref_chain(repo, pin.name.as_bstr(), &mut view)?;
     }
-    for review in &reviews {
-        insert_ref_chain(repo, review.name.as_bstr(), &mut view)?;
-    }
     let mut view_tips = resolve_tips(repo, revisions)?.unwrap_or_default();
     view_tips.extend(pins.iter().map(|pin| pin.id));
-    view_tips.extend(reviews.iter().map(|review| review.id));
     if include_worktrees {
         view_tips.extend(worktrees.iter().map(|worktree| worktree.id));
     }
@@ -2463,26 +2458,28 @@ mod tests {
     }
 
     #[test]
-    fn review_stashes_are_not_history_tips_or_decorations() -> gix_testtools::Result {
+    fn review_resources_are_not_history_tips_and_stashes_are_not_decorations() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repo = crate::test_repository::open(fixture.path())?;
-        let head = repo.head_id()?.detach();
-        let stash = repo.rev_parse_single("topic")?.detach();
+        let review = repo.rev_parse_single("topic")?.detach();
         repo.reference(
             "refs/worktree/tix/review/1",
-            head,
+            review,
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test review",
         )?;
         repo.reference(
             "refs/worktree/tix/review/stashes/1",
-            stash,
+            review,
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test review stash",
         )?;
 
         assert_eq!(all_reviews(&repo)?.len(), 1);
-        assert!(!snapshot(&repo, &[], &[], false)?.view_tips.contains(&stash));
+        assert!(
+            !snapshot(&repo, &[], &[], false)?.view_tips.contains(&review),
+            "review resources do not retain history"
+        );
         assert!(
             decorations(&repo, &[], &worktree_checkouts(&repo))?
                 .values()

From aac818dc0d618222fb7f1847d02f9be3b8e3a809 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:59:08 +0200
Subject: [PATCH 146/282] feat: let tix reword set the author actor

The non-interactive reword command could replace a message but offered no equivalent way to change the author identity. Agents and scripts therefore had to launch and modify the full editor document even when the desired actor was already known.

Add --author with the same Name <email> validation used by the reword document. Preserve the original author date, continue using the current repository committer, and combine the override with -m or -f without opening an editor. When no explicit message is supplied, prefill the ordinary Markdown document and apply the requested identity even if the editor makes no additional change.

Cover clap parsing, editor-prefill behavior, explicit-message operation, identity validation, and preservation of the message and author date. Document the new command form in the tix specification.
---
 gix-tix/spec.md               | 11 +++---
 gix-tix/src/command.rs        | 23 ++++++++++---
 gix-tix/src/command/reword.rs | 65 +++++++++++++++++++++++++++++++----
 gix-tix/src/edit/reword.rs    | 22 ++++++++++--
 4 files changed, 104 insertions(+), 17 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index d1dd3e3e0e1..bee86ae310b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -22,14 +22,17 @@ without trading responsiveness for metadata that is not visible.
   rules. Replay conflicts change nothing unless explicitly materialized; an
   accepted conflict writes the checkout and unmerged index, then exits with an
   error so resolution cannot be mistaken for completion.
-- `tix reword REVSPEC [-m MESSAGE ... | -f FILE]` applies the same signing,
+- `tix reword REVSPEC [--author "Name <email>"] [-m MESSAGE ... | -f FILE]`
+  applies the same signing,
   lazy-rebase, mutable-ref, and worktree-safety rules as the TUI. Without either
   message option it opens the standard Markdown reword document. Repeated
   `-m/--message` values form paragraphs; `-f/--file` reads the complete message
   from a file, or from standard input when given `-`. Explicit sources bypass
-  the editor and do not add suggested trailers. An attached `HEAD` may reword
-  itself without a pin. Every other target requires an existing current-worktree
-  tix pin at that commit or a descendant;
+  the editor and do not add suggested trailers. `--author` replaces the author
+  actor while preserving its date. Without an explicit message it prefills the
+  normal editor document; with one it is applied non-interactively. An attached
+  `HEAD` may reword itself without a pin. Every other target requires an existing
+  current-worktree tix pin at that commit or a descendant;
   every such covering pin participates so retained forks are rewritten together.
   Eligibility is checked before the editor opens, and an unchanged document is
   an explicit no-op.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 5f6aa46978d..d5098e1b5af 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -284,14 +284,29 @@ mod tests {
         assert_eq!(reword.revision, "HEAD~2");
         assert!(reword.message.is_empty());
         assert!(reword.file.is_none());
-        let reword = Cli::try_parse_from(["tix", "reword", "HEAD~2", "-m", "title", "-m", "body"])
-            .expect("reword messages parse")
-            .platform
-            .command;
+        assert!(reword.author.is_none());
+        let reword = Cli::try_parse_from([
+            "tix",
+            "reword",
+            "HEAD~2",
+            "--author",
+            "Agent <agent@example.com>",
+            "-m",
+            "title",
+            "-m",
+            "body",
+        ])
+        .expect("reword messages parse")
+        .platform
+        .command;
         let Some(Command::Reword(reword)) = reword else {
             panic!("reword was expected")
         };
         assert_eq!(reword.message, ["title", "body"]);
+        assert_eq!(
+            reword.author.as_deref(),
+            Some(std::ffi::OsStr::new("Agent <agent@example.com>"))
+        );
         assert!(
             Cli::try_parse_from(["tix", "reword", "HEAD", "-m", "message", "-f", "message.txt"]).is_err(),
             "message and file inputs are mutually exclusive"
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 952685b687c..e6f6cff63a6 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -17,6 +17,9 @@ pub(super) struct Args {
     /// Read the new message from this file, or from standard input with `-`.
     #[arg(short = 'f', long, value_name = "FILE", conflicts_with = "message")]
     pub(super) file: Option<PathBuf>,
+    /// Set the author actor while preserving the original author date.
+    #[arg(long, value_name = "NAME <EMAIL>")]
+    pub(super) author: Option<OsString>,
 }
 
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
@@ -47,24 +50,39 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         anyhow::bail!("the reword target or one of its descendants must be pinned");
     }
 
+    let author = args
+        .author
+        .as_deref()
+        .map(gix::path::os_str_into_bstr)
+        .transpose()
+        .context("author is not valid UTF-8")?;
+
     if let Some(message) = explicit_message(&args, std::io::stdin())? {
         return finish(crate::edit::reword::apply_message(
-            repository, &graph, target, &message,
+            repository,
+            &graph,
+            target,
+            &message,
+            author.map(AsRef::as_ref),
         )?);
     }
 
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
-    let (editor, document) = crate::edit::reword::document(&repository, target)?;
+    let (editor, document) = crate::edit::reword::document_with_author(&repository, target, author.map(AsRef::as_ref))?;
     drop(repository);
-    let Some(edited) = crate::edit::edit_document_without_terminal(
+    let edited = crate::edit::edit_document_without_terminal(
         &editor,
         &document,
         &format!("tix-reword-{}-{}.md", std::process::id(), target.to_hex_with_len(7)),
-    )?
-    else {
-        println!("no reword performed: the editor document was unchanged");
-        return Ok(());
+    )?;
+    let edited = match edited {
+        Some(edited) => edited,
+        None if author.is_some() => document,
+        None => {
+            println!("no reword performed: the editor document was unchanged");
+            return Ok(());
+        }
     };
 
     let mut repository = crate::open_repository(&repository_path, bare, false)
@@ -139,6 +157,7 @@ mod tests {
             revision: revision.into(),
             message: Vec::new(),
             file: None,
+            author: None,
         }
     }
 
@@ -178,6 +197,7 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let mut initial = args("HEAD");
         initial.message = vec!["replacement title".into(), ";literal body".into()];
+        initial.author = Some("Agent <agent@example.com>".into());
         run(open(fixture.path(), "false")?, initial)?;
 
         assert_eq!(
@@ -185,6 +205,11 @@ mod tests {
             b"replacement title\n\n;literal body\n\n",
             "an explicit message bypasses the editor and retains editor-comment-looking lines"
         );
+        assert_eq!(
+            git(fixture.path(), &["log", "-1", "--format=%an <%ae>"])?,
+            b"Agent <agent@example.com>\n",
+            "an explicit message applies the author without opening an editor"
+        );
         let rewritten = git(fixture.path(), &["rev-parse", "HEAD"])?;
         let mut same = args("HEAD");
         same.message = vec!["replacement title\n\n;literal body".into()];
@@ -203,6 +228,32 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn author_prefills_the_editor_and_preserves_message_and_date() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let message = git(fixture.path(), &["log", "-1", "--format=%B"])?;
+        let author_date = git(fixture.path(), &["log", "-1", "--format=%aI"])?;
+        let mut reword = args("HEAD");
+        reword.author = Some("Agent <agent@example.com>".into());
+        run(open(fixture.path(), ":")?, reword)?;
+
+        assert_eq!(git(fixture.path(), &["log", "-1", "--format=%B"])?, message);
+        assert_eq!(git(fixture.path(), &["log", "-1", "--format=%aI"])?, author_date);
+        assert_eq!(
+            git(fixture.path(), &["log", "-1", "--format=%an <%ae>"])?,
+            b"Agent <agent@example.com>\n"
+        );
+
+        let old = git(fixture.path(), &["rev-parse", "HEAD"])?;
+        let mut invalid = args("HEAD");
+        invalid.author = Some("missing-email".into());
+        let err = run(open(fixture.path(), "false")?, invalid)
+            .expect_err("an invalid author is rejected before invoking the editor");
+        assert!(format!("{err:#}").contains("author identity"));
+        assert_eq!(git(fixture.path(), &["rev-parse", "HEAD"])?, old);
+        Ok(())
+    }
+
     #[test]
     fn attached_head_needs_no_pin() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 5a4a3d88792..8c960cafd1f 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -22,14 +22,25 @@ pub(super) struct Edit<'a> {
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
+    document_with_author(repo, id, None)
+}
+
+pub(crate) fn document_with_author(
+    repo: &gix::Repository,
+    id: gix::ObjectId,
+    author: Option<&[u8]>,
+) -> Result<(std::ffi::OsString, Vec<u8>)> {
     let editor = repo.editor().context("no Git editor is available")?;
-    let commit = repo
+    let mut commit = repo
         .find_commit(id)
         .context("could not find commit to reword")?
         .decode()
         .context("could not decode commit to reword")?
         .into_owned()
         .context("could not own commit to reword")?;
+    if let Some(author) = author {
+        commit.author = actor(author, commit.author.time, "author")?;
+    }
     let committer = repo
         .committer()
         .context("no Git committer is configured")?
@@ -104,6 +115,7 @@ pub(crate) fn apply_message(
     graph: &crate::history::HistoryGraph,
     old_id: gix::ObjectId,
     message: &[u8],
+    author: Option<&[u8]>,
 ) -> Result<Option<gix::ObjectId>> {
     let message = cleanup_message(message, None);
     if message.is_empty() {
@@ -116,9 +128,15 @@ pub(crate) fn apply_message(
         .context("could not decode commit to reword")?
         .into_owned()
         .context("could not own commit to reword")?;
-    if commit.message == message {
+    let changed_author = author
+        .map(|author| actor(author, commit.author.time, "author"))
+        .transpose()?;
+    if commit.message == message && changed_author.as_ref().is_none_or(|author| *author == commit.author) {
         return Ok(None);
     }
+    if let Some(author) = changed_author {
+        commit.author = author;
+    }
     commit.message = message;
     apply_commit(&repo, graph, old_id, commit)
 }

From 818595b56597beed5337c47aa0ad06ab5ca2379c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 05:59:30 +0200
Subject: [PATCH 147/282] Require agents to author commits as themselves

The tix-specific guidance required agent provenance but still allowed another author identity when explicitly requested. That exception made it possible for materially agent-written commits to appear human-authored, defeating the metadata distinction the policy was intended to provide.

Require agents to set their own identity explicitly, point to the new tix reword --author option as one way to do so, and prohibit impersonating the user, repository owner, or another person. Existing authors remain preserved when the agent is not responsible for the commit contents.
---
 gix-tix/AGENTS.md | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index fb1e6a7973b..8763fa5725c 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -30,9 +30,13 @@
   the conversation that produced it.
 - Keep each change's implementation, tests, snapshots, and corresponding
   `spec.md` updates in that change's commit.
-- A commit created or materially rewritten by an AI agent must use that agent's own name and email as its author. Do not silently inherit the repository owner's configured identity.
+- A commit created or materially rewritten by an AI agent must use that agent's
+  own name and email as its author. Set it explicitly when necessary, for example
+  with `tix reword --author "Agent Name <agent@example.com>"`; do not silently
+  inherit the repository owner's configured identity.
+- Never impersonate the repository owner, user, or another person when authoring
+  an agent-created or materially agent-rewritten commit.
 - Preserve the author of an existing commit when the agent is not responsible for its contents.
-- Use another author's identity only when the user explicitly requests it for that particular commit.
 - Keep this provenance in commit metadata so reviewers can distinguish agent-authored changes without relying on commit-message trailers.
 
 ## Repository lifetime

From f8d47d64d87be94099571c690003238270868719 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 06:25:10 +0200
Subject: [PATCH 148/282] fix: keep the HEAD marker on review commits

Review commits previously replaced the graph disc with a diamond before HEAD rendering was considered. This made a checked-out review look unlike every other checked-out commit and obscured the repository position.

Keep graph markers solely responsible for signature and HEAD state. Render the review diamond as the first resource marker after the hash, ahead of pin and stash markers, so review identity remains prominent without competing with @.
---
 gix-tix/spec.md   |  8 +++++---
 gix-tix/src/ui.rs | 40 ++++++++++++++++++++++++++--------------
 2 files changed, 31 insertions(+), 17 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bee86ae310b..1eb36e3c84e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -126,7 +126,8 @@ without trading responsiveness for metadata that is not visible.
   committer date, author and attribution information, markers, and title.
 - The commit marker is blue when unsigned, orange when signed but unverified or
   being verified, green when verified, and bright red when verification fails.
-- The current `HEAD` commit uses `@` instead of the normal commit disc and keeps
+- The current `HEAD` commit, including a review commit, uses `@` instead of the
+  normal commit disc and keeps
   the same signature and selection coloring. It remains visible when textual
   reference labels are hidden, and textual `HEAD` is never rendered alongside it.
 - At startup, the current worktree's `@` row becomes selected as soon as it is
@@ -553,8 +554,9 @@ space first; changes blocks adapt within the remaining history width.
 - Review refs are resources, not traversal tips; pins alone retain history. They
   remain visible in every ref mode: one active ref is shown as `review`, while
   multiple refs are shown as `review:N`. Review
-  commits replace the signature disc with a filled diamond while retaining independent
-  signature state. Ordinary edits preserve the review header and otherwise keep
+  commits show a filled diamond as the first resource marker, before pin and stash
+  markers, while retaining the normal signature disc or `@` at `HEAD`. Ordinary
+  edits preserve the review header and otherwise keep
   their normal signing and lazy-rebase behavior.
 - At a checked-out review commit, amend is offered only for staged changes and
   consumes only the index tree. It leaves worktree bytes and the review header
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 5642fbbf0b5..0595dd32754 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -547,7 +547,7 @@ pub(crate) fn draw_with_worktree(
                 lane,
                 graph_offset,
                 highlight,
-                (visible_rows[index].signature, visible_rows[index].is_review),
+                visible_rows[index].signature,
                 head_state,
             );
             let aligned = Rect::new(
@@ -572,7 +572,7 @@ pub(crate) fn draw_with_worktree(
                 lane,
                 horizontal_offset,
                 highlight,
-                (visible_rows[index].signature, visible_rows[index].is_review),
+                visible_rows[index].signature,
                 head_state,
             );
         }
@@ -1697,6 +1697,9 @@ fn metadata_line<'a>(
         },
     )];
     let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
+    if row.is_review {
+        spans.push(Span::styled(" ◆", decoration_style(DecorationKind::Review)));
+    }
     if row_decorations
         .iter()
         .any(|decoration| decoration.kind == DecorationKind::Pin)
@@ -1707,9 +1710,10 @@ fn metadata_line<'a>(
         .iter()
         .any(|decoration| decoration.kind == DecorationKind::Stash)
     {
-        let marker = if row_decorations
-            .iter()
-            .any(|decoration| decoration.kind == DecorationKind::Pin)
+        let marker = if row.is_review
+            || row_decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Pin)
         {
             "🎁"
         } else {
@@ -1944,10 +1948,9 @@ fn color_graph(
     graph: &str,
     offset: usize,
     highlight: Option<Color>,
-    marker: (SignatureState, bool),
+    signature: SignatureState,
     head: Option<bool>,
 ) {
-    let (signature, review) = marker;
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
             continue;
@@ -1963,9 +1966,7 @@ fn color_graph(
             style = style.add_modifier(Modifier::BOLD);
         }
         let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
-        if review && symbol == '●' {
-            cell.set_symbol("◆");
-        } else if head.is_some() && symbol == '●' {
+        if head.is_some() && symbol == '●' {
             cell.set_symbol("@");
         }
         cell.set_style(style);
@@ -2888,6 +2889,17 @@ mod tests {
             hash < pin && pin < date,
             "the pin sits between the hash and metadata: {row:?}"
         );
+        std::sync::Arc::make_mut(&mut app.rows[0]).is_review = true;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let row = rendered_row(&terminal);
+        let review = row.find("◆").expect("a review has its resource marker");
+        let pin = row.find("📌").expect("the row contains its pin");
+        let gift = row.find("🎁").expect("the row contains its stash marker");
+        assert!(
+            review < pin && pin < gift,
+            "review is the first resource marker: {row:?}"
+        );
+        std::sync::Arc::make_mut(&mut app.rows[0]).is_review = false;
         app.ref_mode = RefMode::None;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
@@ -3299,7 +3311,7 @@ mod tests {
                         "●─",
                         0,
                         Some(signature_color(*state)),
-                        (*state, false),
+                        *state,
                         head.then_some(false),
                     );
                 }
@@ -3319,7 +3331,7 @@ mod tests {
     }
 
     #[test]
-    fn review_commit_uses_a_diamond_instead_of_the_signature_disc() -> Result<(), Box<dyn std::error::Error>> {
+    fn review_commit_at_head_uses_the_head_marker() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(2, 1))?;
         terminal.draw(|frame| {
             frame.render_widget(Paragraph::new("●─"), Rect::new(0, 0, 2, 1));
@@ -3329,11 +3341,11 @@ mod tests {
                 "●─",
                 0,
                 None,
-                (SignatureState::Unsigned, true),
+                SignatureState::Unsigned,
                 Some(true),
             );
         })?;
-        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "◆");
+        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "@");
         assert_eq!(terminal.backend().buffer()[(1, 0)].symbol(), "─");
         Ok(())
     }

From bfbaaf562a761a50ad6191e6d0983e28ba4f4155 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 06:56:29 +0200
Subject: [PATCH 149/282] feat: finish reviews from checked-out successors

Review-side commits may be created above the dedicated review commit while inspecting and organizing changes. Finishing was nevertheless offered only when HEAD pointed directly at the review root, forcing users to travel backward before integrating work that was already part of the same review line.

Recognize the selected review as finishable when the completed in-memory history shows it in HEAD's ancestry and the worktree is clean. Revalidate the relationship against the edit operation's HistoryGraph, then reuse the existing finish machinery so review successors, the recorded return checkout, and resource cleanup retain their established behavior.
---
 gix-tix/spec.md            |  3 ++-
 gix-tix/src/app.rs         | 50 +++++++++++++++++++++++++++++++++++---
 gix-tix/src/edit/review.rs |  6 +++--
 gix-tix/src/ui.rs          |  2 +-
 4 files changed, 53 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1eb36e3c84e..a41e08aecd2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -561,7 +561,8 @@ space first; changes blocks adapt within the remaining history width.
 - At a checked-out review commit, amend is offered only for staged changes and
   consumes only the index tree. It leaves worktree bytes and the review header
   intact, removes signatures, and marks only affected descendants for lazy replay.
-- `e v` finishes a checked-out review only when status is completely clean. The
+- `e v` finishes a selected review when status is completely clean and the current
+  worktree HEAD is the review commit or one of its successors. The
   review commit is inserted after its reviewed tip with its exact tree, review
   header removed, updated committer, and configured signature. Review-side
   descendants retain exact trees and are signed without pending markers. With one
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 221725543aa..18108160646 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1329,6 +1329,22 @@ impl App {
         reachable
     }
 
+    fn is_known_ancestor(&self, ancestor: ObjectId, descendant: ObjectId) -> bool {
+        let mut seen = HashSet::new();
+        let mut pending = vec![descendant];
+        while let Some(id) = pending.pop() {
+            if id == ancestor {
+                return true;
+            }
+            if seen.insert(id)
+                && let Some(row) = self.all_rows.get(&id)
+            {
+                pending.extend(row.parent_ids.iter().copied());
+            }
+        }
+        false
+    }
+
     pub(crate) fn finish_lane_computation(&mut self, rows: Vec<SharedCommitRow>, graph: Graph, lane_time: Duration) {
         if self.state != State::Computing {
             return;
@@ -1729,10 +1745,12 @@ impl App {
             && self.finish_review_available
             && self.changes_focus.is_none()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self
-                .selected
-                .and_then(|index| self.rows.get(index))
-                .is_some_and(|row| row.is_review && Some(row.id) == self.worktree_head)
+            && self.selected.and_then(|index| self.rows.get(index)).is_some_and(|row| {
+                row.is_review
+                    && self
+                        .worktree_head
+                        .is_some_and(|head| self.is_known_ancestor(row.id, head))
+            })
     }
 
     pub(crate) fn review_selection_active(&self) -> bool {
@@ -2622,6 +2640,30 @@ mod tests {
         assert!(app.update(Action::Amend).is_empty());
     }
 
+    #[test]
+    fn a_clean_review_can_finish_while_head_is_on_its_successor() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row_with_parents(4, &[1]),
+            row(1),
+        ]);
+        std::sync::Arc::make_mut(&mut app.rows[1]).is_review = true;
+        app.selected = Some(1);
+        app.set_worktree_head(Some(id(3)), false);
+        app.set_head_edit_availability(false, false, false, false, true, false, false);
+        complete(&mut app);
+
+        assert_eq!(app.update(Action::Review), vec![Effect::FinishReview(id(2))]);
+
+        app.set_worktree_head(Some(id(4)), false);
+        assert!(
+            app.update(Action::Review).is_empty(),
+            "an unrelated checkout cannot finish the selected review"
+        );
+    }
+
     #[test]
     fn forgetting_a_non_merge_tip_requires_a_second_d_and_navigation_cancels_it() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index d00b11cc1a0..b6728372144 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -212,8 +212,9 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
         .workdir()
         .context("finishing review requires a worktree")?
         .to_owned();
-    if repo.head_id()?.detach() != review {
-        anyhow::bail!("the review commit must be checked out before it can be finished");
+    let head = repo.head_id()?.detach();
+    if !graph.is_ancestor(review, head) {
+        anyhow::bail!("HEAD must be the review commit or one of its successors before it can be finished");
     }
     ensure_clean(&workdir)?;
     let commit = repo.find_commit(review)?.decode()?.into_owned()?;
@@ -628,6 +629,7 @@ mod tests {
                 &review_successor.to_string(),
             ],
         )?;
+        run(fixture.path(), &["checkout", "--detach", &review_successor.to_string()])?;
 
         let repo = open()?;
         let graph = super::super::loaded_graph(&repo)?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 0595dd32754..586e2a2d73c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -336,7 +336,7 @@ pub(crate) fn draw_with_worktree(
         stashable,
         selected_is_head && selected_has_stash,
         selected_is_head && worktree_path_amend,
-        selected_is_head && selected_is_review && worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
+        worktree_changes.is_some_and(|changes| changes.paths.is_empty()),
         selected_is_head && tree_changes.is_some_and(|changes| !changes.paths.is_empty()),
         selected_is_head
             && worktree_changes.is_some_and(|changes| {

From d9be628765f4a5e4f2754cf55f18babac688b450 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 07:12:58 +0200
Subject: [PATCH 150/282] fix: keep materialized rebases visibly paused

A todo rebase continuation previously lived only in the event loop after its conflict was checked out. Its instruction was a transient message, so filesystem redraws and navigation could hide the required Enter action while ordinary edits remained available to invalidate the retained plan.

Mirror the continuation in application state and give it a persistent high-contrast footer that distinguishes unresolved and resolved indexes. Reserve history Enter for continuing and Escape for explicitly stopping without rollback, allow read-only inspection in the meantime, and reject repository-changing actions until the continuation is consumed.
---
 gix-tix/spec.md    |   8 ++++
 gix-tix/src/app.rs |  19 +++++++++
 gix-tix/src/lib.rs | 102 +++++++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/ui.rs  |  62 +++++++++++++++++++++++++--
 4 files changed, 188 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a41e08aecd2..f595ab8216b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -530,6 +530,14 @@ space first; changes blocks adapt within the remaining history width.
 - A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
+- A materialized todo conflict keeps a high-contrast `REBASE PAUSED` footer until
+  its in-memory continuation is consumed. The footer changes when the index is
+  resolved but always advertises `<enter>` to continue and `Esc` to stop. History,
+  changes-pane navigation, display toggles, copying, and path-diff inspection stay
+  available; repository-changing actions and refresh are blocked. Pane-local
+  `<enter>`, `Esc`, and `q` retain their inspection and focus behavior. Stopping
+  forgets only the in-memory continuation and leaves the partially applied
+  repository untouched; Ctrl-C still exits immediately.
 
 ### Reviews
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 18108160646..bc4a83ade09 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -441,6 +441,7 @@ pub(crate) struct App {
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
     pending_rebase_conflict: Option<ObjectId>,
+    rebase_continuation_pending: bool,
     worktree_conflicted: bool,
     amend_available: bool,
     stash_available: bool,
@@ -531,6 +532,7 @@ impl App {
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
             pending_rebase_conflict: None,
+            rebase_continuation_pending: false,
             worktree_conflicted: false,
             amend_available: false,
             stash_available: false,
@@ -585,6 +587,7 @@ impl App {
             "rebase suspended on conflict; press <enter> to checkout for resolution"
         );
         self.pending_rebase_conflict = Some(id);
+        self.rebase_continuation_pending = false;
         self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
     }
 
@@ -604,6 +607,22 @@ impl App {
         self.changes_focus = None;
     }
 
+    pub(crate) fn arm_rebase_continuation(&mut self) {
+        self.rebase_continuation_pending = true;
+    }
+
+    pub(crate) fn clear_rebase_continuation(&mut self) {
+        self.rebase_continuation_pending = false;
+    }
+
+    pub(crate) fn rebase_continuation_pending(&self) -> bool {
+        self.rebase_continuation_pending
+    }
+
+    pub(crate) fn rebase_continuation_conflicted(&self) -> bool {
+        self.rebase_continuation_pending && self.worktree_conflicted
+    }
+
     pub(crate) fn set_worktree_conflicted(&mut self, conflicted: bool) {
         self.worktree_conflicted = conflicted;
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8f7de8c51e7..b06f4e4f34c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1657,6 +1657,7 @@ fn event_loop(
                     Ok((notice, id)) => {
                         pending_todo_rebase_plan = Some(plan);
                         app.begin_conflict_resolution();
+                        app.arm_rebase_continuation();
                         app.leave_message(format!("{notice}; resolve the index, then press <enter>"));
                         app.select_commit_after_refresh(id);
                     }
@@ -1680,6 +1681,19 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        if key_pressed
+            && action == Some(Action::Cancel)
+            && app.changes_focus.is_none()
+            && pending_todo_rebase_plan.is_some()
+        {
+            drop(pending_todo_rebase_plan.take());
+            app.clear_rebase_continuation();
+            app.leave_message("stopped rebase continuation; the partially applied repository remains unchanged");
+            tracing::info!("stopped materialized rebase continuation without rolling back repository state");
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         if key_pressed
             && action == Some(Action::OpenDiff)
             && app.changes_focus.is_none()
@@ -1711,6 +1725,7 @@ fn event_loop(
                         .transpose()
                         .map(Option::flatten);
                     app.clear_rebase_conflict();
+                    app.clear_rebase_continuation();
                     app.set_worktree_conflicted(false);
                     app.leave_message(
                         notice
@@ -1742,6 +1757,13 @@ fn event_loop(
             urgent = true;
             continue;
         }
+        if pending_todo_rebase_plan.is_some()
+            && !action_allowed_during_rebase_continuation(action.as_ref(), app.changes_focus.is_some())
+        {
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         let Some(action) = action else {
             continue;
         };
@@ -4303,6 +4325,45 @@ fn action(key: KeyEvent) -> Option<Action> {
     action_with_shortcut_groups(key, false, false)
 }
 
+fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_focused: bool) -> bool {
+    matches!(
+        action,
+        None | Some(
+            Action::MoveUp
+                | Action::MoveDown
+                | Action::MoveUpBy(_)
+                | Action::MoveDownBy(_)
+                | Action::ScrollLeft
+                | Action::ScrollRight
+                | Action::HalfPageUp
+                | Action::HalfPageDown
+                | Action::PageUp
+                | Action::PageDown
+                | Action::First
+                | Action::Last
+                | Action::ToggleDate
+                | Action::ToggleName
+                | Action::ToggleEmail
+                | Action::ToggleTrailers
+                | Action::ToggleMailmap
+                | Action::CycleRefs
+                | Action::ToggleRefs
+                | Action::ToggleHidden
+                | Action::ToggleHistoryDisplay
+                | Action::ToggleInformation
+                | Action::ToggleAlign
+                | Action::ToggleCommit
+                | Action::ToggleChanges
+                | Action::ToggleChangesFocus
+                | Action::CycleChangesParent
+                | Action::Copy
+                | Action::CopyPath(_)
+                | Action::CopyAuthor
+                | Action::ForceQuit
+        )
+    ) || (changes_focused && matches!(action, Some(Action::OpenDiff | Action::Cancel | Action::Quit)))
+}
+
 fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, edit_expanded: bool) -> Option<Action> {
     if key.kind == KeyEventKind::Release {
         return None;
@@ -5483,6 +5544,47 @@ mod tests {
         assert!(!is_key_press(&key(KeyEventKind::Release)));
     }
 
+    #[test]
+    fn materialized_rebases_allow_inspection_but_block_repository_changes() {
+        for action in [
+            Action::MoveDown,
+            Action::ToggleChangesFocus,
+            Action::ToggleCommit,
+            Action::Copy,
+            Action::ForceQuit,
+        ] {
+            assert!(action_allowed_during_rebase_continuation(Some(&action), false));
+        }
+        for action in [
+            Action::Refresh,
+            Action::ToggleEdit,
+            Action::Amend,
+            Action::Rebase,
+            Action::TimeTravel,
+            Action::VerifySignatures,
+            Action::Quit,
+        ] {
+            assert!(
+                !action_allowed_during_rebase_continuation(Some(&action), false),
+                "{action:?} cannot invalidate a materialized rebase"
+            );
+        }
+        for action in [Action::OpenDiff, Action::Cancel, Action::Quit] {
+            assert!(
+                action_allowed_during_rebase_continuation(Some(&action), true),
+                "{action:?} retains its changes-pane behavior"
+            );
+        }
+        assert!(
+            !action_allowed_during_rebase_continuation(Some(&Action::OpenDiff), false),
+            "history Enter is reserved for continuation"
+        );
+        assert!(
+            !action_allowed_during_rebase_continuation(Some(&Action::Cancel), false),
+            "history Escape is reserved for stopping"
+        );
+    }
+
     #[test]
     fn maps_continuous_mouse_scrolling_to_navigation() {
         assert_eq!(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 586e2a2d73c..d02d5e648fd 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -990,13 +990,31 @@ pub(crate) fn draw_with_worktree(
         footer_spans.push(Span::raw(" · "));
         footer_spans.extend(shortcut("quit", 'q', true));
     }
-    if let Some(message) = app.message() {
+    let mut footer_style = Style::default();
+    if app.rebase_continuation_pending() {
+        footer_spans = vec![Span::raw(if app.rebase_continuation_conflicted() {
+            "REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"
+        } else {
+            "REBASE PAUSED · <enter> continue · Esc stop"
+        })];
+        if let Some(message) = app.message() {
+            footer_spans.push(Span::raw(format!(" · {message}")));
+        }
+        footer_style = Style::default()
+            .fg(Color::Black)
+            .bg(if app.rebase_continuation_conflicted() {
+                Color::LightRed
+            } else {
+                Color::Yellow
+            })
+            .add_modifier(Modifier::BOLD);
+    } else if let Some(message) = app.message() {
         footer_spans = vec![Span::raw(message)];
     }
-    if app.unseen_filesystem_redraw {
+    if app.unseen_filesystem_redraw && !app.rebase_continuation_pending() {
         footer_spans = notification_discs(footer_spans);
     }
-    frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
+    frame.render_widget(Paragraph::new(Line::from(footer_spans)).style(footer_style), footer);
     FrameLayout {
         history: body,
         overlays: changes_panes
@@ -2149,6 +2167,44 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn materialized_rebase_continuation_replaces_the_footer_until_cleared() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        complete(&mut app);
+        app.arm_rebase_continuation();
+        app.set_worktree_conflicted(true);
+        app.leave_message("materialized conflict");
+        let mut terminal = Terminal::new(TestBackend::new(120, 1))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        let footer = rendered_line(&terminal, 0);
+        assert!(
+            footer.starts_with("REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"),
+            "an unresolved continuation owns the footer: {footer:?}"
+        );
+        assert!(
+            footer.contains("materialized conflict"),
+            "messages cannot replace the mode"
+        );
+        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::LightRed);
+
+        app.update(Action::MoveDown);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 0).starts_with("REBASE PAUSED"),
+            "navigation cannot dismiss the continuation"
+        );
+        app.set_worktree_conflicted(false);
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::Yellow);
+        assert!(rendered_line(&terminal, 0).starts_with("REBASE PAUSED · <enter> continue · Esc stop"));
+
+        app.clear_rebase_continuation();
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(!rendered_line(&terminal, 0).contains("REBASE PAUSED"));
+        Ok(())
+    }
+
     #[test]
     fn renders_selection_info_beside_the_right_marker_without_dimming_it() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);

From 236412ca71e47156ef097bd9cb065e4839e08e6e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 15:14:21 +0200
Subject: [PATCH 151/282] change reword shortcut to e o

Move reword within the edit shortcut group from r to o so r consistently retains its existing reference-visibility behavior. Plain o remains inert outside the edit group.
---
 gix-tix/spec.md    | 2 +-
 gix-tix/src/lib.rs | 9 +++++++--
 gix-tix/src/ui.rs  | 2 +-
 3 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index f595ab8216b..3088cfb18da 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -755,7 +755,7 @@ space first; changes blocks adapt within the remaining history width.
 
 - `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base and
   `e u` rebases it onto the newer hidden branch tip when available,
-  `e r` rewords, `e n` creates a rebased child, `e f` forks an independent child,
+  `e o` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   and `e d d` confirms forgetting a top commit when each action is available.
 - `@` invokes time travel directly, outside the edit group. Invoking it leaves an
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b06f4e4f34c..e5d4e909ea8 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4407,7 +4407,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
-        KeyCode::Char('r') if edit_expanded => Some(Action::Reword),
+        KeyCode::Char('o') if edit_expanded => Some(Action::Reword),
         KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
         KeyCode::Char('m') if edit_expanded => Some(Action::NewEmptyCommit),
         KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
@@ -5420,7 +5420,7 @@ mod tests {
         for (key, expected) in [
             ('b', Action::Rebase),
             ('u', Action::RebaseUpdate),
-            ('r', Action::Reword),
+            ('o', Action::Reword),
             ('n', Action::NewCommit),
             ('m', Action::NewEmptyCommit),
             ('f', Action::ForkCommit),
@@ -5470,6 +5470,11 @@ mod tests {
             Some(Action::ToggleCommit)
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE), false, true),
+            Some(Action::ToggleRefs),
+            "the old edit shortcut retains its direct reference-toggle behavior"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
             Some(Action::CycleChangesParent)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index d02d5e648fd..8c1b03135fc 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -819,7 +819,7 @@ pub(crate) fn draw_with_worktree(
                 options.push(("review", 'v'));
             }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
-                options.push(("reword", 'r'));
+                options.push(("reword", 'o'));
             }
             if app.changes_focus.is_none() && app.can_create_commit() {
                 options.push(("new", 'n'));

From e4b1fadcbd33e6bfbbcca7ffc501af979b814c8e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 15:45:05 +0200
Subject: [PATCH 152/282] Document provisional agent commits

Require agents to create an identifiable empty WIP commit before changing tracked files. Completed work must amend that placeholder with the actual changes, the responsible agent's identity, and the final purposeful message so finished history and the worktree remain clean.
---
 AGENTS.md | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/AGENTS.md b/AGENTS.md
index fe85a78d148..9d7f299c161 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -70,6 +70,23 @@ Follow "purposeful conventional commits" style:
   - `feat(gix-odb)!: add a new object lookup API`
   - `fix(gix-ref)!: reject invalid reference names`
 
+### Provisional Commits
+
+- Before changing tracked worktree files for a task, start from a clean
+  worktree and create an empty provisional commit authored as
+  `🚧WIP🚧 <wip@invalid>`. Give it the purposeful subject the completed change
+  is expected to use so an interrupted session remains identifiable; do not use
+  a `WIP:` prefix.
+- When the task is complete, stage the intended changes and amend that
+  provisional commit. Replace the WIP author with the responsible agent's own
+  name and email, and update the subject and descriptive body to match what was
+  actually completed. The final commit must contain the complete task and leave
+  the worktree clean; never leave the provisional author in finished history.
+- If follow-up work semantically belongs to an existing local commit, amend it
+  into that commit instead of adding a corrective commit at the tip. Use
+  `tix travel <commit>` when suitable to edit it while retaining its descendants,
+  then return through the saved branch after the descendants are rebased.
+
 ### Code Style
 
 - Follow existing patterns in the codebase

From 0fa9950266dc67f210dda8f9d3ca646c865c5bdb Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 15:48:47 +0200
Subject: [PATCH 153/282] feat: offer a WIP author in commit editors
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Show a commented 🚧WIP🚧 author directly below the configured author in new, empty, fork, and split commit editor documents. Uncommenting that single line now overrides the configured author while leaving the existing author date intact.

Keep reword documents unchanged, document the opt-in, and cover both the default and selected-author behavior along with the shared new-commit and split templates.
---
 gix-tix/spec.md            |  6 +++-
 gix-tix/src/edit/create.rs |  9 +++++-
 gix-tix/src/edit/reword.rs | 62 +++++++++++++++++++++++++++++++++++---
 gix-tix/src/edit/split.rs  |  7 +++++
 4 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3088cfb18da..76d8168f351 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -450,7 +450,9 @@ space first; changes blocks adapt within the remaining history width.
   to its parent; `new-empty` deliberately reuses it.
 - The Markdown editor buffer contains editable identities and dates, a `what`
   title, a `why` body, optional attribution trailers, and a commented Git-style
-  per-path diffstat with signed net line counts. Commit hooks are not run.
+  per-path diffstat with signed net line counts. A commented
+  `Author: 🚧WIP🚧 <wip@invalid>` directly below the configured author can be
+  uncommented to select it instead. Commit hooks are not run.
 - After editing, tix revalidates the destination, applies configured signing,
   marks linear descendants for lazy replay, persists the prepared objects, and atomically
   advances mutable refs throughout the rewritten stack. This includes local
@@ -499,6 +501,8 @@ space first; changes blocks adapt within the remaining history width.
   changes abort without writing objects or changing refs, the index, or files.
 - `tix split` performs the same split at `HEAD`: worktree changes are amended
   into the source commit and staged index changes become the new commit on top.
+  Its upper-commit editor offers the same commented WIP author override as the
+  new-commit editor.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Their final trees and ancestry
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 88cbf8d2ea7..9272b603361 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -99,7 +99,7 @@ fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: boo
     )?;
     let line_counts = add_line_counts(&repo, &mut changes)?;
     let mut document = Vec::new();
-    reword::write_headers(&mut document, &author, &committer)?;
+    reword::write_headers(&mut document, &author, &committer, Some(reword::WIP_AUTHOR))?;
     document.extend_from_slice(b"\nwhat\n\nwhy\n");
     for trailer in reword::missing_agent_trailers(b"what\n\nwhy\n").into_iter().flatten() {
         document.extend_from_slice(b"\n;");
@@ -338,6 +338,13 @@ mod tests {
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let objects_before = object_count(fixture.path())?;
         let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        assert!(
+            prepared
+                .document
+                .windows(b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>".len())
+                .any(|window| window == b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>"),
+            "new-commit editors offer the provisional author"
+        );
         assert!(
             prepared
                 .document
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 8c960cafd1f..288f4ced27c 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -9,6 +9,7 @@ const COMMITTER: &[u8] = b"Committer: ";
 const COMMITTER_DATE: &[u8] = b"CommitterDate: ";
 const COMMENT_CHAR: &[u8] = b"CommentChar: ";
 pub(super) const DEFAULT_COMMENT_CHAR: &[u8] = b";";
+pub(super) const WIP_AUTHOR: &[u8] = b"\xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>";
 pub(super) const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
 pub(super) const CO_AUTHORED_BY: &[u8] = b"Co-authored-by: GPT 5.6 <codex@openai.com>";
 
@@ -49,7 +50,7 @@ pub(crate) fn document_with_author(
         .context("could not own the Git committer")?;
 
     let mut out = Vec::new();
-    write_headers(&mut out, &commit.author, &committer)?;
+    write_headers(&mut out, &commit.author, &committer, None)?;
     out.push(b'\n');
     out.extend_from_slice(&commit.message);
     if !out.ends_with(b"\n") {
@@ -162,8 +163,15 @@ pub(super) fn write_headers(
     out: &mut Vec<u8>,
     author: &gix::actor::Signature,
     committer: &gix::actor::Signature,
+    alternative_author: Option<&[u8]>,
 ) -> Result<()> {
     write_actor(out, AUTHOR, author);
+    if let Some(alternative_author) = alternative_author {
+        out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+        out.extend_from_slice(AUTHOR);
+        out.extend_from_slice(alternative_author);
+        out.push(b'\n');
+    }
     write_date(out, AUTHOR_DATE, author.time)?;
     write_actor(out, COMMITTER, committer);
     write_date(out, COMMITTER_DATE, committer.time)?;
@@ -193,9 +201,30 @@ fn write_date(out: &mut Vec<u8>, label: &[u8], time: gix::date::Time) -> Result<
 }
 
 pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
-    let mut parts = input.splitn(7, |byte| *byte == b'\n');
-    let author = header(parts.next(), AUTHOR)?;
-    let author_time = date(header(parts.next(), AUTHOR_DATE)?, "author")?;
+    let has_alternative_author = input
+        .splitn(3, |byte| *byte == b'\n')
+        .nth(1)
+        .map(trim_cr)
+        .is_some_and(|line| {
+            line.starts_with(AUTHOR)
+                || line
+                    .strip_prefix(DEFAULT_COMMENT_CHAR)
+                    .is_some_and(|line| line.starts_with(AUTHOR))
+        });
+    let mut parts = input.splitn(7 + usize::from(has_alternative_author), |byte| *byte == b'\n');
+    let mut author = header(parts.next(), AUTHOR)?;
+    let mut line = parts.next();
+    if line
+        .map(trim_cr)
+        .and_then(|line| line.strip_prefix(DEFAULT_COMMENT_CHAR))
+        .is_some_and(|line| line.starts_with(AUTHOR))
+    {
+        line = parts.next();
+    } else if line.map(trim_cr).is_some_and(|line| line.starts_with(AUTHOR)) {
+        author = header(line, AUTHOR)?;
+        line = parts.next();
+    }
+    let author_time = date(header(line, AUTHOR_DATE)?, "author")?;
     let committer = header(parts.next(), COMMITTER)?;
     let committer_time = date(header(parts.next(), COMMITTER_DATE)?, "committer")?;
     let comment_char = header(parts.next(), COMMENT_CHAR)?;
@@ -309,6 +338,31 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_commented_alternative_author_can_be_selected_by_uncommenting_it() -> gix_testtools::Result {
+        let input = b"Author: Default <default@example.com>\n\
+                      ;Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>\n\
+                      AuthorDate: 2026-08-12 10:20:30 +0200\n\
+                      Committer: C <c@example.com>\n\
+                      CommitterDate: 2026-08-12 11:20:30 +0200\n\
+                      CommentChar: ;\n\
+                      \n\
+                      title\n";
+
+        assert_eq!(
+            parse(input)?.author,
+            b"Default <default@example.com>",
+            "the commented alternative leaves the configured author active"
+        );
+        let selected = input.replacen(b";Author: ", b"Author: ", 1);
+        assert_eq!(
+            parse(&selected)?.author,
+            "🚧WIP🚧 <wip@invalid>".as_bytes(),
+            "uncommenting the offered author is sufficient to select it"
+        );
+        Ok(())
+    }
+
     #[test]
     fn document_does_not_repeat_existing_agent_trailers() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 4ff1e74cef7..2ebee44d3ee 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -127,6 +127,13 @@ mod tests {
         }
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let prepared = prepare(open(fixture.path())?)?;
+        assert!(
+            prepared
+                .document
+                .windows(b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>".len())
+                .any(|window| window == b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>"),
+            "split editors offer the provisional author"
+        );
         assert!(
             prepared
                 .document

From 776a00109c0f3aa26761387c3bbdaa44507c7a24 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 16:06:42 +0200
Subject: [PATCH 154/282] feat: remember detached HEAD branches with a HEAD pin
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Record the local branch tix detaches from in a singleton worktree-local symbolic pin. Keep it as a reachability tip without exposing ordinary return, reuse, or unpin behavior, and reattach HEAD automatically when travel reaches the branch tip.

Render the remembered branch as ★branch, retain the pin when reattachment fails, and cover moving branch targets, repeated travel, explicit attachment, ordinary pin isolation, fork travel, and failure recovery.
---
 gix-tix/spec.md                               |  51 ++--
 gix-tix/src/edit/create.rs                    |  12 +-
 ...sts__accepted-pending-rebase-conflict.snap |   2 +-
 gix-tix/src/edit/time_travel.rs               | 219 +++++++++++++++---
 gix-tix/src/history.rs                        |  72 +++++-
 gix-tix/src/ui.rs                             |  21 ++
 6 files changed, 321 insertions(+), 56 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 76d8168f351..49d30589ad9 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -18,7 +18,7 @@ without trading responsiveness for metadata that is not visible.
   TUI time travel. Travelling to the current `HEAD` is a no-op. A detached
   source may travel to a descendant without a pin, but travelling to an ancestor
   or unrelated commit requires an existing current-worktree pin at `HEAD` or a
-  descendant. An attached source is preserved through the normal symbolic-pin
+  descendant. An attached source is preserved through the singleton HEAD-pin
   rules. Replay conflicts change nothing unless explicitly materialized; an
   accepted conflict writes the checkout and unmerged index, then exits with an
   error so resolution cannot be mistaken for completion.
@@ -240,23 +240,30 @@ The Enter key is written as `<enter>` throughout.
 
 - On a completed, focused history in a worktree repository, `@` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
-- Before every move, tix provisionally retains the previous `HEAD` with a
-  `refs/worktree/tix/pins/<suffix>` ref. Git stores these refs privately for the
-  current worktree. After a successful checkout it removes that pin
-  when the old `HEAD` remains reachable from another view tip, and retains it
-  otherwise. Pins use at least four alphanumeric characters;
-  generated pins start with eight hexadecimal characters from the saved commit.
-- A pin is symbolic when the previous `HEAD` named a local branch, so later branch
-  advances move the pinned tip. An already detached `HEAD` receives a direct pin.
+- When tix detaches an attached local branch, it records that branch symbolically
+  in the singleton `refs/worktree/tix/pins/HEAD` ref. Git stores this HEAD pin
+  privately for the current worktree, and later branch advances move its tip.
+  Further detached travel preserves the singleton. After each successful tix
+  checkout, landing on the remembered branch tip reattaches `HEAD` to that branch
+  and removes the HEAD pin; explicitly attaching another branch also removes it.
+  A failed automatic reattachment leaves both detached `HEAD` and the HEAD pin
+  intact and reports a warning. External Git checkouts do not reconcile it.
+- Other departures are provisionally retained with ordinary
+  `refs/worktree/tix/pins/<suffix>` refs. An already detached `HEAD` receives a
+  direct pin. After a successful checkout tix removes that pin when the old
+  `HEAD` remains reachable from another view tip, and retains it otherwise. Pins
+  use at least four alphanumeric characters; generated pins start with eight
+  hexadecimal characters from the saved commit.
 - When a rebase rewrites a detached departure, checkout applies the rebase mapping
   before deciding whether to pin it. A departure rewritten into the selected `@`
   successor is not pinned; a distinct departure preserves its rewritten identity.
-- While `HEAD` is detached, every valid pin from the current worktree augments
-  implicit and explicit revision tips. While it is attached, only pins at strict
-  descendants of `HEAD` do so, preserving rewritten leaves after a history rebase
-  moves the checked-out branch down its stack. Pins from other worktrees,
-  dangling, malformed, and non-commit pins do not
-  enter the view or its decorations. Normal hidden-revision exclusions still apply.
+- While `HEAD` is detached, every valid pin, including the HEAD pin, from the
+  current worktree augments implicit and explicit revision tips. While it is
+  attached, only pins at strict descendants of `HEAD` do so and the HEAD pin is
+  inactive, preserving rewritten leaves after a history rebase moves the
+  checked-out branch down its stack. Pins from other worktrees, dangling,
+  malformed, and non-commit pins do not enter the view or its decorations.
+  Normal hidden-revision exclusions still apply.
 - One or more worktree pins at a commit are shown as a single blue `📌`
   resource marker immediately after the hash and outside ordinary reference
   decorations. It remains visible when references are hidden, and internal pin
@@ -264,6 +271,9 @@ The Enter key is written as `<enter>` throughout.
   tip checks out its underlying branch, or its direct commit in detached mode,
   then removes that one pin. Multiple matching pins prefer symbolic targets and
   then lexical ref-name order.
+- The HEAD pin instead marks its target branch as `★branch` in the local-branch
+  style. It has no `📌`, is never selected as a return destination, and does not
+  offer `unpin`; its branch keeps normal tracking-relation behavior.
 - The edit menu offers `unpin` on a pinned row. It atomically removes every pin
   for that commit in the current worktree and retains that row's selection.
 - `tix pin <REVSPEC>...` resolves every argument before writing and deduplicates
@@ -272,11 +282,12 @@ The Enter key is written as `<enter>` throughout.
   revisions and object IDs remain fixed direct pins. Each unique target prints
   as `pin:<suffix> <short-id>`, and targets at the same commit remain distinct.
 - Checkout failures retain the original `HEAD`, remove only a newly created
-  source pin, and leave destination pins intact. Successful travel consumes a
-  destination pin and applies the same source-pin reconciliation for ancestor,
-  descendant, and sideways moves. Conflict acceptance, history-rebase checkout,
-  and automatic fork travel use this same primitive. Successful travel preserves
-  the selected row, refreshes history directly, and invalidates worktree status.
+  source or HEAD pin, and leave destination pins intact. Successful travel
+  consumes a destination pin and applies the same source-pin reconciliation for
+  ancestor, descendant, and sideways moves. Conflict acceptance, history-rebase
+  checkout, and automatic fork travel use this same primitive. Successful travel
+  preserves the selected row, refreshes history directly, and invalidates
+  worktree status.
 - Active review commits define review trees containing all of their descendants.
   Time travel within one review tree keeps ordinary checkout behavior and never
   creates or restores a stash. Crossing out of a dirty review tree saves tracked,
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 9272b603361..2a0ae88cba4 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -498,10 +498,10 @@ mod tests {
         let repository = open(fixture.path())?;
         assert!(repository.head()?.is_detached(), "automatic fork travel detaches HEAD");
         assert_eq!(repository.head_id()?.detach(), fork);
-        assert!(
-            crate::history::all_pins(&repository)?.is_empty(),
-            "the checkout consumes the fork pin and does not retain a redundant source pin"
-        );
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the checkout consumes the temporary fork pin");
+        assert!(pins[0].is_head(), "the singleton remembers the departed branch");
+        assert_eq!(pins[0].id, main);
         Ok(())
     }
 
@@ -559,8 +559,8 @@ mod tests {
                 .into_iter()
                 .map(|pin| pin.id)
                 .collect::<std::collections::HashSet<_>>(),
-            [first].into_iter().collect(),
-            "every non-current tip has one private pin"
+            [first, base].into_iter().collect(),
+            "the first fork and remembered branch have private pins"
         );
         Ok(())
     }
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index c0e0370cc09..d942628c2f1 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -6,7 +6,7 @@ HEAD detached C1
 
 [refs]
 refs/heads/main = C2
-refs/worktree/tix/pins/9dabf957 = -> refs/heads/main
+refs/worktree/tix/pins/HEAD = -> refs/heads/main
 
 [commits]
 C0
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 7f768f4e639..907d906371d 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -210,7 +210,19 @@ where
         return Ok(None);
     }
     let destination_pin = selected_pin(&repository, selected)?;
-    let provisional = departure
+    let checkout_detaches = reference.is_none()
+        && destination_pin
+            .as_ref()
+            .is_none_or(|pin| pin.target.try_name().is_none());
+    let head_pin = head_ref
+        .as_ref()
+        .filter(|name| checkout_detaches && name.as_bstr().starts_with(b"refs/heads/"))
+        .map(|name| create_or_update_head_pin(&repository, name, head_id))
+        .transpose()?;
+    let provisional = head_pin
+        .is_none()
+        .then_some(departure)
+        .flatten()
         .filter(|departure| *departure != selected)
         .map(|departure| {
             let target = head_ref.clone().map_or(Target::Object(departure), Target::Symbolic);
@@ -219,12 +231,15 @@ where
         .transpose()?;
     drop(repository);
     let checkout = match (reference, &destination_pin) {
-        (Some(reference), _) => checkout_branch(&workdir, reference),
+        (Some(reference), _) => checkout_branch(&workdir, reference.as_ref()),
         (None, Some(pin)) => checkout_pin(&workdir, pin),
         (None, None) => checkout_detached(&workdir, selected),
     };
     if let Err(checkout) = checkout {
-        if let Some((pin, true)) = provisional.as_ref() {
+        let cleanup_pin = head_pin
+            .as_ref()
+            .or_else(|| provisional.as_ref().and_then(|(pin, created)| created.then_some(pin)));
+        if let Some(pin) = cleanup_pin {
             let cleanup = open_repository(repository_path, bare, false)
                 .context("could not reopen repository to remove a provisional pin")
                 .and_then(|repository| delete_pin(&repository, pin));
@@ -253,14 +268,17 @@ where
     {
         notice = format!("{notice}; destination pin remains: {err:#}");
     }
-    let snapshot = history::snapshot_ignoring_pin(
-        &repository,
-        revisions,
-        &[],
-        include_worktrees,
-        provisional.as_ref().map(|(pin, _)| pin.name.as_bstr()),
-    )?;
+    if let Some(addition) = reconcile_head_pin(&repository, &workdir)? {
+        notice = format!("{notice}; {addition}");
+    }
     if let Some((provisional, _)) = provisional {
+        let snapshot = history::snapshot_ignoring_pin(
+            &repository,
+            revisions,
+            &[],
+            include_worktrees,
+            Some(provisional.name.as_bstr()),
+        )?;
         if snapshot
             .view_tips
             .iter()
@@ -505,7 +523,7 @@ fn pending_base(repository: &gix::Repository, selected: ObjectId) -> Result<Opti
 fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
     let mut pins: Vec<_> = history::all_pins(repository)?
         .into_iter()
-        .filter(|pin| pin.id == selected)
+        .filter(|pin| !pin.is_head() && pin.id == selected)
         .collect();
     pins.sort_by(|a, b| {
         a.target
@@ -517,6 +535,69 @@ fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Opti
     Ok(pins.into_iter().next())
 }
 
+fn create_or_update_head_pin(
+    repository: &gix::Repository,
+    branch: &gix::refs::FullName,
+    id: ObjectId,
+) -> Result<history::Pin> {
+    let name: gix::refs::FullName = history::HEAD_PIN_NAME
+        .as_bstr()
+        .try_into()
+        .context("the HEAD pin name is valid")?;
+    let expected = repository
+        .try_find_reference(name.as_ref())
+        .context("could not read the existing HEAD pin")?
+        .map_or(PreviousValue::MustNotExist, |reference| {
+            PreviousValue::MustExistAndMatch(reference.target().into_owned())
+        });
+    let target = Target::Symbolic(branch.clone());
+    repository
+        .edit_references([RefEdit {
+            change: Change::Update {
+                log: LogChange {
+                    mode: RefLog::AndReference,
+                    force_create_reflog: false,
+                    message: "tix remember HEAD branch".into(),
+                },
+                expected,
+                new: target.clone(),
+            },
+            name: name.clone(),
+            deref: false,
+        }])
+        .context("could not remember the branch HEAD was attached to")?;
+    Ok(history::Pin { name, target, id })
+}
+
+fn reconcile_head_pin(repository: &gix::Repository, workdir: &Path) -> Result<Option<String>> {
+    let Some(pin) = history::all_pins(repository)?.into_iter().find(history::Pin::is_head) else {
+        return Ok(None);
+    };
+    let head = repository.head().context("could not read HEAD after time-travel")?;
+    let detached = head.is_detached();
+    let head_id = head.id().map(gix::Id::detach);
+    drop(head);
+    if !detached {
+        return Ok(delete_pin(repository, &pin)
+            .err()
+            .map(|err| format!("HEAD pin remains: {err:#}")));
+    }
+    if head_id != Some(pin.id) {
+        return Ok(None);
+    }
+    let branch = pin.target.try_name().context("the HEAD pin is not symbolic")?;
+    if let Err(err) = checkout_branch(workdir, branch) {
+        return Ok(Some(format!(
+            "could not reattach HEAD to {}: {err:#}; HEAD pin remains",
+            branch.shorten()
+        )));
+    }
+    Ok(Some(match delete_pin(repository, &pin) {
+        Ok(()) => format!("reattached HEAD to {}", branch.shorten()),
+        Err(err) => format!("reattached HEAD to {}; HEAD pin remains: {err:#}", branch.shorten()),
+    }))
+}
+
 pub(crate) fn create_or_reuse_pin(
     repository: &gix::Repository,
     target: Target,
@@ -524,7 +605,7 @@ pub(crate) fn create_or_reuse_pin(
     reflog_message: &str,
 ) -> Result<(history::Pin, bool)> {
     let pins = history::all_pins(repository)?;
-    if let Some(pin) = pins.iter().find(|pin| pin.target == target) {
+    if let Some(pin) = pins.iter().find(|pin| !pin.is_head() && pin.target == target) {
         return Ok((pin.clone(), false));
     }
     let hex = id.to_hex().to_string();
@@ -584,7 +665,7 @@ pub(crate) fn remove_pins(repository_path: &Path, bare: bool, selected: ObjectId
         open_repository(repository_path, bare, false).context("could not open repository to remove pins")?;
     let pins: Vec<_> = history::all_pins(&repository)?
         .into_iter()
-        .filter(|pin| pin.id == selected)
+        .filter(|pin| !pin.is_head() && pin.id == selected)
         .collect();
     if pins.is_empty() {
         return Ok(0);
@@ -625,7 +706,7 @@ fn delete_deferred_refs(repository_path: &Path, bare: bool, refs: &[(gix::refs::
     Ok(())
 }
 
-fn checkout_branch(workdir: &Path, name: &gix::refs::FullName) -> Result<()> {
+fn checkout_branch(workdir: &Path, name: &gix::refs::FullNameRef) -> Result<()> {
     let branch = name
         .as_bstr()
         .strip_prefix(b"refs/heads/")
@@ -976,12 +1057,17 @@ mod tests {
         let notice = perform(&repository_path, false, root, &graph, &[], &[], false)?
             .complete()?
             .context("time-travel changed HEAD")?;
-        assert!(notice.contains("saved pin:"), "{notice}");
+        assert!(notice.contains("time-travelled"), "{notice}");
         let repository = crate::test_repository::open(fixture.path())?;
         assert!(repository.head()?.is_detached(), "travel detaches HEAD");
         assert_eq!(repository.head_id()?.detach(), root);
         let pins = history::all_pins(&repository)?;
         assert_eq!(pins.len(), 1, "the lost branch tip gets one pin");
+        assert_eq!(
+            pins[0].name.as_bstr(),
+            b"refs/worktree/tix/pins/HEAD".as_bstr(),
+            "an attached departure uses the singleton HEAD pin"
+        );
         assert_eq!(
             pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
             Some(b"refs/heads/main".as_bstr())
@@ -993,6 +1079,15 @@ mod tests {
                 .contains(&main)
         );
 
+        let middle = repository.rev_parse_single("main~1")?.detach();
+        drop(repository);
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(repository.head()?.is_detached(), "further travel remains detached");
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "further travel keeps only the singleton HEAD pin");
+        assert!(pins[0].is_head());
+
         repository
             .find_reference("refs/heads/main")?
             .set_target_id(topic, "advance pinned branch")?;
@@ -1032,6 +1127,69 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn explicit_attachment_clears_the_head_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let topic_ref = repository.find_reference("refs/heads/topic")?.name().to_owned();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        move_head_to(&repository_path, false, topic, Some(&topic_ref), &[], false, Some)?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(topic_ref.into())
+        );
+        assert!(
+            history::all_pins(&repository)?.iter().all(|pin| !pin.is_head()),
+            "an explicit attachment clears the remembered branch"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn failed_reattachment_keeps_the_head_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let linked = fixture.path().join("main-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("main")
+            .status()?;
+        assert!(worktree.success(), "another worktree checks out the remembered branch");
+
+        let notice = perform(&repository_path, false, main, &graph, &[], &[], false)?
+            .complete()?
+            .context("travel reports the failed reattachment")?;
+        assert!(notice.contains("could not reattach HEAD to main"), "{notice}");
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(
+            repository.head()?.is_detached(),
+            "the successful detached checkout is retained"
+        );
+        assert_eq!(repository.head_id()?.detach(), main);
+        assert!(
+            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            "the HEAD pin remains available for a later retry"
+        );
+        Ok(())
+    }
+
     #[test]
     fn returning_to_a_commit_restores_its_manual_stash() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -1080,18 +1238,22 @@ mod tests {
         ] {
             repository.reference(name, target, PreviousValue::MustNotExist, "test pin removal")?;
         }
+        let main = repository.find_reference("refs/heads/main")?.name().to_owned();
+        create_or_update_head_pin(&repository, &main, selected)?;
+        let (manual, created) = create_or_reuse_pin(
+            &repository,
+            Target::Symbolic(main),
+            selected,
+            "test ordinary symbolic pin",
+        )?;
+        assert!(created && !manual.is_head(), "manual pins never reuse the HEAD pin");
         drop(repository);
 
-        assert_eq!(remove_pins(&repository_path, false, selected)?, 2);
+        assert_eq!(remove_pins(&repository_path, false, selected)?, 3);
         let repository = crate::test_repository::open(fixture.path())?;
-        assert_eq!(
-            history::all_pins(&repository)?
-                .into_iter()
-                .map(|pin| pin.id)
-                .collect::<Vec<_>>(),
-            [other],
-            "pins on other commits remain"
-        );
+        let pins = history::all_pins(&repository)?;
+        assert!(pins.iter().any(history::Pin::is_head), "unpin preserves the HEAD pin");
+        assert!(pins.iter().any(|pin| pin.id == other), "pins on other commits remain");
         Ok(())
     }
 
@@ -1146,10 +1308,13 @@ mod tests {
         drop(repository);
 
         perform(&repository_path, false, root, &graph, &[], &revisions, false)?.complete()?;
-        assert!(
-            history::all_pins(&crate::test_repository::open(fixture.path())?)?.is_empty(),
-            "an explicit tip already retains the former HEAD"
+        let pins = history::all_pins(&crate::test_repository::open(fixture.path())?)?;
+        assert_eq!(
+            pins.len(),
+            1,
+            "the singleton is retained even when the branch is an explicit tip"
         );
+        assert!(pins[0].is_head());
 
         let checkout = Command::new("git")
             .arg("-C")
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 0d63915d79d..759963b26ce 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -30,6 +30,7 @@ pub(crate) struct Decoration {
 pub(crate) enum DecorationKind {
     Head,
     Pin,
+    HeadPinBranch,
     Stash,
     Review,
     CurrentWorktreeBranch,
@@ -45,6 +46,7 @@ pub(crate) enum DecorationKind {
 pub(crate) type Decorations = HashMap<ObjectId, Vec<Decoration>>;
 
 pub(crate) const PIN_PREFIX: &[u8] = b"refs/worktree/tix/pins/";
+pub(crate) const HEAD_PIN_NAME: &[u8] = b"refs/worktree/tix/pins/HEAD";
 pub(crate) const STASH_PREFIX: &[u8] = b"refs/tix/stash/";
 pub(crate) const REVIEW_PREFIX: &[u8] = b"refs/worktree/tix/review/";
 pub(crate) const REVIEW_STASH_PREFIX: &[u8] = b"refs/worktree/tix/review/stashes/";
@@ -56,6 +58,12 @@ pub(crate) struct Pin {
     pub id: ObjectId,
 }
 
+impl Pin {
+    pub(crate) fn is_head(&self) -> bool {
+        self.name.as_bstr() == HEAD_PIN_NAME
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct WorktreeCheckout {
     pub id: ObjectId,
@@ -387,7 +395,10 @@ impl HistoryGraph {
             .map(|decoration| {
                 let upstream = if matches!(
                     decoration.kind,
-                    DecorationKind::Local | DecorationKind::CurrentWorktreeBranch | DecorationKind::WorktreeBranch
+                    DecorationKind::Local
+                        | DecorationKind::HeadPinBranch
+                        | DecorationKind::CurrentWorktreeBranch
+                        | DecorationKind::WorktreeBranch
                 ) {
                     tracked
                         .into_iter()
@@ -1316,6 +1327,14 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
         }
         let name = reference.name().to_owned();
         let target = reference.target().into_owned();
+        if name.as_bstr() == HEAD_PIN_NAME
+            && !target
+                .try_name()
+                .is_some_and(|name| name.as_bstr().starts_with(b"refs/heads/"))
+        {
+            tracing::warn!(name = %name, "ignoring malformed HEAD pin");
+            continue;
+        }
         let id = match reference.peel_to_id() {
             Ok(id) => id.detach(),
             Err(err) => {
@@ -1354,7 +1373,8 @@ pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
     Ok(pins
         .into_iter()
         .filter(|pin| {
-            pin.id != head_id
+            !pin.is_head()
+                && pin.id != head_id
                 && repo
                     .merge_base(head_id, pin.id)
                     .is_ok_and(|base| base.as_ref() == head_id)
@@ -1599,6 +1619,11 @@ impl Authors {
 
 pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[WorktreeCheckout]) -> Result<Decorations> {
     let mut out = Decorations::new();
+    let head_pin_branch = pins
+        .iter()
+        .find(|pin| pin.is_head())
+        .and_then(|pin| pin.target.try_name())
+        .map(ToOwned::to_owned);
     let pins: HashSet<_> = pins.iter().map(|pin| pin.name.as_bstr()).collect();
     let review_count = all_reviews(repo)?.len();
     for reference in repo
@@ -1613,6 +1638,9 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let full_name = reference.name().to_owned();
+        if full_name.as_bstr() == HEAD_PIN_NAME {
+            continue;
+        }
         if full_name.as_bstr().starts_with(REVIEW_STASH_PREFIX) {
             continue;
         }
@@ -1660,6 +1688,9 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         }) {
             kind = DecorationKind::WorktreeBranch;
         }
+        if head_pin_branch.as_ref() == Some(&full_name) {
+            kind = DecorationKind::HeadPinBranch;
+        }
         let mut name = pin_suffix.map_or_else(
             || {
                 review_suffix.as_ref().map_or_else(
@@ -2452,11 +2483,48 @@ mod tests {
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test non-commit pin",
         )?;
+        repo.reference(
+            HEAD_PIN_NAME.as_bstr(),
+            head,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test non-symbolic HEAD pin",
+        )?;
 
         assert!(all_pins(&repo)?.is_empty(), "invalid pins never enter history");
         Ok(())
     }
 
+    #[test]
+    fn head_pin_marks_its_branch_without_an_ordinary_pin_decoration() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let symbolic = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["symbolic-ref", "refs/worktree/tix/pins/HEAD", "refs/heads/main"])
+            .status()?;
+        assert!(symbolic.success(), "git creates the symbolic HEAD pin");
+        let detached = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["checkout", "-q", "--detach", "main~2"])
+            .status()?;
+        assert!(detached.success(), "git detaches HEAD below the remembered branch");
+
+        let repo = crate::test_repository::open(fixture.path())?;
+        let main = repo.rev_parse_single("main")?.detach();
+        let snapshot = snapshot(&repo, &[], &[], false)?;
+        assert!(snapshot.view_tips.contains(&main), "the HEAD pin retains its branch");
+        let decorations = decorations(&repo, &snapshot.pins, &snapshot.worktrees)?;
+        let main = decorations.get(&main).expect("the remembered branch is decorated");
+        assert!(
+            main.iter()
+                .any(|decoration| { decoration.kind == DecorationKind::HeadPinBranch && decoration.name == "main" })
+        );
+        assert!(
+            main.iter().all(|decoration| decoration.kind != DecorationKind::Pin),
+            "the HEAD pin has no ordinary pin marker"
+        );
+        Ok(())
+    }
+
     #[test]
     fn review_resources_are_not_history_tips_and_stashes_are_not_decorations() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8c1b03135fc..7a314f183f2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1769,6 +1769,8 @@ fn metadata_line<'a>(
                     DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
                 ) {
                     format!("{name}@").into()
+                } else if decoration.kind == DecorationKind::HeadPinBranch {
+                    format!("★{name}").into()
                 } else if decoration.kind == DecorationKind::CurrentWorktreeBranch {
                     format!("@{name}").into()
                 } else {
@@ -1944,6 +1946,7 @@ fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
+        DecorationKind::HeadPinBranch => Style::default().fg(Color::Cyan),
         DecorationKind::Stash => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::Review => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::CurrentWorktreeBranch => Style::default().fg(Color::Cyan),
@@ -2974,6 +2977,24 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
+
+        app.ref_mode = RefMode::Default;
+        decorations.insert(
+            selected,
+            vec![Decoration {
+                name: "main".into(),
+                kind: DecorationKind::HeadPinBranch,
+            }],
+        );
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let row = rendered_row(&terminal);
+        assert!(
+            row.contains("★main"),
+            "the remembered branch has its dedicated marker: {row:?}"
+        );
+        assert!(!row.contains("📌"), "the HEAD pin is not an ordinary pin: {row:?}");
+        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
+        assert!(!rendered_line(&terminal, 1).contains("unpin"));
         Ok(())
     }
 

From ffbdbf003810cd3b5c60b1efb9ae919d1b825936 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 14:41:04 +0200
Subject: [PATCH 155/282] feat: add a reference tree and broaden rebase ref
 editing

Add a rounded first-parent reference projection over the already loaded history graph. It contracts linear runs while retaining references, forks, roots, boundaries, and raw tips, uses all-parent reachability for selection counts, and provides independent spatial or topological navigation plus complete ASCII and Unicode `tix tree` diagnostics.

Reuse the loaded graph and reference snapshot for tree toggling and tag, hidden-history, and worktree filtering so cursor movement never reopens the repository or traverses commits. Extend rebase todo editing to import existing direct refs outside the generated stack and permit attaching HEAD to an imported local branch under the existing compare-and-swap and worktree preflight rules.
---
 gix-tix/spec.md                 |   62 +-
 gix-tix/src/app.rs              |   48 +-
 gix-tix/src/command.rs          |   78 +-
 gix-tix/src/edit/rebase.rs      |   20 +-
 gix-tix/src/edit/time_travel.rs |   29 +-
 gix-tix/src/edit/todo.rs        |   93 +-
 gix-tix/src/history.rs          |   98 ++-
 gix-tix/src/lib.rs              |  176 +++-
 gix-tix/src/tree.rs             | 1417 +++++++++++++++++++++++++++++++
 gix-tix/src/ui.rs               |   10 +-
 10 files changed, 1969 insertions(+), 62 deletions(-)
 create mode 100644 gix-tix/src/tree.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 49d30589ad9..f44122557cc 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -186,6 +186,52 @@ without trading responsiveness for metadata that is not visible.
   can be made, and cache completed results. They must never reopen a repository
   merely because selection moved.
 
+### Tree overviews
+
+- After traversal completes, `t` toggles history and a rounded rail tree.
+  `Escape` also returns directly to history. The tree cursor and viewport are
+  independent of the history selection and panes, and the tree provides
+  navigation only. The direct tree action appears in the `?` information group.
+- The overview uses normal references and raw revision tips already present in
+  the completed graph, including traversed hidden history; it never causes more
+  repository traversal. Special refs are excluded. First-parent paths form a
+  forest whose referenced commits, forks, roots, shallow boundaries, and raw
+  tips remain as nodes while linear runs are contracted. `Shift-T` toggles
+  tags; when hidden, tag labels and tag-only anchors are removed before this
+  projection.
+- The component containing `HEAD` sorts first. Children sort by their smallest
+  reference label and then object ID. Initial selection is `HEAD`, then a raw
+  tip, then the first node; refresh and re-entry preserve the tree cursor when
+  its commit remains available.
+- The selected node shows the exact number of commits reachable
+  through all parents. Other reference and raw-tip nodes show the number reachable
+  from them but not from the selection as `N●`; multiple labels at one commit
+  share one count. Selected first-parent ancestry is emphasized, other reachable
+  history is dimmed, and exclusive history remains normal. A non-selectable `●`
+  splits a contracted edge where it becomes reachable. Reachability and boundaries
+  are computed when selection changes; exact exclusive counts are computed and
+  cached only for reference rows visible in the viewport.
+- The tree orders tips above roots and renders one retained or boundary
+  node per row. Rounded ancestry lanes precede aligned counts and labels; their
+  disk is the node marker, so counts do not repeat it.
+- Rendering clips lanes and node labels to the viewport.
+- `Tab` switches nearest-direction and topological movement.
+  Nearest movement chooses the closest node in the requested screen direction.
+  Topological Up moves toward leaves, Down toward roots, and Left/Right chooses
+  a remembered child; `i/n` and an emphasized edge show the choice.
+- `g` selects the top tree node, and `Shift-G` selects the root of the current
+  component. Shift-modified directions pan the tree viewport; mouse and the existing
+  Ctrl/Page keys scroll without moving the tree cursor.
+
+### Tree diagnostics
+
+- `tix tree` prints the entire reference projection to standard output without
+  terminal colors, selection state, counts, or viewport clipping. It traverses
+  all normal references by default; positional revisions scope traversal.
+- `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
+  corresponding tree inputs. Output uses ASCII lines and `o` nodes by default;
+  `--unicode` uses the interactive tree's rounded line and node glyphs.
+
 ## Interaction
 
 ### Navigation and display controls
@@ -199,6 +245,7 @@ without trading responsiveness for metadata that is not visible.
 | `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. Its actions remain direct shortcuts. |
+| `t` | Toggle the rounded tree overview. |
 | `[` | Toggle graph/metadata alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Toggle committer dates. |
@@ -698,20 +745,25 @@ space first; changes blocks adapt within the remaining history width.
   sole editable representation.
   Existing displayed names may be moved or removed, and new unqualified names
   create local branches; explicit editable `refs/...` names are also accepted.
+  Existing editable direct refs outside the generated todo are imported with
+  their current target as compare-and-swap state and may be placed the same way.
   Short names follow the history display, ambiguous names expand to full names,
   and Git quoting preserves arbitrary bytes. Tags, remote-tracking refs, general
-  symbolic refs, tix pins, and review resources remain hidden and unchanged.
+  symbolic refs, tix pins, stashes, and review resources remain hidden and
+  unchanged.
 - Pick lines use display-only state symbols documented in the footer: `↻` for a
   lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
   unverified signature, and `○` for an unsigned commit. Applicable states may be
   combined without changing plan semantics.
 - `@pick`, `@squash`, or `@empty` chooses the post-rebase commit. A generated
   todo keeps this marker even when `HEAD` is attached, but shows its branch as an
-  ordinary ref. Versioned state remembers that attachment while the branch stays
+  ordinary ref. Versioned state remembers that attachment while the ref stays
   at the marked result. Moving it elsewhere detaches `HEAD`; adding `@` to one
-  local branch explicitly attaches it and is valid only at the marked result.
-  Removing the name deletes the branch. Checkout markers are invalid without a
-  worktree. Todo generation and application reject an unborn `HEAD`.
+  editable ref explicitly attaches it and is valid only at the marked result.
+  The ref may be imported from outside the generated todo and is moved before
+  `HEAD` is made symbolic to it. Removing the name deletes the ref. Checkout
+  markers are invalid without a worktree. Todo generation and application
+  reject an unborn `HEAD`.
 - Within the ancestry ending at `@`, unchanged picks whose original parent is
   still their planned parent retain their IDs. Eager cherry-picking and re-signing
   starts at the first pending or structurally changed commit. Any descendants
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index bc4a83ade09..8ad931b8904 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -288,6 +288,7 @@ pub(crate) enum Action {
     Refresh,
     ToggleHidden,
     ToggleHistoryDisplay,
+    ToggleTree,
     ToggleEdit,
     ToggleInformation,
     ToggleAlign,
@@ -845,6 +846,7 @@ impl App {
                 | Action::ToggleAlign
                 | Action::ToggleCommit
                 | Action::ToggleChanges
+                | Action::ToggleTree
         ) {
             self.information_expanded = false;
         }
@@ -2191,7 +2193,7 @@ impl RenderedLanes {
 }
 
 #[derive(Default)]
-struct LaneState {
+pub(crate) struct LaneState {
     columns: Vec<ObjectId>,
     next: Vec<ObjectId>,
     parents: Vec<(ObjectId, Option<usize>, usize)>,
@@ -2201,14 +2203,28 @@ struct LaneState {
 
 impl LaneState {
     fn advance(&mut self, row: &CommitRow, out: Option<&mut String>) -> Option<Range<usize>> {
+        self.advance_ids(row.id, row.parent_ids.iter().copied(), out, '●')
+    }
+
+    pub(crate) fn advance_ids(
+        &mut self,
+        id: ObjectId,
+        parent_ids: impl IntoIterator<Item = ObjectId>,
+        out: Option<&mut String>,
+        marker: char,
+    ) -> Option<Range<usize>> {
         let render = out.is_some();
-        let current = self.columns.iter().position(|id| *id == row.id).unwrap_or_else(|| {
-            self.columns.push(row.id);
-            self.columns.len() - 1
-        });
+        let current = self
+            .columns
+            .iter()
+            .position(|candidate| *candidate == id)
+            .unwrap_or_else(|| {
+                self.columns.push(id);
+                self.columns.len() - 1
+            });
 
         self.parents.clear();
-        for parent in row.parent_ids.iter().copied() {
+        for parent in parent_ids {
             if !self.parents.iter().any(|(id, _, _)| *id == parent) {
                 self.parents
                     .push((parent, self.columns.iter().position(|id| *id == parent), 0));
@@ -2260,11 +2276,27 @@ impl LaneState {
                 &self.edges,
                 &mut self.cells,
                 out,
+                marker,
             )
         });
         std::mem::swap(&mut self.columns, &mut self.next);
         range
     }
+
+    pub(crate) fn node_line(&self, id: ObjectId, marker: char) -> String {
+        let current = self
+            .columns
+            .iter()
+            .position(|candidate| *candidate == id)
+            .unwrap_or(self.columns.len());
+        let mut cells = vec![' '; self.columns.len().max(current + 1) * 2 - 1];
+        for column in 0..self.columns.len() {
+            cells[column * 2] = '│';
+        }
+        cells[current * 2] = marker;
+        cells.push(' ');
+        cells.into_iter().collect()
+    }
 }
 
 fn transition(
@@ -2274,6 +2306,7 @@ fn transition(
     edges: &[(usize, usize)],
     cells: &mut Vec<u8>,
     out: &mut String,
+    marker: char,
 ) -> Range<usize> {
     const UP: u8 = 1;
     const DOWN: u8 = 2;
@@ -2317,7 +2350,7 @@ fn transition(
     let start = out.len();
     for (index, cell) in cells.iter().copied().enumerate() {
         out.push(if index == current * 2 {
-            '●'
+            marker
         } else {
             match cell {
                 0 => ' ',
@@ -3462,6 +3495,7 @@ mod tests {
             Action::ToggleCommit,
             Action::ToggleChanges,
             Action::VerifySignatures,
+            Action::ToggleTree,
         ] {
             app.update(action);
             assert!(app.information_expanded, "information actions keep the group open");
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index d5098e1b5af..e30bf6a1449 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -32,6 +32,8 @@ pub struct Platform {
 
 #[derive(Debug, clap::Subcommand)]
 enum Command {
+    /// Print the complete reference tree without opening the terminal UI.
+    Tree(Tree),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend,
     /// Move the changes introduced by HEAD into the worktree.
@@ -49,6 +51,28 @@ enum Command {
     Rebase(rebase::Command),
 }
 
+#[derive(Debug, clap::Args)]
+struct Tree {
+    /// Print help.
+    #[arg(long, action = clap::ArgAction::HelpLong)]
+    help: Option<bool>,
+    /// Omit tags as labels, traversal tips, and topology anchors.
+    #[arg(long)]
+    no_tags: bool,
+    /// Include detached and linked-worktree HEADs as traversal tips.
+    #[arg(short = 'w', long)]
+    worktrees: bool,
+    /// Hide this revision and every commit reachable from it.
+    #[arg(long, value_name = "REVSPEC")]
+    hide: Vec<OsString>,
+    /// Use the tree view's Unicode line and node glyphs instead of ASCII.
+    #[arg(long)]
+    unicode: bool,
+    /// Revisions to traverse instead of all normal references.
+    #[arg(value_name = "REVSPEC")]
+    revisions: Vec<OsString>,
+}
+
 #[derive(Debug, clap::Args)]
 struct Pin {
     /// Revisions resolving to commits to pin.
@@ -96,9 +120,14 @@ impl Platform {
             );
         };
 
-        let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         let repository = repository.to_thread_local();
+        let command = match command {
+            Command::Tree(args) => return print_tree(&repository, args),
+            command => command,
+        };
+        let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         match command {
+            Command::Tree(_) => unreachable!("tree commands return before logging"),
             Command::Amend => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?;
@@ -120,6 +149,24 @@ impl Platform {
     }
 }
 
+fn print_tree(repository: &gix::Repository, args: Tree) -> Result<()> {
+    let revisions = if args.revisions.is_empty() {
+        crate::history::tree_revisions(repository, !args.no_tags)?
+    } else {
+        args.revisions
+    };
+    let rendered = crate::tree::render_full(
+        repository,
+        &revisions,
+        &args.hide,
+        args.worktrees,
+        !args.no_tags,
+        args.unicode,
+    )?;
+    std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes()).context("could not write tree")?;
+    Ok(())
+}
+
 fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
     for pin in create_pins(repository, &args.revisions)? {
         println!("{}", display_pin(repository, &pin)?);
@@ -236,6 +283,35 @@ mod tests {
         );
         assert!(cli.platform.command.is_none(), "omitting a command launches the TUI");
 
+        let tree = Cli::try_parse_from([
+            "tix",
+            "tree",
+            "--no-tags",
+            "--worktrees",
+            "--hide",
+            "private",
+            "--unicode",
+            "main",
+            "topic",
+        ])
+        .expect("tree options parse")
+        .platform
+        .command;
+        let Some(Command::Tree(tree)) = tree else {
+            panic!("tree was expected")
+        };
+        assert!(tree.help.is_none());
+        assert!(tree.no_tags);
+        assert!(tree.worktrees);
+        assert_eq!(tree.hide, ["private"]);
+        assert!(tree.unicode);
+        assert_eq!(tree.revisions, ["main", "topic"]);
+
+        assert!(
+            Cli::try_parse_from(["tix", "tree", "--layout", "rail"]).is_err(),
+            "the removed layout selector is rejected"
+        );
+
         assert!(matches!(
             Cli::try_parse_from(["tix", "amend"])
                 .expect("amend parses")
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 870a969491a..189d25db84b 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1677,15 +1677,25 @@ fn marked_parent(commit: &gix::objs::Commit) -> Result<Option<ObjectId>> {
         .extra_headers
         .iter()
         .find(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
-        .map(|(_, value)| {
-            ObjectId::from_hex(value)
-                .context("pending rebase has an invalid original parent")
-                .map(|id| (!id.is_null()).then_some(id))
-        })
+        .map(|(_, value)| parse_marked_parent(value.as_bstr()))
         .transpose()
         .map(Option::flatten)
 }
 
+pub(crate) fn marked_parent_ref(commit: &gix::objs::CommitRef<'_>) -> Result<Option<Option<ObjectId>>> {
+    commit
+        .extra_headers()
+        .find("tix-rebase-parent")
+        .map(parse_marked_parent)
+        .transpose()
+}
+
+fn parse_marked_parent(value: &BStr) -> Result<Option<ObjectId>> {
+    ObjectId::from_hex(value)
+        .context("pending rebase has an invalid original parent")
+        .map(|id| (!id.is_null()).then_some(id))
+}
+
 pub(super) fn has_marker(commit: &gix::objs::Commit) -> bool {
     commit
         .extra_headers
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 907d906371d..27358054a9a 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -231,7 +231,7 @@ where
         .transpose()?;
     drop(repository);
     let checkout = match (reference, &destination_pin) {
-        (Some(reference), _) => checkout_branch(&workdir, reference.as_ref()),
+        (Some(reference), _) => checkout_reference(repository_path, bare, &workdir, selected, reference),
         (None, Some(pin)) => checkout_pin(&workdir, pin),
         (None, None) => checkout_detached(&workdir, selected),
     };
@@ -720,6 +720,33 @@ fn checkout_branch(workdir: &Path, name: &gix::refs::FullNameRef) -> Result<()>
     )
 }
 
+fn checkout_reference(
+    repository_path: &Path,
+    bare: bool,
+    workdir: &Path,
+    selected: ObjectId,
+    name: &gix::refs::FullName,
+) -> Result<()> {
+    checkout_detached(workdir, selected)?;
+    open_repository(repository_path, bare, false)
+        .context("could not reopen repository to attach HEAD")?
+        .edit_reference(RefEdit {
+            name: "HEAD".try_into().expect("valid reference name"),
+            deref: false,
+            change: Change::Update {
+                log: LogChange {
+                    mode: RefLog::AndReference,
+                    force_create_reflog: false,
+                    message: "tix attach HEAD".into(),
+                },
+                expected: PreviousValue::MustExistAndMatch(Target::Object(selected)),
+                new: Target::Symbolic(name.clone()),
+            },
+        })
+        .context("could not attach HEAD to the selected reference")?;
+    Ok(())
+}
+
 fn checkout_pin(workdir: &Path, pin: &history::Pin) -> Result<()> {
     match pin.target.try_name() {
         Some(name) => {
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 6d0910d7ac9..905a85371b7 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -20,9 +20,9 @@ const HELP: &str = r#"
 - `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
-- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs. The current attached branch stays attached while it remains at the `@` command. Prefix one local branch with `@` to attach HEAD to it explicitly; it must point to the `@` command.
+- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs, including existing editable refs outside the generated todo. The current attached ref stays attached while it remains at the `@` command. Prefix one editable ref with `@` to attach HEAD to it explicitly; it must point to the `@` command.
 - Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. Unchanged picks whose parent stays unchanged retain their IDs; replay starts at the first pending or structurally changed commit. Changed commits through `@` are cherry-picked and re-signed, while descendants and other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
-- Tix pins and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A branch checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
+- Tix pins, stashes, and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A ref checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
 - Commit states are display-only and editing them has no effect: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, `○` means unsigned, and `🎁` means worktree state is stashed for that commit. Stashes follow rewritten commits automatically; dropping a stashed commit or combining multiple stashes into one result is rejected.
 -->
@@ -723,13 +723,12 @@ fn validate_state(repo: &gix::Repository, state: &State) -> Result<()> {
         }
     }
     if let Some(name) = &state.head_ref
-        && (name.category() != Some(gix::refs::Category::LocalBranch)
-            || !state
-                .expected_refs
-                .iter()
-                .any(|reference| reference.editable && reference.name == *name))
+        && !state
+            .expected_refs
+            .iter()
+            .any(|reference| reference.editable && reference.name == *name)
     {
-        anyhow::bail!("the recorded HEAD ref is not an editable local branch");
+        anyhow::bail!("the recorded HEAD ref is not editable");
     }
     for tip in &state.tips {
         repo.find_commit(*tip).context("could not find a recorded rebase tip")?;
@@ -824,9 +823,6 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
                     if !state.checkout_allowed || repo.workdir().is_none() {
                         anyhow::bail!("the rebase todo cannot select a checkout without a worktree");
                     }
-                    if name.category() != Some(gix::refs::Category::LocalBranch) {
-                        anyhow::bail!("only a local branch may carry the @ marker");
-                    }
                     if explicit_checkout_reference.replace((name, target)).is_some() {
                         anyhow::bail!("the rebase todo contains more than one @ reference");
                     }
@@ -1070,6 +1066,7 @@ fn resolve_ref_name(
     };
     let name = gix::refs::FullName::try_from(full).context("the todo contains an invalid reference name")?;
     if name.as_bstr().starts_with(crate::history::PIN_PREFIX)
+        || name.as_bstr().starts_with(crate::history::STASH_PREFIX)
         || name.as_bstr().starts_with(crate::history::REVIEW_PREFIX)
         || matches!(
             name.category(),
@@ -1081,14 +1078,20 @@ fn resolve_ref_name(
     if refs.iter().any(|reference| reference.name == name) {
         anyhow::bail!("the todo cannot edit a hidden reference");
     }
-    if repo.try_find_reference(name.as_ref())?.is_some() {
-        anyhow::bail!("an existing reference outside the editable history cannot be moved");
-    }
+    let old = repo
+        .try_find_reference(name.as_ref())?
+        .map(|reference| {
+            reference
+                .try_id()
+                .map(gix::Id::detach)
+                .context("an existing symbolic reference outside the editable history cannot be moved")
+        })
+        .transpose()?;
     refs.push(rebase::ExpectedRef {
         name: name.clone(),
-        old: None,
-        target: repo.head_id()?.detach(),
-        new: None,
+        old,
+        target: old.unwrap_or(repo.head_id()?.detach()),
+        new: old,
         follows_tip: false,
         editable: true,
         placement: None,
@@ -1712,6 +1715,62 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn reference_lines_import_out_of_scope_refs_and_may_attach_head() -> gix_testtools::Result {
+        let (fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        for name in ["refs/heads/outside", "refs/patches/attach"] {
+            repo.reference(
+                name,
+                base,
+                gix::refs::transaction::PreviousValue::MustNotExist,
+                "create out-of-scope todo ref",
+            )?;
+        }
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let edited = with_state(
+            &prepared,
+            &format!(
+                "## fork {}\npick {}\n(outside)\n@pick {}\n(@refs/patches/attach)\n",
+                base.to_hex_with_len(7),
+                middle.to_hex_with_len(7),
+                tip.to_hex_with_len(7),
+            ),
+        );
+        let plan = parse_plan(&repo, &edited)?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = rebase::perform_plan(&repo, &graph, plan)?.complete()?;
+        let selected = outcome.selected.context("the todo retains its checkout")?;
+        super::super::time_travel::checkout_plan(repo.git_dir(), false, &outcome, &[], false)?;
+
+        assert_eq!(
+            repo.find_reference("refs/heads/outside")?.id().detach(),
+            outcome.map(middle).context("the middle commit is retained")?,
+            "an unmarked out-of-scope ref moves like a generated ref"
+        );
+        assert_eq!(
+            repo.find_reference("refs/patches/attach")?.id().detach(),
+            selected,
+            "the marked out-of-scope ref moves to the selected result"
+        );
+        assert_eq!(
+            repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(b"refs/patches/attach".as_bstr()),
+            "HEAD attaches to an editable ref outside refs/heads"
+        );
+        assert_eq!(
+            std::fs::read_to_string(fixture.path().join("tip"))?,
+            "tip\n",
+            "the selected worktree tree remains checked out"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?.index_tree,
+            Some(repo.find_commit(selected)?.tree_id()?.detach()),
+            "the index matches the attached commit"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rewritten_detached_head_is_not_pinned_before_checkout() -> gix_testtools::Result {
         let (fixture, repo) = repo()?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 759963b26ce..1a887e4a13f 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -157,6 +157,32 @@ impl PartialOrd for GenThenTime {
 }
 
 impl HistoryGraph {
+    #[cfg(test)]
+    pub(crate) fn from_test_commits(commits: &[(ObjectId, Vec<ObjectId>)]) -> Self {
+        let mut graph = HistoryGraph::default();
+        for (id, _) in commits {
+            graph.intern(*id).expect("the test graph fits into u32");
+        }
+        for (id, parents) in commits {
+            let index = graph.index(*id).expect("the test commit was interned");
+            let start = graph.parents.len() as u32;
+            let parents: Vec<_> = parents
+                .iter()
+                .map(|parent| graph.index(*parent).expect("the test parent was interned"))
+                .collect();
+            graph.parents.extend(parents);
+            let end = graph.parents.len() as u32;
+            graph.commits[index.as_usize()] = GraphCommit {
+                id: *id,
+                parents: start..end,
+                commit_time: index.as_usize() as i64,
+                generation: index.as_usize() as u32 + 1,
+                state: NODE_LOADED,
+            };
+        }
+        graph
+    }
+
     pub(crate) fn for_commits(repo: &gix::Repository, ids: &[ObjectId]) -> Result<Self> {
         let mut graph = HistoryGraph::default();
         let shallow: HashSet<_> = repo
@@ -191,7 +217,7 @@ impl HistoryGraph {
         Ok(index)
     }
 
-    fn index(&self, id: ObjectId) -> Option<CommitIndex> {
+    pub(crate) fn index(&self, id: ObjectId) -> Option<CommitIndex> {
         self.by_id.get(&id).copied()
     }
 
@@ -199,11 +225,15 @@ impl HistoryGraph {
         self.commits[index.as_usize()].id
     }
 
-    fn parents(&self, index: CommitIndex) -> &[CommitIndex] {
+    pub(crate) fn parents(&self, index: CommitIndex) -> &[CommitIndex] {
         let range = self.commits[index.as_usize()].parents.clone();
         &self.parents[range.start as usize..range.end as usize]
     }
 
+    pub(crate) fn commit_count(&self) -> usize {
+        self.commits.len()
+    }
+
     pub(crate) fn is_ancestor(&self, ancestor: ObjectId, descendant: ObjectId) -> bool {
         let (Some(ancestor), Some(descendant)) = (self.index(ancestor), self.index(descendant)) else {
             return false;
@@ -1168,6 +1198,40 @@ pub(crate) fn snapshot(
     snapshot_ignoring_pin(repo, revisions, hidden, include_worktrees, None)
 }
 
+pub(crate) fn tree_revisions(repo: &gix::Repository, include_tags: bool) -> Result<Vec<OsString>> {
+    let mut out = Vec::new();
+    for reference in repo
+        .references()
+        .context("could not open references")?
+        .all()
+        .context("could not iterate references")?
+    {
+        let mut reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
+        };
+        let name = reference.name().as_bstr().to_owned();
+        let kind = decoration_kind(&name);
+        if kind == DecorationKind::Special
+            || matches!(kind, DecorationKind::Tag) && !include_tags
+            || name.starts_with(STASH_PREFIX)
+            || name.starts_with(REVIEW_STASH_PREFIX)
+        {
+            continue;
+        }
+        let Ok(id) = reference.peel_to_id() else { continue };
+        if repo.find_header(id)?.kind() != gix::object::Kind::Commit {
+            continue;
+        }
+        out.push(gix::path::from_bstr(&name).into_owned().into_os_string());
+    }
+    if repo.head().is_ok_and(|head| head.referent_name().is_none()) {
+        out.push("HEAD".into());
+    }
+    Ok(out)
+}
+
 pub(crate) fn snapshot_ignoring_pin(
     repo: &gix::Repository,
     revisions: &[OsString],
@@ -2465,6 +2529,36 @@ mod tests {
         assert_eq!(decoration_kind(b"refs/stash"), DecorationKind::Special);
     }
 
+    #[test]
+    fn tree_revisions_cover_normal_refs_and_optionally_tags() -> gix_testtools::Result {
+        let fixture = fixture()?;
+        let repo = crate::test_repository::open(&fixture)?;
+        let names = |include_tags| {
+            tree_revisions(&repo, include_tags).map(|revisions| {
+                revisions
+                    .into_iter()
+                    .map(|revision| revision.to_string_lossy().into_owned())
+                    .collect::<Vec<_>>()
+            })
+        };
+
+        let with_tags = names(true)?;
+        let without_tags = names(false)?;
+        assert!(
+            with_tags.iter().any(|name| name.starts_with("refs/heads/")),
+            "branches are default traversal tips"
+        );
+        assert!(
+            with_tags.iter().any(|name| name.starts_with("refs/tags/")),
+            "tags are included by default"
+        );
+        assert!(
+            without_tags.iter().all(|name| !name.starts_with("refs/tags/")),
+            "tagless rendering does not traverse tag-only history"
+        );
+        Ok(())
+    }
+
     #[test]
     fn ignores_malformed_and_non_commit_pins() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index e5d4e909ea8..75e584d8ff1 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -10,6 +10,7 @@ mod history;
 mod logging;
 #[cfg(test)]
 mod test_repository;
+mod tree;
 mod ui;
 
 use std::{
@@ -949,6 +950,7 @@ fn event_loop(
         }
     }
     let mut decorations = Decorations::new();
+    let mut tree = tree::Tree::default();
     let mut motion = MotionState::default();
     let mut filesystem_responses = logging::FilesystemResponses::default();
     let mut focused = true;
@@ -967,6 +969,7 @@ fn event_loop(
         &mut line_diff_pool,
         &mut motion,
         focused,
+        &mut tree,
         &mut filesystem_responses,
     )?;
     let mut last_draw = Instant::now();
@@ -1247,8 +1250,9 @@ fn event_loop(
                 Ok((graph, result)) => {
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
-                    history_graph = Some(graph);
                     let result = result?;
+                    tree.rebuild(&graph, &result.refs, &result.decorations);
+                    history_graph = Some(graph);
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "history-refresh-completed");
@@ -1373,6 +1377,7 @@ fn event_loop(
                 &mut line_diff_pool,
                 &mut motion,
                 focused,
+                &mut tree,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1411,6 +1416,7 @@ fn event_loop(
                     history_finished = true;
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
+                    tree.rebuild(&graph, &ref_snapshot, &decorations);
                     history_graph = Some(graph);
                     update_hidden_branch_updates(&mut app, history_graph.as_ref(), &ref_snapshot);
                     selection_relation = None;
@@ -1441,6 +1447,7 @@ fn event_loop(
                 &mut line_diff_pool,
                 &mut motion,
                 focused,
+                &mut tree,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1480,6 +1487,24 @@ fn event_loop(
         let Some(terminal_event) = terminal_event else {
             continue;
         };
+        if tree.is_active() {
+            match &terminal_event {
+                TerminalEvent::Key(key) if key.kind != KeyEventKind::Release => match tree.handle_key(*key) {
+                    tree::Input::Handled => {
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
+                    tree::Input::Quit => return Ok(None),
+                },
+                TerminalEvent::Mouse(mouse) if tree.handle_mouse(mouse.kind, 1) => {
+                    dirty = true;
+                    urgent = true;
+                    continue;
+                }
+                _ => {}
+            }
+        }
         let key_pressed = is_key_press(&terminal_event);
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
@@ -1767,6 +1792,13 @@ fn event_loop(
         let Some(action) = action else {
             continue;
         };
+        if action == Action::ToggleTree {
+            tree.toggle();
+            app.history_display_expanded = false;
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         let action = copy_selected_path_action(
             action,
             &app,
@@ -2675,12 +2707,28 @@ fn draw(
     line_diff_pool: &mut Option<LineDiffPool>,
     motion: &mut MotionState,
     focused: bool,
+    tree: &mut tree::Tree,
     filesystem_responses: &mut logging::FilesystemResponses,
 ) -> Result<()> {
     let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
         return Ok(());
     }
+    if tree.is_active() {
+        motion.cancel_pending();
+        terminal
+            .autoresize()
+            .context("could not resize the terminal before drawing")?;
+        {
+            let mut frame = terminal.get_frame();
+            tree.draw(&mut frame, history_graph.as_ref());
+        }
+        terminal
+            .apply_buffer_with_cursor(None)
+            .context("could not draw tree overview")?;
+        filesystem_responses.frame_presented();
+        return Ok(());
+    }
     app.unseen_filesystem_redraw = unseen_filesystem_redraw(
         app.unseen_filesystem_redraw,
         focused,
@@ -3831,32 +3879,36 @@ fn load_changes_without_lines(repository: &gix::Repository, target: app::TreeDif
         return Ok(changes);
     };
     let commit = repository.find_commit(id).context("could not load changed paths")?;
-    let parents: Vec<_> = commit.parent_ids().collect();
+    let marked_parent = {
+        let decoded = commit.decode().context("could not decode changed commit")?;
+        edit::rebase::marked_parent_ref(&decoded)?
+    };
+    let parents: Vec<_> = commit.parent_ids().map(gix::Id::detach).collect();
     let parent_index = requested_parent.checked_rem(parents.len()).unwrap_or_default();
-    let parent = parents.get(parent_index).copied();
+    let selected_parent = parents.get(parent_index).copied();
+    let (parent, compared_parent) = match marked_parent {
+        Some(parent) => (parent, None),
+        None => (
+            selected_parent,
+            (parents.len() > 1).then(|| ComparedParent {
+                index: parent_index,
+                total: parents.len(),
+                id: selected_parent.expect("a merge has parents"),
+            }),
+        ),
+    };
     let new_tree = commit.tree().context("could not load changed commit tree")?;
     let old_tree = match parent {
         Some(parent) => Some(
-            parent
-                .object()
+            repository
+                .find_commit(parent)
                 .context("could not load parent commit")?
-                .try_into_commit()
-                .context("parent is not a commit")?
                 .tree()
                 .context("could not load parent commit tree")?,
         ),
         None => None,
     };
-    load_tree_changes_without_lines(
-        repository,
-        old_tree.as_ref(),
-        &new_tree,
-        (parents.len() > 1).then(|| ComparedParent {
-            index: parent_index,
-            total: parents.len(),
-            id: parent.expect("a merge has parents").detach(),
-        }),
-    )
+    load_tree_changes_without_lines(repository, old_tree.as_ref(), &new_tree, compared_parent)
 }
 
 fn load_tree_changes_without_lines(
@@ -4420,6 +4472,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
+        KeyCode::Char('t') => Some(Action::ToggleTree),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
@@ -4784,6 +4837,71 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pending_rebase_changes_use_the_recorded_parent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let actual_parent = repository.rev_parse_single("main")?.detach();
+
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let mut marked = repository.find_commit(topic)?.decode()?.into_owned()?;
+        let original_parent = marked.parents[0];
+        marked.parents = [actual_parent].into_iter().collect();
+        marked
+            .extra_headers
+            .push(("tix-rebase-parent".into(), original_parent.to_hex().to_string().into()));
+        let marked_topic = repository.write_object(&marked)?.detach();
+        let changes = load_changes_without_lines(
+            &repository,
+            app::TreeDiffTarget::Commit {
+                id: marked_topic,
+                parent: 0,
+            },
+        )?;
+        assert_eq!(
+            changes
+                .paths
+                .iter()
+                .map(|change| change.path.as_bstr())
+                .collect::<Vec<_>>(),
+            ["topic", "topic-extra"],
+            "the recorded parent preserves the commit's original changes"
+        );
+        assert_eq!(
+            changes.parent, None,
+            "the actual parent isn't presented as the comparison base"
+        );
+
+        let root = repository.rev_parse_single("v1^{}")?.detach();
+        let mut marked_root = repository.find_commit(root)?.decode()?.into_owned()?;
+        marked_root.parents = [actual_parent].into_iter().collect();
+        marked_root.extra_headers.push((
+            "tix-rebase-parent".into(),
+            gix::ObjectId::null(repository.object_hash())
+                .to_hex()
+                .to_string()
+                .into(),
+        ));
+        let marked_root = repository.write_object(&marked_root)?.detach();
+        let changes = load_changes_without_lines(
+            &repository,
+            app::TreeDiffTarget::Commit {
+                id: marked_root,
+                parent: 0,
+            },
+        )?;
+        assert_eq!(
+            changes
+                .paths
+                .iter()
+                .map(|change| change.path.as_bstr())
+                .collect::<Vec<_>>(),
+            ["root"],
+            "a recorded null parent compares the pending root to the empty tree"
+        );
+        Ok(())
+    }
+
     #[test]
     fn loads_changes_against_each_merge_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
@@ -5350,7 +5468,10 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
             Some(Action::ToggleRefs)
         );
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)),
+            Some(Action::ToggleTree)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE)),
             Some(Action::TimeTravel),
@@ -5439,8 +5560,8 @@ mod tests {
         }
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE), false, true),
-            None,
-            "time travel is no longer part of the edit prefix"
+            Some(Action::ToggleTree),
+            "the direct tree key remains available while edit is expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE), false, true),
@@ -5494,6 +5615,21 @@ mod tests {
         assert_eq!(action(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE)), None);
     }
 
+    #[test]
+    fn tree_is_direct_while_trailers_remain_scoped_to_the_view_prefix() {
+        let key = KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE);
+        assert_eq!(
+            action_with_shortcut_groups(key, true, false),
+            Some(Action::ToggleTrailers),
+            "v t retains its trailer action"
+        );
+        assert_eq!(
+            action_with_shortcut_groups(key, false, false),
+            Some(Action::ToggleTree),
+            "plain t toggles the tree"
+        );
+    }
+
     #[test]
     fn retains_the_fill_repository_only_for_repeated_viewport_navigation() {
         assert!(retains_fill_repository(
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
new file mode 100644
index 00000000000..d30a84e9fad
--- /dev/null
+++ b/gix-tix/src/tree.rs
@@ -0,0 +1,1417 @@
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::OsString,
+    fmt::Write,
+    sync::atomic::AtomicBool,
+};
+
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEventKind};
+use gix::{ObjectId, bstr::ByteSlice};
+use ratatui::{
+    Frame,
+    layout::{Constraint, Layout, Rect},
+    style::{Color, Modifier, Style},
+    widgets::{Clear, Paragraph},
+};
+
+use crate::{
+    app::LaneState,
+    history::{CommitIndex, Decoration, DecorationKind, Decorations, HistoryGraph, RefSnapshot},
+    ui::decoration_style,
+};
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+enum Motion {
+    #[default]
+    Nearest,
+    Topological,
+}
+
+#[derive(Clone, Copy, Debug, Default)]
+struct Offset {
+    x: usize,
+    y: usize,
+    page_width: usize,
+    page_height: usize,
+    max_x: usize,
+    max_y: usize,
+}
+
+#[derive(Clone, Debug)]
+struct Node {
+    commit: CommitIndex,
+    id: ObjectId,
+    parent: Option<usize>,
+    children: Vec<usize>,
+    decorations: Vec<Decoration>,
+    is_head: bool,
+    is_anchor: bool,
+    raw_tip: bool,
+    sort_key: String,
+}
+
+#[derive(Clone, Debug)]
+struct Edge {
+    child: usize,
+    parent: usize,
+    hidden: Vec<CommitIndex>,
+}
+
+#[derive(Clone, Debug, Default)]
+struct Overview {
+    nodes: Vec<Node>,
+    edges: Vec<Edge>,
+    roots: Vec<usize>,
+    by_commit: HashMap<CommitIndex, usize>,
+    commit_count: usize,
+}
+
+#[derive(Clone, Debug)]
+struct Overlay {
+    selected: CommitIndex,
+    reachable: Vec<bool>,
+    first_parent: Vec<bool>,
+    counts: Vec<Option<usize>>,
+    boundaries: Vec<Option<ObjectId>>,
+    seen: Vec<u32>,
+    stamp: u32,
+}
+
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+struct Point {
+    x: usize,
+    y: usize,
+}
+
+#[derive(Default)]
+struct Placed {
+    nodes: Vec<Point>,
+    boundaries: Vec<Option<Point>>,
+    rail_rows: Vec<RailRow>,
+    rail_width: usize,
+    width: usize,
+    height: usize,
+}
+
+struct RailRow {
+    lane: String,
+    kind: RailRowKind,
+    edge: Option<usize>,
+}
+
+#[derive(Clone, Copy)]
+enum RailRowKind {
+    Node(usize),
+    Boundary(usize),
+    NodeConnector,
+    BoundaryConnector,
+}
+
+#[derive(Clone, Copy)]
+enum Direction {
+    Up,
+    Down,
+    Left,
+    Right,
+}
+
+pub(crate) enum Input {
+    Handled,
+    Quit,
+}
+
+#[derive(Default)]
+pub(crate) struct Tree {
+    active: bool,
+    motion: Motion,
+    overview: Option<Overview>,
+    alternate_overview: Option<Overview>,
+    overlay: Option<Overlay>,
+    selected: Option<usize>,
+    choices: Vec<usize>,
+    offset: Offset,
+    placed: Option<Placed>,
+    ensure_visible: bool,
+    hide_tags: bool,
+}
+
+impl Tree {
+    pub(crate) fn is_active(&self) -> bool {
+        self.active
+    }
+
+    pub(crate) fn toggle(&mut self) -> bool {
+        if !self.active && self.overview.as_ref().is_none_or(|overview| overview.nodes.is_empty()) {
+            return false;
+        }
+        self.active = !self.active;
+        self.ensure_visible = true;
+        true
+    }
+
+    pub(crate) fn leave(&mut self) {
+        self.active = false;
+    }
+
+    pub(crate) fn rebuild(&mut self, graph: &HistoryGraph, refs: &RefSnapshot, decorations: &Decorations) {
+        let selected = self
+            .selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            .map(|node| node.id);
+        let with_tags = Overview::new(graph, refs, decorations, true);
+        let without_tags = Overview::new(graph, refs, decorations, false);
+        let (overview, alternate_overview) = if self.hide_tags {
+            (without_tags, with_tags)
+        } else {
+            (with_tags, without_tags)
+        };
+        let head = overview
+            .nodes
+            .iter()
+            .position(|node| node.is_head)
+            .or_else(|| {
+                selected.and_then(|id| {
+                    graph
+                        .index(id)
+                        .and_then(|index| overview.by_commit.get(&index).copied())
+                })
+            })
+            .or_else(|| {
+                refs.view_tips.iter().chain(&refs.hidden_tips).find_map(|id| {
+                    graph
+                        .index(*id)
+                        .and_then(|index| overview.by_commit.get(&index).copied())
+                })
+            })
+            .or((!overview.nodes.is_empty()).then_some(0));
+        self.selected = selected
+            .and_then(|id| {
+                graph
+                    .index(id)
+                    .and_then(|index| overview.by_commit.get(&index).copied())
+            })
+            .or(head);
+        self.choices = vec![0; overview.nodes.len()];
+        self.overview = Some(overview);
+        self.alternate_overview = Some(alternate_overview);
+        self.overlay = None;
+        self.placed = None;
+        self.ensure_visible = true;
+    }
+
+    pub(crate) fn handle_key(&mut self, key: KeyEvent) -> Input {
+        if key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL)
+            || key.code == KeyCode::Char('q')
+        {
+            return Input::Quit;
+        }
+        if key.code == KeyCode::Esc {
+            self.leave();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Char('G')
+            || key.code == KeyCode::Char('g') && key.modifiers.contains(KeyModifiers::SHIFT)
+        {
+            self.jump_to_root();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Char('g') && key.modifiers.is_empty() {
+            self.jump_to_top();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Char('t') && key.modifiers.is_empty() {
+            self.leave();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Char('T')
+            || key.code == KeyCode::Char('t') && key.modifiers.contains(KeyModifiers::SHIFT)
+        {
+            self.toggle_tags();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Tab {
+            self.motion = match self.motion {
+                Motion::Nearest => Motion::Topological,
+                Motion::Topological => Motion::Nearest,
+            };
+            return Input::Handled;
+        }
+        if key.modifiers.contains(KeyModifiers::CONTROL) {
+            let amount = self.offset().page_height.max(1);
+            match key.code {
+                KeyCode::Char('u') => self.pan(Direction::Up, (amount / 2).max(1)),
+                KeyCode::Char('d') => self.pan(Direction::Down, (amount / 2).max(1)),
+                KeyCode::Char('b') => self.pan(Direction::Up, amount),
+                KeyCode::Char('f') => self.pan(Direction::Down, amount),
+                _ => return Input::Handled,
+            }
+            return Input::Handled;
+        }
+        match key.code {
+            KeyCode::PageUp => {
+                self.pan(Direction::Up, self.offset().page_height.max(1));
+                return Input::Handled;
+            }
+            KeyCode::PageDown => {
+                self.pan(Direction::Down, self.offset().page_height.max(1));
+                return Input::Handled;
+            }
+            _ => {}
+        }
+        let Some(direction) = direction(key.code) else {
+            return Input::Handled;
+        };
+        if key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('H' | 'J' | 'K' | 'L')) {
+            self.pan(direction, 1);
+        } else {
+            self.navigate(direction);
+        }
+        Input::Handled
+    }
+
+    pub(crate) fn handle_mouse(&mut self, kind: MouseEventKind, distance: usize) -> bool {
+        let direction = match kind {
+            MouseEventKind::ScrollUp => Direction::Up,
+            MouseEventKind::ScrollDown => Direction::Down,
+            MouseEventKind::ScrollLeft => Direction::Left,
+            MouseEventKind::ScrollRight => Direction::Right,
+            _ => return false,
+        };
+        self.pan(direction, distance.max(1));
+        true
+    }
+
+    pub(crate) fn draw(&mut self, frame: &mut Frame<'_>, graph: Option<&HistoryGraph>) {
+        if self.overlay.as_ref().map(|overlay| overlay.selected)
+            != self
+                .selected
+                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+                .map(|node| node.commit)
+            && let (Some(graph), Some(selected)) = (graph, self.selected)
+        {
+            self.overlay = self
+                .overview
+                .as_ref()
+                .map(|overview| Overlay::new(graph, overview, selected));
+        }
+        let [body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
+        frame.render_widget(Clear, frame.area());
+        let Some(overview) = self.overview.as_ref() else {
+            frame.render_widget(Paragraph::new("tree overview unavailable"), body);
+            return;
+        };
+        if self.placed.is_none() {
+            self.placed = Some(place_rail(overview, self.overlay.as_ref()));
+        }
+        let placed = self.placed.as_ref().expect("rail placement was just populated");
+        let selected = self.selected;
+        let ensure_visible = self.ensure_visible;
+        let selected_point = selected.and_then(|selected| placed.nodes.get(selected)).copied();
+        let offset = {
+            let offset = &mut self.offset;
+            offset.page_width = usize::from(body.width);
+            offset.page_height = usize::from(body.height);
+            offset.max_x = placed.width.saturating_sub(offset.page_width);
+            offset.max_y = placed.height.saturating_sub(offset.page_height);
+            offset.x = offset.x.min(offset.max_x);
+            offset.y = offset.y.min(offset.max_y);
+            if ensure_visible && let Some(point) = selected_point {
+                ensure_point_visible(offset, point);
+            }
+            *offset
+        };
+        self.ensure_visible = false;
+        let overview = self.overview.as_ref().expect("the overview was checked");
+        if let (Some(graph), Some(overlay)) = (graph, self.overlay.as_mut()) {
+            overlay.compute_visible_counts(
+                graph,
+                overview,
+                placed,
+                offset.y..offset.y.saturating_add(usize::from(body.height)),
+            );
+        }
+        draw_rail_edges(
+            frame,
+            body,
+            overview,
+            self.overlay.as_ref(),
+            placed,
+            offset,
+            selected,
+            &self.choices,
+        );
+        draw_nodes(
+            frame,
+            body,
+            overview,
+            self.overlay.as_ref(),
+            placed,
+            offset,
+            selected,
+            self.motion,
+            &self.choices,
+        );
+        let motion = match self.motion {
+            Motion::Nearest => "nearest",
+            Motion::Topological => "topo ↑ leaves · ↓ roots · ←/→ branch",
+        };
+        let tags = if self.hide_tags { "off" } else { "on" };
+        frame.render_widget(
+            Paragraph::new(format!(
+                "tree · {motion} · g top · G root · T tags:{tags} · Shift+directions pan · t/Esc history"
+            ))
+            .style(Style::default().add_modifier(Modifier::DIM)),
+            footer,
+        );
+    }
+
+    fn navigate(&mut self, direction: Direction) {
+        let Some(overview) = self.overview.as_ref() else { return };
+        let Some(selected) = self.selected else { return };
+        let next = if self.motion == Motion::Topological {
+            match direction {
+                Direction::Up => overview.nodes[selected]
+                    .children
+                    .get(self.choices[selected].min(overview.nodes[selected].children.len().saturating_sub(1)))
+                    .copied(),
+                Direction::Down => overview.nodes[selected].parent,
+                Direction::Left => {
+                    self.choices[selected] = self.choices[selected].saturating_sub(1);
+                    None
+                }
+                Direction::Right => {
+                    self.choices[selected] = self.choices[selected]
+                        .saturating_add(1)
+                        .min(overview.nodes[selected].children.len().saturating_sub(1));
+                    None
+                }
+            }
+        } else {
+            self.placed
+                .as_ref()
+                .and_then(|placed| nearest(&placed.nodes, selected, direction))
+        };
+        if let Some(next) = next {
+            self.selected = Some(next);
+            self.overlay = None;
+            self.placed = None;
+            self.ensure_visible = true;
+        }
+    }
+
+    fn jump_to_root(&mut self) {
+        let (Some(overview), Some(mut selected)) = (self.overview.as_ref(), self.selected) else {
+            return;
+        };
+        while let Some(parent) = overview.nodes[selected].parent {
+            selected = parent;
+        }
+        self.selected = Some(selected);
+        self.overlay = None;
+        self.placed = None;
+        self.ensure_visible = true;
+    }
+
+    fn jump_to_top(&mut self) {
+        let Some(overview) = self.overview.as_ref() else {
+            return;
+        };
+        let Some(mut selected) = overview.roots.first().copied() else {
+            return;
+        };
+        while let Some(child) = overview.nodes[selected].children.first().copied() {
+            selected = child;
+        }
+        self.selected = Some(selected);
+        self.overlay = None;
+        self.placed = None;
+        self.ensure_visible = true;
+    }
+
+    fn toggle_tags(&mut self) {
+        let selected = self
+            .selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            .map(|node| node.id);
+        let Some(alternate) = self.alternate_overview.as_mut() else {
+            return;
+        };
+        let overview = self.overview.get_or_insert_with(Overview::default);
+        std::mem::swap(overview, alternate);
+        self.selected = selected
+            .and_then(|id| overview.nodes.iter().position(|node| node.id == id))
+            .or_else(|| overview.nodes.iter().position(|node| node.is_head))
+            .or_else(|| overview.nodes.iter().position(|node| node.raw_tip))
+            .or((!overview.nodes.is_empty()).then_some(0));
+        self.hide_tags = !self.hide_tags;
+        self.choices = vec![0; overview.nodes.len()];
+        self.overlay = None;
+        self.placed = None;
+        self.ensure_visible = true;
+    }
+
+    fn pan(&mut self, direction: Direction, amount: usize) {
+        let offset = &mut self.offset;
+        match direction {
+            Direction::Up => offset.y = offset.y.saturating_sub(amount),
+            Direction::Down => offset.y = offset.y.saturating_add(amount).min(offset.max_y),
+            Direction::Left => offset.x = offset.x.saturating_sub(amount),
+            Direction::Right => offset.x = offset.x.saturating_add(amount).min(offset.max_x),
+        }
+        self.ensure_visible = false;
+    }
+
+    fn offset(&self) -> &Offset {
+        &self.offset
+    }
+}
+
+impl Overview {
+    fn new(graph: &HistoryGraph, refs: &RefSnapshot, decorations: &Decorations, show_tags: bool) -> Self {
+        let mut labels = HashMap::<CommitIndex, Vec<Decoration>>::new();
+        let mut heads = HashSet::new();
+        let mut anchors = HashSet::new();
+        for (id, decorations) in decorations {
+            let Some(index) = graph.index(*id) else { continue };
+            for decoration in decorations {
+                if !show_tags && matches!(decoration.kind, DecorationKind::Tag | DecorationKind::AnnotatedTag) {
+                    continue;
+                }
+                if decoration.kind == DecorationKind::Head {
+                    heads.insert(index);
+                    anchors.insert(index);
+                } else if decoration.kind != DecorationKind::Special {
+                    labels.entry(index).or_default().push(decoration.clone());
+                    anchors.insert(index);
+                }
+            }
+        }
+        let raw: HashSet<_> = refs
+            .view_tips
+            .iter()
+            .chain(&refs.hidden_tips)
+            .filter_map(|id| graph.index(*id))
+            .inspect(|index| {
+                anchors.insert(*index);
+            })
+            .collect();
+        if anchors.is_empty() {
+            return Overview::default();
+        }
+        for decorations in labels.values_mut() {
+            decorations.sort_by(|a, b| a.name.cmp(&b.name));
+            decorations.dedup();
+        }
+        let mut included = HashSet::new();
+        for anchor in anchors.iter().copied() {
+            let mut current = Some(anchor);
+            while let Some(index) = current {
+                if !included.insert(index) {
+                    break;
+                }
+                current = graph.parents(index).first().copied();
+            }
+        }
+        let mut children = vec![Vec::new(); graph.commit_count()];
+        for child in included.iter().copied() {
+            if let Some(parent) = graph
+                .parents(child)
+                .first()
+                .copied()
+                .filter(|parent| included.contains(parent))
+            {
+                children[parent.as_usize()].push(child);
+            }
+        }
+        let structural: HashSet<_> = included
+            .iter()
+            .copied()
+            .filter(|index| {
+                anchors.contains(index)
+                    || children[index.as_usize()].len() != 1
+                    || graph
+                        .parents(*index)
+                        .first()
+                        .is_none_or(|parent| !included.contains(parent))
+            })
+            .collect();
+        let mut structural_order: Vec<_> = structural.iter().copied().collect();
+        structural_order.sort_by_key(|index| index.as_usize());
+        let by_commit: HashMap<_, _> = structural_order
+            .iter()
+            .enumerate()
+            .map(|(node, commit)| (*commit, node))
+            .collect();
+        let mut nodes: Vec<_> = structural_order
+            .iter()
+            .copied()
+            .map(|commit| {
+                let decorations = labels.remove(&commit).unwrap_or_default();
+                let sort_key = decorations.first().map_or_else(
+                    || graph.id(commit).to_hex().to_string(),
+                    |decoration| decoration.name.to_str_lossy().into_owned(),
+                );
+                Node {
+                    commit,
+                    id: graph.id(commit),
+                    parent: None,
+                    children: Vec::new(),
+                    decorations,
+                    is_head: heads.contains(&commit),
+                    is_anchor: anchors.contains(&commit),
+                    raw_tip: raw.contains(&commit),
+                    sort_key,
+                }
+            })
+            .collect();
+        let mut edges = Vec::new();
+        let mut roots = Vec::new();
+        for child in 0..nodes.len() {
+            let mut hidden = Vec::new();
+            let mut parent = graph.parents(nodes[child].commit).first().copied();
+            while let Some(index) = parent.filter(|index| included.contains(index)) {
+                if let Some(parent_node) = by_commit.get(&index).copied() {
+                    nodes[child].parent = Some(parent_node);
+                    nodes[parent_node].children.push(child);
+                    edges.push(Edge {
+                        child,
+                        parent: parent_node,
+                        hidden,
+                    });
+                    break;
+                }
+                hidden.push(index);
+                parent = graph.parents(index).first().copied();
+            }
+            if nodes[child].parent.is_none() {
+                roots.push(child);
+            }
+        }
+        fn subtree_key(node: usize, nodes: &mut [Node]) -> String {
+            let children = nodes[node].children.clone();
+            let mut key = nodes[node].sort_key.clone();
+            for child in children {
+                key = key.min(subtree_key(child, nodes));
+            }
+            nodes[node].sort_key.clone_from(&key);
+            key
+        }
+        for root in roots.iter().copied() {
+            subtree_key(root, &mut nodes);
+        }
+        for node in 0..nodes.len() {
+            let keys: Vec<_> = nodes[node]
+                .children
+                .iter()
+                .map(|child| (*child, nodes[*child].sort_key.clone(), graph.id(nodes[*child].commit)))
+                .collect();
+            let mut keys = keys;
+            keys.sort_by(|a, b| a.1.cmp(&b.1).then(a.2.cmp(&b.2)));
+            nodes[node].children = keys.into_iter().map(|(child, _, _)| child).collect();
+        }
+        fn contains_head(node: usize, nodes: &[Node]) -> bool {
+            nodes[node].is_head || nodes[node].children.iter().any(|child| contains_head(*child, nodes))
+        }
+        roots.sort_by(|a, b| {
+            (!contains_head(*a, &nodes))
+                .cmp(&(!contains_head(*b, &nodes)))
+                .then(nodes[*a].sort_key.cmp(&nodes[*b].sort_key))
+        });
+        Overview {
+            nodes,
+            edges,
+            roots,
+            by_commit,
+            commit_count: graph.commit_count(),
+        }
+    }
+}
+
+impl Overlay {
+    fn new(graph: &HistoryGraph, overview: &Overview, selected: usize) -> Self {
+        let selected_commit = overview.nodes[selected].commit;
+        let mut reachable = vec![false; graph.commit_count()];
+        let mut pending = vec![selected_commit];
+        let mut total = 0;
+        while let Some(index) = pending.pop() {
+            if std::mem::replace(&mut reachable[index.as_usize()], true) {
+                continue;
+            }
+            total += 1;
+            pending.extend_from_slice(graph.parents(index));
+        }
+        let mut first_parent = vec![false; graph.commit_count()];
+        let mut current = Some(selected_commit);
+        while let Some(index) = current {
+            first_parent[index.as_usize()] = true;
+            current = graph.parents(index).first().copied();
+        }
+        let mut counts = vec![None; overview.nodes.len()];
+        counts[selected] = Some(total);
+        let boundaries = overview
+            .edges
+            .iter()
+            .map(|edge| {
+                (!reachable[overview.nodes[edge.child].commit.as_usize()]).then(|| {
+                    edge.hidden
+                        .iter()
+                        .copied()
+                        .find(|index| reachable[index.as_usize()])
+                        .map(|index| graph.id(index))
+                })?
+            })
+            .collect();
+        Overlay {
+            selected: selected_commit,
+            reachable,
+            first_parent,
+            counts,
+            boundaries,
+            seen: vec![0; graph.commit_count()],
+            stamp: 0,
+        }
+    }
+
+    fn compute_visible_counts(
+        &mut self,
+        graph: &HistoryGraph,
+        overview: &Overview,
+        placed: &Placed,
+        rows: std::ops::Range<usize>,
+    ) {
+        for (node, value) in overview.nodes.iter().enumerate() {
+            if !value.is_anchor || self.counts[node].is_some() || !rows.contains(&placed.nodes[node].y) {
+                continue;
+            }
+            self.stamp = self.stamp.wrapping_add(1);
+            if self.stamp == 0 {
+                self.seen.fill(0);
+                self.stamp = 1;
+            }
+            let mut count = 0;
+            let mut pending = vec![value.commit];
+            while let Some(index) = pending.pop() {
+                if self.reachable[index.as_usize()]
+                    || std::mem::replace(&mut self.seen[index.as_usize()], self.stamp) == self.stamp
+                {
+                    continue;
+                }
+                count += 1;
+                pending.extend_from_slice(graph.parents(index));
+            }
+            self.counts[node] = Some(count);
+        }
+    }
+}
+
+fn place_rail(overview: &Overview, overlay: Option<&Overlay>) -> Placed {
+    struct Item {
+        id: ObjectId,
+        parent: Option<ObjectId>,
+        kind: RailRowKind,
+        marker: char,
+    }
+
+    let mut edge_by_child = vec![None; overview.nodes.len()];
+    for (edge, value) in overview.edges.iter().enumerate() {
+        edge_by_child[value.child] = Some(edge);
+    }
+    fn collect(
+        node: usize,
+        parent: Option<ObjectId>,
+        overview: &Overview,
+        overlay: Option<&Overlay>,
+        edge_by_child: &[Option<usize>],
+        out: &mut Vec<Item>,
+    ) {
+        for child in overview.nodes[node].children.iter().copied() {
+            let edge = edge_by_child[child].expect("non-root nodes have an edge");
+            let boundary = overlay.and_then(|overlay| overlay.boundaries[edge]);
+            collect(
+                child,
+                Some(boundary.unwrap_or(overview.nodes[node].id)),
+                overview,
+                overlay,
+                edge_by_child,
+                out,
+            );
+            if let Some(id) = boundary {
+                out.push(Item {
+                    id,
+                    parent: Some(overview.nodes[node].id),
+                    kind: RailRowKind::Boundary(edge),
+                    marker: '●',
+                });
+            }
+        }
+        out.push(Item {
+            id: overview.nodes[node].id,
+            parent,
+            kind: RailRowKind::Node(node),
+            marker: if overview.nodes[node].is_head { '@' } else { '●' },
+        });
+    }
+
+    let mut items = Vec::new();
+    for root in overview.roots.iter().copied() {
+        collect(root, None, overview, overlay, &edge_by_child, &mut items);
+    }
+    let mut state = LaneState::default();
+    let mut placed = Placed {
+        nodes: vec![Point::default(); overview.nodes.len()],
+        boundaries: vec![None; overview.edges.len()],
+        ..Placed::default()
+    };
+    for item in items {
+        let node_lane = state.node_line(item.id, item.marker);
+        let mut transition = String::new();
+        state.advance_ids(item.id, item.parent, Some(&mut transition), item.marker);
+        transition = transition
+            .chars()
+            .map(|symbol| match symbol {
+                '┌' => '╭',
+                '┐' => '╮',
+                '└' => '╰',
+                '┘' => '╯',
+                _ => symbol,
+            })
+            .collect();
+        let rounded_transition = transition.contains('─');
+        let lane = if rounded_transition {
+            node_lane
+        } else {
+            std::mem::take(&mut transition)
+        };
+        let x = lane
+            .chars()
+            .position(|symbol| symbol == item.marker)
+            .expect("a rendered lane contains its node marker");
+        let y = placed.rail_rows.len();
+        match item.kind {
+            RailRowKind::Node(node) => placed.nodes[node] = Point { x, y },
+            RailRowKind::Boundary(edge) => placed.boundaries[edge] = Some(Point { x, y }),
+            RailRowKind::NodeConnector | RailRowKind::BoundaryConnector => {
+                unreachable!("items are always node rows")
+            }
+        }
+        placed.rail_width = placed.rail_width.max(lane.chars().count());
+        let edge = match item.kind {
+            RailRowKind::Node(node) => edge_by_child[node],
+            RailRowKind::Boundary(edge) => Some(edge),
+            RailRowKind::NodeConnector | RailRowKind::BoundaryConnector => unreachable!("items are node rows"),
+        };
+        placed.rail_rows.push(RailRow {
+            lane,
+            kind: item.kind,
+            edge,
+        });
+        if rounded_transition {
+            let mut connector: Vec<_> = transition.chars().collect();
+            connector[x] = if x > 0 && connector[x - 1] == '─' {
+                '╯'
+            } else if connector.get(x + 1) == Some(&'─') {
+                '╰'
+            } else {
+                '│'
+            };
+            let kind = match item.kind {
+                RailRowKind::Node(_) => RailRowKind::NodeConnector,
+                RailRowKind::Boundary(_) => RailRowKind::BoundaryConnector,
+                RailRowKind::NodeConnector | RailRowKind::BoundaryConnector => unreachable!("items are node rows"),
+            };
+            let lane: String = connector.into_iter().collect();
+            placed.rail_width = placed.rail_width.max(lane.chars().count());
+            placed.rail_rows.push(RailRow { lane, kind, edge });
+        }
+    }
+    placed.height = placed.rail_rows.len();
+    let label_width = overview
+        .nodes
+        .iter()
+        .map(|node| rail_label(node, Some(overview.commit_count)).chars().count())
+        .max()
+        .unwrap_or_default();
+    placed.width = placed.rail_width.saturating_add(label_width).max(1);
+    placed
+}
+
+#[expect(
+    clippy::too_many_arguments,
+    reason = "drawing receives detached layout and style state"
+)]
+fn draw_rail_edges(
+    frame: &mut Frame<'_>,
+    area: Rect,
+    overview: &Overview,
+    overlay: Option<&Overlay>,
+    placed: &Placed,
+    offset: Offset,
+    selected: Option<usize>,
+    choices: &[usize],
+) {
+    for (y, row) in placed.rail_rows.iter().enumerate() {
+        if y < offset.y || y >= offset.y.saturating_add(usize::from(area.height)) {
+            continue;
+        }
+        let style = match row.kind {
+            RailRowKind::Boundary(_) | RailRowKind::BoundaryConnector => Style::default().add_modifier(Modifier::DIM),
+            RailRowKind::Node(_) | RailRowKind::NodeConnector => row
+                .edge
+                .map(|edge| &overview.edges[edge])
+                .map_or_else(Style::default, |edge| {
+                    let chosen = selected == Some(edge.parent)
+                        && overview.nodes[edge.parent].children.get(
+                            choices[edge.parent].min(overview.nodes[edge.parent].children.len().saturating_sub(1)),
+                        ) == Some(&edge.child);
+                    if chosen {
+                        Style::default().fg(Color::Yellow).add_modifier(Modifier::BOLD)
+                    } else {
+                        edge_style(overview, overlay, edge)
+                    }
+                }),
+        };
+        draw_text(frame, area, offset, Point { x: 0, y }, &row.lane, style);
+    }
+}
+
+#[expect(
+    clippy::too_many_arguments,
+    reason = "drawing receives detached layout and style state"
+)]
+fn draw_nodes(
+    frame: &mut Frame<'_>,
+    area: Rect,
+    overview: &Overview,
+    overlay: Option<&Overlay>,
+    placed: &Placed,
+    offset: Offset,
+    selected: Option<usize>,
+    motion: Motion,
+    choices: &[usize],
+) {
+    for (index, node) in overview.nodes.iter().enumerate() {
+        let point = placed.nodes[index];
+        if point.y < offset.y
+            || point.y >= offset.y.saturating_add(usize::from(area.height))
+            || point.x >= offset.x.saturating_add(usize::from(area.width))
+        {
+            continue;
+        }
+        let count = overlay.and_then(|overlay| overlay.counts[index]);
+        let mut text = rail_label(node, count);
+        if selected == Some(index) && motion == Motion::Topological && node.children.len() > 1 {
+            write!(
+                text,
+                " {}/{}",
+                choices[index].min(node.children.len() - 1) + 1,
+                node.children.len()
+            )
+            .expect("writing to a string cannot fail");
+        }
+        let mut style = node.decorations.first().map_or_else(
+            || Style::default().fg(Color::LightBlue),
+            |decoration| decoration_style(decoration.kind),
+        );
+        if selected == Some(index) {
+            style = style.add_modifier(Modifier::REVERSED | Modifier::BOLD);
+        } else if let Some(overlay) = overlay {
+            let commit = node.commit.as_usize();
+            if overlay.first_parent[commit] {
+                style = style.add_modifier(Modifier::BOLD);
+            } else if overlay.reachable[commit] {
+                style = style.add_modifier(Modifier::DIM);
+            }
+        }
+        put(frame, area, offset, point, if node.is_head { '@' } else { '●' }, style);
+        draw_text(
+            frame,
+            area,
+            offset,
+            Point {
+                x: placed.rail_width,
+                y: point.y,
+            },
+            &text,
+            style,
+        );
+    }
+}
+
+fn rail_label(node: &Node, count: Option<usize>) -> String {
+    let mut out = count.map_or_else(String::new, |count| count.to_string());
+    let labels: Vec<_> = node
+        .decorations
+        .iter()
+        .map(|decoration| decoration.name.to_str_lossy())
+        .collect();
+    let suffix = if !labels.is_empty() {
+        labels.join(", ")
+    } else if node.raw_tip {
+        node.id.to_hex_with_len(7).to_string()
+    } else if node.parent.is_none() {
+        "<root>".into()
+    } else {
+        String::new()
+    };
+    if !out.is_empty() && !suffix.is_empty() {
+        out.push(' ');
+    }
+    out.push_str(&suffix);
+    out
+}
+
+fn edge_style(overview: &Overview, overlay: Option<&Overlay>, edge: &Edge) -> Style {
+    let Some(overlay) = overlay else {
+        return Style::default();
+    };
+    let child = overview.nodes[edge.child].commit.as_usize();
+    let parent = overview.nodes[edge.parent].commit.as_usize();
+    if overlay.first_parent[child] && overlay.first_parent[parent] {
+        Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD)
+    } else if overlay.reachable[child] {
+        Style::default().add_modifier(Modifier::DIM)
+    } else {
+        Style::default()
+    }
+}
+
+pub(crate) fn render_full(
+    repository: &gix::Repository,
+    revisions: &[OsString],
+    hidden: &[OsString],
+    worktrees: bool,
+    show_tags: bool,
+    unicode: bool,
+) -> anyhow::Result<String> {
+    let refs = crate::history::snapshot(repository, revisions, hidden, worktrees)?;
+    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+        crate::history::Authors::default(),
+    ));
+    let mut graph = None;
+    let mut decorations = None;
+    crate::history::load(
+        repository,
+        revisions,
+        hidden,
+        worktrees,
+        &authors,
+        &AtomicBool::new(false),
+        |event| {
+            match event {
+                crate::history::Event::Decorations(value) => decorations = Some(value),
+                crate::history::Event::Complete(value) => graph = Some(value),
+                _ => {}
+            }
+            true
+        },
+    )?;
+    let graph = graph.ok_or_else(|| anyhow::anyhow!("history traversal did not produce a graph"))?;
+    let decorations = decorations.unwrap_or_default();
+    Ok(render_overview(
+        &Overview::new(&graph, &refs, &decorations, show_tags),
+        unicode,
+    ))
+}
+
+fn render_overview(overview: &Overview, unicode: bool) -> String {
+    if overview.nodes.is_empty() {
+        return String::new();
+    }
+    let placed = place_rail(overview, None);
+    let mut out = String::new();
+    for row in &placed.rail_rows {
+        let node = match row.kind {
+            RailRowKind::Node(node) => Some(node),
+            RailRowKind::NodeConnector => None,
+            RailRowKind::Boundary(_) | RailRowKind::BoundaryConnector => continue,
+        };
+        let lane = if unicode {
+            row.lane.clone()
+        } else {
+            row.lane
+                .chars()
+                .map(|symbol| match symbol {
+                    '●' => 'o',
+                    '│' => '|',
+                    '─' => '-',
+                    ' ' | '@' => symbol,
+                    _ => '+',
+                })
+                .collect()
+        };
+        let width = lane.chars().count();
+        out.push_str(&lane);
+        out.extend(std::iter::repeat_n(' ', placed.rail_width.saturating_sub(width)));
+        if let Some(node) = node {
+            out.push_str(&rail_label(&overview.nodes[node], None));
+        }
+        while out.ends_with(' ') {
+            out.pop();
+        }
+        out.push('\n');
+    }
+    out
+}
+
+fn draw_text(frame: &mut Frame<'_>, area: Rect, offset: Offset, point: Point, text: &str, style: Style) {
+    for (index, symbol) in text.chars().enumerate() {
+        put(
+            frame,
+            area,
+            offset,
+            Point {
+                x: point.x + index,
+                y: point.y,
+            },
+            symbol,
+            style,
+        );
+    }
+}
+
+fn put(frame: &mut Frame<'_>, area: Rect, offset: Offset, point: Point, symbol: char, style: Style) {
+    let Some(x) = point.x.checked_sub(offset.x) else { return };
+    let Some(y) = point.y.checked_sub(offset.y) else { return };
+    if x >= usize::from(area.width) || y >= usize::from(area.height) {
+        return;
+    }
+    frame.buffer_mut()[(area.x + x as u16, area.y + y as u16)]
+        .set_char(symbol)
+        .set_style(style);
+}
+
+fn ensure_point_visible(offset: &mut Offset, point: Point) {
+    if point.x < offset.x {
+        offset.x = point.x;
+    } else if point.x >= offset.x.saturating_add(offset.page_width) {
+        offset.x = point.x.saturating_sub(offset.page_width.saturating_sub(1));
+    }
+    if point.y < offset.y {
+        offset.y = point.y;
+    } else if point.y >= offset.y.saturating_add(offset.page_height) {
+        offset.y = point.y.saturating_sub(offset.page_height.saturating_sub(1));
+    }
+    offset.x = offset.x.min(offset.max_x);
+    offset.y = offset.y.min(offset.max_y);
+}
+
+fn nearest(points: &[Point], selected: usize, direction: Direction) -> Option<usize> {
+    let source = *points.get(selected)?;
+    points
+        .iter()
+        .copied()
+        .enumerate()
+        .filter(|(index, point)| {
+            *index != selected
+                && match direction {
+                    Direction::Up => point.y < source.y,
+                    Direction::Down => point.y > source.y,
+                    Direction::Left => point.x < source.x,
+                    Direction::Right => point.x > source.x,
+                }
+        })
+        .min_by_key(|(index, point)| {
+            let dx = point.x.abs_diff(source.x);
+            let dy = point.y.abs_diff(source.y);
+            let perpendicular = match direction {
+                Direction::Up | Direction::Down => dx,
+                Direction::Left | Direction::Right => dy,
+            };
+            (dx * dx + dy * dy, perpendicular, *index)
+        })
+        .map(|(index, _)| index)
+}
+
+fn direction(code: KeyCode) -> Option<Direction> {
+    match code {
+        KeyCode::Up | KeyCode::Char('k' | 'K') => Some(Direction::Up),
+        KeyCode::Down | KeyCode::Char('j' | 'J') => Some(Direction::Down),
+        KeyCode::Left | KeyCode::Char('h' | 'H') => Some(Direction::Left),
+        KeyCode::Right | KeyCode::Char('l' | 'L') => Some(Direction::Right),
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use ratatui::{Terminal, backend::TestBackend};
+
+    use super::*;
+
+    fn id(n: u8) -> ObjectId {
+        let mut bytes = [0; 20];
+        bytes[19] = n;
+        ObjectId::Sha1(bytes)
+    }
+
+    fn fixture() -> (HistoryGraph, RefSnapshot, Decorations) {
+        let graph = HistoryGraph::from_test_commits(&[
+            (id(1), vec![]),
+            (id(2), vec![id(1)]),
+            (id(3), vec![id(2)]),
+            (id(4), vec![id(2)]),
+            (id(5), vec![id(4)]),
+            (id(6), vec![id(3), id(4)]),
+        ]);
+        let refs = RefSnapshot {
+            view: HashMap::new(),
+            hidden: HashMap::new(),
+            view_tips: vec![id(6), id(5)],
+            hidden_tips: Vec::new(),
+            pins: Vec::new(),
+            worktrees: Vec::new(),
+        };
+        let decorations = Decorations::from([
+            (
+                id(6),
+                vec![
+                    Decoration {
+                        name: "main".into(),
+                        kind: DecorationKind::Local,
+                    },
+                    Decoration {
+                        name: "HEAD".into(),
+                        kind: DecorationKind::Head,
+                    },
+                ],
+            ),
+            (
+                id(5),
+                vec![Decoration {
+                    name: "topic".into(),
+                    kind: DecorationKind::Local,
+                }],
+            ),
+        ]);
+        (graph, refs, decorations)
+    }
+
+    #[test]
+    fn first_parent_shape_uses_all_parent_reachability_for_counts_and_boundaries() {
+        let (graph, refs, decorations) = fixture();
+        let overview = Overview::new(&graph, &refs, &decorations, true);
+        let main = overview.by_commit[&graph.index(id(6)).expect("main exists")];
+        let topic = overview.by_commit[&graph.index(id(5)).expect("topic exists")];
+        let fork = overview.by_commit[&graph.index(id(2)).expect("fork exists")];
+        let mut overlay = Overlay::new(&graph, &overview, main);
+
+        assert_eq!(overview.nodes.len(), 4, "only refs, the fork, and root remain");
+        assert_eq!(overview.nodes[main].parent, Some(fork));
+        assert_eq!(overview.nodes[topic].parent, Some(fork));
+        assert_eq!(overlay.counts[main], Some(5), "selected count follows every parent");
+        assert_eq!(overlay.counts[topic], None, "off-screen reference counts start lazy");
+        let topic_edge = overview
+            .edges
+            .iter()
+            .position(|edge| edge.child == topic)
+            .expect("topic has a contracted edge");
+        assert_eq!(
+            overlay.boundaries[topic_edge],
+            Some(id(4)),
+            "the hidden merged topic commit becomes the visual reachability boundary"
+        );
+        let rail = place_rail(&overview, Some(&overlay));
+        let boundary = rail.boundaries[topic_edge].expect("rail inserts the boundary row");
+        assert!(
+            matches!(rail.rail_rows[boundary.y].kind, RailRowKind::Boundary(edge) if edge == topic_edge),
+            "the inserted rail row retains its source edge"
+        );
+        let topic_row = rail.nodes[topic].y;
+        overlay.compute_visible_counts(&graph, &overview, &rail, topic_row..topic_row + 1);
+        assert_eq!(
+            overlay.counts[topic],
+            Some(1),
+            "a visible reference gets its exact exclusive count"
+        );
+        let stamp = overlay.stamp;
+        overlay.compute_visible_counts(&graph, &overview, &rail, topic_row..topic_row + 1);
+        assert_eq!(overlay.stamp, stamp, "a cached visible count is not traversed again");
+    }
+
+    #[test]
+    fn topological_navigation_and_g_shortcuts_reach_the_top_and_root() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.motion = Motion::Topological;
+        let overview = tree.overview.as_ref().expect("overview exists");
+        let root = overview.by_commit[&graph.index(id(1)).expect("root exists")];
+        let fork = overview.by_commit[&graph.index(id(2)).expect("fork exists")];
+        let main = overview.by_commit[&graph.index(id(6)).expect("main exists")];
+        tree.selected = Some(root);
+
+        tree.navigate(Direction::Up);
+        assert_eq!(tree.selected, Some(fork), "up moves toward a leaf");
+        tree.navigate(Direction::Down);
+        assert_eq!(tree.selected, Some(root), "down moves toward the root");
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE));
+        assert_eq!(tree.selected, Some(main), "plain g reaches the top selectable node");
+        tree.selected = Some(main);
+        tree.handle_key(KeyEvent::new(KeyCode::Char('G'), KeyModifiers::SHIFT));
+        assert_eq!(
+            tree.selected,
+            Some(root),
+            "uppercase G reaches the current component root"
+        );
+        tree.selected = Some(main);
+        tree.handle_key(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::SHIFT));
+        assert_eq!(tree.selected, Some(root), "shift-modified lowercase g reaches the root");
+    }
+
+    #[test]
+    fn rebuild_preserves_selection_by_object_id() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.selected = tree.overview.as_ref().and_then(|overview| {
+            graph
+                .index(id(5))
+                .and_then(|index| overview.by_commit.get(&index).copied())
+        });
+
+        let reordered = HistoryGraph::from_test_commits(&[
+            (id(6), vec![id(3), id(4)]),
+            (id(5), vec![id(4)]),
+            (id(4), vec![id(2)]),
+            (id(3), vec![id(2)]),
+            (id(2), vec![id(1)]),
+            (id(1), vec![]),
+        ]);
+        tree.rebuild(&reordered, &refs, &decorations);
+
+        assert_eq!(
+            tree.selected
+                .and_then(|selected| tree.overview.as_ref()?.nodes.get(selected))
+                .map(|node| node.id),
+            Some(id(5)),
+            "refresh keeps the selected commit when graph indices change"
+        );
+    }
+
+    #[test]
+    fn toggling_tags_removes_their_labels_and_topology() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations.entry(id(3)).or_default().extend([
+            Decoration {
+                name: "v1".into(),
+                kind: DecorationKind::Tag,
+            },
+            Decoration {
+                name: "release".into(),
+                kind: DecorationKind::AnnotatedTag,
+            },
+        ]);
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        assert!(tree.toggle(), "the available tree opens");
+        let tagged = graph.index(id(3)).expect("tagged commit exists");
+        assert!(
+            tree.overview
+                .as_ref()
+                .is_some_and(|overview| overview.by_commit.contains_key(&tagged)),
+            "tags retain otherwise linear commits"
+        );
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char('T'), KeyModifiers::SHIFT));
+        assert!(tree.hide_tags, "uppercase T hides tags");
+        assert!(
+            tree.overview
+                .as_ref()
+                .is_some_and(|overview| !overview.by_commit.contains_key(&tagged)),
+            "a tag-only linear node disappears from the projection"
+        );
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::SHIFT));
+        assert!(
+            tree.overview
+                .as_ref()
+                .is_some_and(|overview| overview.by_commit.contains_key(&tagged)),
+            "shift-modified lowercase t restores tag nodes"
+        );
+        tree.handle_key(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE));
+        assert!(!tree.is_active(), "plain t returns to history");
+    }
+
+    #[test]
+    fn full_rendering_is_unstyled_ascii() {
+        let (graph, refs, decorations) = fixture();
+        let overview = Overview::new(&graph, &refs, &decorations, true);
+        let rendered = render_overview(&overview, false);
+
+        assert!(rendered.contains("main"), "HEAD is rendered without selection state");
+        assert!(rendered.contains("topic"), "ordinary nodes retain their label");
+        assert!(rendered.contains("<root>"), "the full projection reaches its root");
+        assert!(rendered.contains('o'), "ordinary nodes use an ASCII marker");
+        assert!(!rendered.contains('●'), "ASCII output has no Unicode node glyphs");
+        assert!(!rendered.contains('\u{1b}'), "plain output has no terminal styles");
+    }
+
+    #[test]
+    fn rail_layout_uses_rounded_unicode_connections_and_ascii_fallbacks() {
+        let (graph, refs, decorations) = fixture();
+        let overview = Overview::new(&graph, &refs, &decorations, true);
+        let unicode = render_overview(&overview, true);
+        let ascii = render_overview(&overview, false);
+
+        assert!(
+            unicode.contains("│ ● topic"),
+            "branch nodes stay in their lane: {unicode:?}"
+        );
+        assert!(
+            unicode.contains("├─╯"),
+            "forks terminate with a rounded corner: {unicode:?}"
+        );
+        assert!(!unicode.contains('┌'), "rail corners are not square");
+        assert!(ascii.contains("| o topic"), "ASCII output retains the branch lane");
+        assert!(ascii.contains("+-+"), "ASCII output retains the join row");
+    }
+
+    #[test]
+    fn interactive_tree_renders_exact_visible_counts() -> gix_testtools::Result {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        let mut terminal = Terminal::new(TestBackend::new(100, 18))?;
+
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        let rendered = terminal
+            .backend()
+            .buffer()
+            .content
+            .chunks(100)
+            .map(|row| row.iter().map(ratatui::buffer::Cell::symbol).collect::<String>())
+            .collect::<Vec<_>>()
+            .join("\n");
+        assert!(rendered.contains("main"), "the rounded tree shows main");
+        assert!(rendered.contains("topic"), "the rounded tree shows topic");
+        assert!(rendered.contains("tree ·"), "the footer identifies the tree");
+        assert!(
+            rendered.contains("5 main"),
+            "the selected reference shows its exact count"
+        );
+        assert!(
+            rendered.contains("1 topic"),
+            "visible references show relative exact counts"
+        );
+        assert!(
+            !rendered.contains("5●"),
+            "the rail marker is not repeated after a count"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn tree_toggle_opens_and_closes_the_single_layout() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+
+        assert!(tree.toggle());
+        assert!(tree.is_active());
+        assert!(tree.toggle());
+        assert!(!tree.is_active());
+    }
+}
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7a314f183f2..1c480e51dc3 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -969,6 +969,8 @@ pub(crate) fn draw_with_worktree(
         }
         ordered.push(toggle("[ align", app.align_metadata));
         ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("tree", 't', false));
+        ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("message", 'm', app.show_commit));
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
@@ -1942,7 +1944,7 @@ fn author_label(
     }
 }
 
-fn decoration_style(kind: DecorationKind) -> Style {
+pub(crate) fn decoration_style(kind: DecorationKind) -> Style {
     match kind {
         DecorationKind::Head => Style::default().fg(Color::Cyan).add_modifier(Modifier::BOLD),
         DecorationKind::Pin => Style::default().fg(Color::Blue),
@@ -3040,14 +3042,14 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         assert!(
             footer.starts_with(
-                    "0 commits · view · edit · copy · refs · ? ([ align · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                    "0 commits · view · edit · copy · refs · ? ([ align · tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
         assert_reversed_group(
             &terminal,
             1,
-            "? ([ align · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
+            "? ([ align · tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
         );
         Ok(())
     }
@@ -4121,7 +4123,7 @@ mod tests {
         })?;
         assert!(
             rendered_line(&footer_terminal, 15).contains(
-                "? ([ align · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                "? ([ align · tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
             ),
             "the expanded information prefix contains every following action except quit"
         );

From 002eabeeae47fb9ecfbb16ffab8dbf9957700ae1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 17:29:45 +0200
Subject: [PATCH 156/282] feat: delete local branches from the tix tree

Add an edit prefix to tree nodes that gathers every eligible local branch at the selected commit and submits one multi-reference `Repository::delete_local_branches()` operation immediately with `e d`. Checked-out worktree branches and the branch remembered by the HEAD pin remain protected, and deletion deliberately performs no merged-state check.

Keep the tree interactive around the operation: Escape cancels only the armed edit prefix, success schedules a refresh, and cleanup failures also refresh when references may already have changed. Status and footer messages name the affected branches without exposing full ref paths.
---
 gix-tix/src/lib.rs  |  31 +++++++++
 gix-tix/src/tree.rs | 155 +++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 178 insertions(+), 8 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 75e584d8ff1..0e14b5080b0 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1495,6 +1495,37 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
+                    tree::Input::DeleteLocalBranches(names) => {
+                        let label = {
+                            let names = names
+                                .iter()
+                                .map(|name| name.shorten().to_str_lossy().into_owned())
+                                .collect::<Vec<_>>();
+                            if names.len() == 1 {
+                                format!("branch {}", names[0])
+                            } else {
+                                format!("branches {}", names.join(", "))
+                            }
+                        };
+                        match open_repository(&repository_path, repository_is_bare, false) {
+                            Ok(mut repository) => match repository.delete_local_branches(names) {
+                                Ok(()) => {
+                                    tree.leave_message(format!("deleted {label}"));
+                                    refresh_pending = true;
+                                }
+                                Err(err) => {
+                                    let changed =
+                                        matches!(&err, gix::repository::branch::delete::Error::Cleanup { .. });
+                                    tree.leave_message(format!("delete {label}: {err}"));
+                                    refresh_pending |= changed;
+                                }
+                            },
+                            Err(err) => tree.leave_message(format!("delete {label}: {err:#}")),
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
                     tree::Input::Quit => return Ok(None),
                 },
                 TerminalEvent::Mouse(mouse) if tree.handle_mouse(mouse.kind, 1) => {
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
index d30a84e9fad..be5d47e90f4 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/tree.rs
@@ -115,8 +115,10 @@ enum Direction {
     Right,
 }
 
+#[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Input {
     Handled,
+    DeleteLocalBranches(Vec<gix::refs::FullName>),
     Quit,
 }
 
@@ -133,6 +135,8 @@ pub(crate) struct Tree {
     placed: Option<Placed>,
     ensure_visible: bool,
     hide_tags: bool,
+    edit_expanded: bool,
+    message: Option<String>,
 }
 
 impl Tree {
@@ -151,6 +155,11 @@ impl Tree {
 
     pub(crate) fn leave(&mut self) {
         self.active = false;
+        self.edit_expanded = false;
+    }
+
+    pub(crate) fn leave_message(&mut self, message: impl Into<String>) {
+        self.message = Some(message.into());
     }
 
     pub(crate) fn rebuild(&mut self, graph: &HistoryGraph, refs: &RefSnapshot, decorations: &Decorations) {
@@ -200,11 +209,29 @@ impl Tree {
     }
 
     pub(crate) fn handle_key(&mut self, key: KeyEvent) -> Input {
+        self.message = None;
         if key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL)
             || key.code == KeyCode::Char('q')
         {
             return Input::Quit;
         }
+        if self.edit_expanded {
+            self.edit_expanded = false;
+            if key.code == KeyCode::Char('d') && key.modifiers.is_empty() {
+                let branches = self.selected_local_branches();
+                if branches.is_empty() {
+                    self.message = Some("no deletable local branches at the selected node".into());
+                    return Input::Handled;
+                }
+                return Input::DeleteLocalBranches(branches);
+            }
+            if key.code == KeyCode::Esc {
+                return Input::Handled;
+            }
+        } else if key.code == KeyCode::Char('e') && key.modifiers.is_empty() {
+            self.edit_expanded = true;
+            return Input::Handled;
+        }
         if key.code == KeyCode::Esc {
             self.leave();
             return Input::Handled;
@@ -351,20 +378,45 @@ impl Tree {
             self.motion,
             &self.choices,
         );
-        let motion = match self.motion {
-            Motion::Nearest => "nearest",
-            Motion::Topological => "topo ↑ leaves · ↓ roots · ←/→ branch",
+        let footer_text = if let Some(message) = &self.message {
+            message.clone()
+        } else if self.edit_expanded {
+            let branches = self.selected_local_branches();
+            if branches.is_empty() {
+                "tree · e edit (no actions)".into()
+            } else {
+                format!("tree · e edit (d delete {})", short_branch_list(&branches))
+            }
+        } else {
+            let motion = match self.motion {
+                Motion::Nearest => "nearest",
+                Motion::Topological => "topo ↑ leaves · ↓ roots · ←/→ branch",
+            };
+            let tags = if self.hide_tags { "off" } else { "on" };
+            format!("tree · {motion} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history")
         };
-        let tags = if self.hide_tags { "off" } else { "on" };
         frame.render_widget(
-            Paragraph::new(format!(
-                "tree · {motion} · g top · G root · T tags:{tags} · Shift+directions pan · t/Esc history"
-            ))
-            .style(Style::default().add_modifier(Modifier::DIM)),
+            Paragraph::new(footer_text).style(Style::default().add_modifier(Modifier::DIM)),
             footer,
         );
     }
 
+    fn selected_local_branches(&self) -> Vec<gix::refs::FullName> {
+        self.selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            .into_iter()
+            .flat_map(|node| &node.decorations)
+            .filter(|decoration| decoration.kind == DecorationKind::Local)
+            .map(|decoration| {
+                let mut name = b"refs/heads/".to_vec();
+                name.extend_from_slice(&decoration.name);
+                gix::bstr::BString::from(name)
+                    .try_into()
+                    .expect("local decorations originate from valid local branch names")
+            })
+            .collect()
+    }
+
     fn navigate(&mut self, direction: Direction) {
         let Some(overview) = self.overview.as_ref() else { return };
         let Some(selected) = self.selected else { return };
@@ -960,6 +1012,14 @@ fn rail_label(node: &Node, count: Option<usize>) -> String {
     out
 }
 
+fn short_branch_list(names: &[gix::refs::FullName]) -> String {
+    names
+        .iter()
+        .map(|name| name.shorten().to_str_lossy().into_owned())
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
 fn edge_style(overview: &Overview, overlay: Option<&Overlay>, edge: &Edge) -> Style {
     let Some(overlay) = overlay else {
         return Style::default();
@@ -1188,6 +1248,85 @@ mod tests {
         (graph, refs, decorations)
     }
 
+    #[test]
+    fn e_arms_immediate_deletion_of_all_ordinary_local_branches() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations.get_mut(&id(6)).expect("main is decorated").extend([
+            Decoration {
+                name: "also-main".into(),
+                kind: DecorationKind::Local,
+            },
+            Decoration {
+                name: "checked-out".into(),
+                kind: DecorationKind::WorktreeBranch,
+            },
+            Decoration {
+                name: "remembered".into(),
+                kind: DecorationKind::HeadPinBranch,
+            },
+            Decoration {
+                name: "origin/main".into(),
+                kind: DecorationKind::Remote,
+            },
+        ]);
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        assert!(tree.toggle(), "the tree opens");
+
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
+            Input::Handled,
+            "e arms the edit prefix"
+        );
+        assert!(tree.edit_expanded);
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)),
+            Input::DeleteLocalBranches(vec![
+                "refs/heads/also-main".try_into().expect("valid"),
+                "refs/heads/main".try_into().expect("valid"),
+            ]),
+            "d immediately submits every ordinary local branch and no protected decoration"
+        );
+        assert!(!tree.edit_expanded);
+    }
+
+    #[test]
+    fn escape_cancels_the_edit_prefix_without_leaving_the_tree() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        assert!(tree.toggle(), "the tree opens");
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
+        tree.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
+
+        assert!(tree.is_active(), "Escape cancels the armed prefix first");
+        assert!(!tree.edit_expanded);
+    }
+
+    #[test]
+    fn protected_branches_leave_no_delete_action() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations.get_mut(&id(5)).expect("topic is decorated")[0].kind = DecorationKind::HeadPinBranch;
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.selected = tree.overview.as_ref().and_then(|overview| {
+            graph
+                .index(id(5))
+                .and_then(|index| overview.by_commit.get(&index).copied())
+        });
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)),
+            Input::Handled
+        );
+        assert_eq!(
+            tree.message.as_deref(),
+            Some("no deletable local branches at the selected node")
+        );
+    }
+
     #[test]
     fn first_parent_shape_uses_all_parent_reachability_for_counts_and_boundaries() {
         let (graph, refs, decorations) = fixture();

From 1533861d17d72f67fb392fae391fcfe3d41fb0a5 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 18:54:50 +0200
Subject: [PATCH 157/282] feat: manage pins and count anchors in the tix tree

Make Space toggle an explicit reachability-count anchor so cursor navigation can reuse its overlay and placement instead of recomputing counts on every move. Preserve a visible anchor across refreshes and clear or relocate it when topology changes, including tag filtering.

Render ordinary pins as one marker without exposing their internal names, and let `p` remove pins or create one at a visible reference or raw tip. Unique visible references produce symbolic pins while ambiguous targets remain fixed; selection falls to the nearest surviving tree node when pin or branch removal eliminates the current node.
---
 gix-tix/spec.md                 |  21 +-
 gix-tix/src/edit/time_travel.rs |  74 +++++
 gix-tix/src/history.rs          |   2 +-
 gix-tix/src/lib.rs              |  42 ++-
 gix-tix/src/tree.rs             | 512 ++++++++++++++++++++++++++++++--
 5 files changed, 621 insertions(+), 30 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index f44122557cc..12f252f9f71 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -206,11 +206,12 @@ without trading responsiveness for metadata that is not visible.
 - The selected node shows the exact number of commits reachable
   through all parents. Other reference and raw-tip nodes show the number reachable
   from them but not from the selection as `N●`; multiple labels at one commit
-  share one count. Selected first-parent ancestry is emphasized, other reachable
-  history is dimmed, and exclusive history remains normal. A non-selectable `●`
-  splits a contracted edge where it becomes reachable. Reachability and boundaries
-  are computed when selection changes; exact exclusive counts are computed and
-  cached only for reference rows visible in the viewport.
+  share one count. Space fixes this count anchor at the selected node or clears it
+  when pressed there again, so cursor navigation can reuse reachability and layout
+  caches. Selected first-parent ancestry is emphasized, other reachable history is
+  dimmed, and exclusive history remains normal. A non-selectable `●` splits a
+  contracted edge where it becomes reachable. Exact exclusive counts are computed
+  and cached only for reference rows visible in the viewport.
 - The tree orders tips above roots and renders one retained or boundary
   node per row. Rounded ancestry lanes precede aligned counts and labels; their
   disk is the node marker, so counts do not repeat it.
@@ -222,11 +223,19 @@ without trading responsiveness for metadata that is not visible.
 - `g` selects the top tree node, and `Shift-G` selects the root of the current
   component. Shift-modified directions pan the tree viewport; mouse and the existing
   Ctrl/Page keys scroll without moving the tree cursor.
+- Ordinary pins use the history view's single blue `📌`, without exposing their
+  internal ref names. `p` removes all ordinary pins at a pinned node or creates one
+  at a visible reference/raw tip. A sole visible reference produces a symbolic pin;
+  ambiguous or unnamed targets produce a direct pin. Hidden tags do not participate.
+- After deleting selected branches or pins, refresh keeps the commit when it remains
+  a tree node, otherwise selects the next surviving node row or the nearest previous
+  row when nothing below survives.
 
 ### Tree diagnostics
 
 - `tix tree` prints the entire reference projection to standard output without
-  terminal colors, selection state, counts, or viewport clipping. It traverses
+  terminal colors, selection state, counts, or viewport clipping. Pins render as
+  `[pin]` in ASCII output and `📌` with `--unicode`. It traverses
   all normal references by default; positional revisions scope traversal.
 - `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
   corresponding tree inputs. Output uses ASCII lines and `o` nodes by default;
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 27358054a9a..a60c1b32991 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -653,6 +653,42 @@ pub(crate) fn create_or_reuse_pin(
     Ok((history::Pin { name, target, id }, true))
 }
 
+pub(crate) fn create_tree_pin(
+    repository: &gix::Repository,
+    id: ObjectId,
+    include_tags: bool,
+) -> Result<(history::Pin, bool)> {
+    let mut references = Vec::new();
+    for reference in repository
+        .references()
+        .context("could not open references for tree pinning")?
+        .all()
+        .context("could not iterate references for tree pinning")?
+    {
+        let mut reference =
+            reference.map_err(|err| anyhow::anyhow!("could not read a reference for tree pinning: {err}"))?;
+        let name = reference.name().to_owned();
+        let kind = history::decoration_kind(name.as_bstr());
+        if matches!(
+            kind,
+            history::DecorationKind::Pin | history::DecorationKind::Stash | history::DecorationKind::Special
+        ) || !include_tags && matches!(kind, history::DecorationKind::Tag)
+            || name.as_bstr().starts_with(history::REVIEW_STASH_PREFIX)
+        {
+            continue;
+        }
+        let Ok(target) = reference.peel_to_id() else { continue };
+        if target.detach() == id && repository.find_header(target)?.kind() == gix::object::Kind::Commit {
+            references.push(name);
+        }
+    }
+    let target = match references.as_slice() {
+        [name] => Target::Symbolic(name.clone()),
+        _ => Target::Object(id),
+    };
+    create_or_reuse_pin(repository, target, id, "tix tree pin")
+}
+
 pub(super) fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     repository
         .edit_references([delete_pin_edit(pin)])
@@ -1284,6 +1320,44 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn tree_pins_follow_one_visible_reference_and_freeze_ambiguous_targets() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let main = repository.rev_parse_single("main")?.detach();
+        let (pin, created) = create_tree_pin(&repository, main, true)?;
+        assert!(created, "the first tree pin is created");
+        assert_eq!(
+            pin.target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(b"refs/heads/main".as_bstr()),
+            "one visible reference produces a symbolic pin"
+        );
+        remove_pins(repository.git_dir(), repository.is_bare(), main)?;
+
+        repository.reference(
+            "refs/tags/also-main",
+            main,
+            PreviousValue::MustNotExist,
+            "test ambiguous tree pin",
+        )?;
+        let (pin, created) = create_tree_pin(&repository, main, true)?;
+        assert!(created);
+        assert_eq!(
+            pin.target,
+            Target::Object(main),
+            "multiple visible refs produce a direct pin"
+        );
+        remove_pins(repository.git_dir(), repository.is_bare(), main)?;
+
+        let (pin, created) = create_tree_pin(&repository, main, false)?;
+        assert!(created);
+        assert!(
+            pin.target.try_name().is_some(),
+            "a hidden tag does not make the branch target ambiguous"
+        );
+        Ok(())
+    }
+
     #[test]
     fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 1a887e4a13f..e623b57bcdc 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1819,7 +1819,7 @@ fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
     }
 }
 
-fn decoration_kind(name: &[u8]) -> DecorationKind {
+pub(crate) fn decoration_kind(name: &[u8]) -> DecorationKind {
     if name.starts_with(PIN_PREFIX) {
         DecorationKind::Pin
     } else if name.starts_with(STASH_PREFIX) {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 0e14b5080b0..72459e833e2 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1495,7 +1495,7 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
-                    tree::Input::DeleteLocalBranches(names) => {
+                    tree::Input::DeleteLocalBranches { names, fallback } => {
                         let label = {
                             let names = names
                                 .iter()
@@ -1507,21 +1507,61 @@ fn event_loop(
                                 format!("branches {}", names.join(", "))
                             }
                         };
+                        let mut deleted = false;
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(mut repository) => match repository.delete_local_branches(names) {
                                 Ok(()) => {
                                     tree.leave_message(format!("deleted {label}"));
+                                    deleted = true;
                                     refresh_pending = true;
                                 }
                                 Err(err) => {
                                     let changed =
                                         matches!(&err, gix::repository::branch::delete::Error::Cleanup { .. });
                                     tree.leave_message(format!("delete {label}: {err}"));
+                                    deleted = changed;
                                     refresh_pending |= changed;
                                 }
                             },
                             Err(err) => tree.leave_message(format!("delete {label}: {err:#}")),
                         }
+                        if deleted {
+                            tree.select_after_reference_deletion(fallback);
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
+                    tree::Input::Pin { id, include_tags } => {
+                        match open_repository(&repository_path, repository_is_bare, false) {
+                            Ok(repository) => match edit::time_travel::create_tree_pin(&repository, id, include_tags) {
+                                Ok((pin, created)) => {
+                                    let label = edit::time_travel::pin_label(&pin);
+                                    tree.leave_message(if created {
+                                        format!("created {label}")
+                                    } else {
+                                        format!("already pinned as {label}")
+                                    });
+                                    refresh_pending |= created;
+                                }
+                                Err(err) => tree.leave_message(format!("pin: {err:#}")),
+                            },
+                            Err(err) => tree.leave_message(format!("pin: {err:#}")),
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
+                    tree::Input::Unpin { id, fallback } => {
+                        match edit::time_travel::remove_pins(&repository_path, repository_is_bare, id) {
+                            Ok(0) => tree.leave_message("no pins removed"),
+                            Ok(count) => {
+                                tree.leave_message(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
+                                tree.select_after_reference_deletion(fallback);
+                                refresh_pending = true;
+                            }
+                            Err(err) => tree.leave_message(format!("unpin: {err:#}")),
+                        }
                         dirty = true;
                         urgent = true;
                         continue;
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
index be5d47e90f4..731bc79c867 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/tree.rs
@@ -46,6 +46,8 @@ struct Node {
     decorations: Vec<Decoration>,
     is_head: bool,
     is_anchor: bool,
+    is_pinned: bool,
+    can_pin: bool,
     raw_tip: bool,
     sort_key: String,
 }
@@ -118,10 +120,27 @@ enum Direction {
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Input {
     Handled,
-    DeleteLocalBranches(Vec<gix::refs::FullName>),
+    DeleteLocalBranches {
+        names: Vec<gix::refs::FullName>,
+        fallback: SelectionFallback,
+    },
+    Pin {
+        id: ObjectId,
+        include_tags: bool,
+    },
+    Unpin {
+        id: ObjectId,
+        fallback: SelectionFallback,
+    },
     Quit,
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub(crate) struct SelectionFallback {
+    selected: ObjectId,
+    candidates: Vec<ObjectId>,
+}
+
 #[derive(Default)]
 pub(crate) struct Tree {
     active: bool,
@@ -130,6 +149,8 @@ pub(crate) struct Tree {
     alternate_overview: Option<Overview>,
     overlay: Option<Overlay>,
     selected: Option<usize>,
+    count_anchor: Option<ObjectId>,
+    selection_after_reference_deletion: Option<SelectionFallback>,
     choices: Vec<usize>,
     offset: Offset,
     placed: Option<Placed>,
@@ -174,6 +195,10 @@ impl Tree {
         } else {
             (with_tags, without_tags)
         };
+        let fallback = self
+            .selection_after_reference_deletion
+            .take()
+            .filter(|fallback| Some(fallback.selected) == selected);
         let head = overview
             .nodes
             .iter()
@@ -199,7 +224,21 @@ impl Tree {
                     .index(id)
                     .and_then(|index| overview.by_commit.get(&index).copied())
             })
+            .or_else(|| {
+                fallback.and_then(|fallback| {
+                    fallback
+                        .candidates
+                        .into_iter()
+                        .find_map(|id| overview.nodes.iter().position(|node| node.id == id))
+                })
+            })
             .or(head);
+        if self
+            .count_anchor
+            .is_some_and(|id| !overview.nodes.iter().any(|node| node.id == id))
+        {
+            self.count_anchor = None;
+        }
         self.choices = vec![0; overview.nodes.len()];
         self.overview = Some(overview);
         self.alternate_overview = Some(alternate_overview);
@@ -223,7 +262,12 @@ impl Tree {
                     self.message = Some("no deletable local branches at the selected node".into());
                     return Input::Handled;
                 }
-                return Input::DeleteLocalBranches(branches);
+                return Input::DeleteLocalBranches {
+                    names: branches,
+                    fallback: self
+                        .reference_deletion_fallback()
+                        .expect("a selected branch has a deletion fallback"),
+                };
             }
             if key.code == KeyCode::Esc {
                 return Input::Handled;
@@ -236,6 +280,34 @@ impl Tree {
             self.leave();
             return Input::Handled;
         }
+        if key.code == KeyCode::Char(' ') && key.modifiers.is_empty() {
+            self.toggle_count_anchor();
+            return Input::Handled;
+        }
+        if key.code == KeyCode::Char('p') && key.modifiers.is_empty() {
+            let Some(node) = self
+                .selected
+                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            else {
+                return Input::Handled;
+            };
+            if node.is_pinned {
+                return Input::Unpin {
+                    id: node.id,
+                    fallback: self
+                        .reference_deletion_fallback()
+                        .expect("a selected pin has a deletion fallback"),
+                };
+            }
+            if !node.can_pin {
+                self.message = Some("no reference at the selected node".into());
+                return Input::Handled;
+            }
+            return Input::Pin {
+                id: node.id,
+                include_tags: !self.hide_tags,
+            };
+        }
         if key.code == KeyCode::Char('G')
             || key.code == KeyCode::Char('g') && key.modifiers.contains(KeyModifiers::SHIFT)
         {
@@ -309,12 +381,17 @@ impl Tree {
     }
 
     pub(crate) fn draw(&mut self, frame: &mut Frame<'_>, graph: Option<&HistoryGraph>) {
+        let overlay_selected = self
+            .count_anchor
+            .and_then(|id| self.overview.as_ref()?.nodes.iter().position(|node| node.id == id))
+            .or(self.selected);
         if self.overlay.as_ref().map(|overlay| overlay.selected)
             != self
-                .selected
-                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+                .overview
+                .as_ref()
+                .and_then(|overview| overlay_selected.and_then(|selected| overview.nodes.get(selected)))
                 .map(|node| node.commit)
-            && let (Some(graph), Some(selected)) = (graph, self.selected)
+            && let (Some(graph), Some(selected)) = (graph, overlay_selected)
         {
             self.overlay = self
                 .overview
@@ -393,7 +470,26 @@ impl Tree {
                 Motion::Topological => "topo ↑ leaves · ↓ roots · ←/→ branch",
             };
             let tags = if self.hide_tags { "off" } else { "on" };
-            format!("tree · {motion} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history")
+            let counts = self.count_anchor.map_or_else(
+                || "Space counts:auto".into(),
+                |id| format!("Space counts:{}", self.node_label(id)),
+            );
+            let pin = self
+                .selected
+                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+                .and_then(|node| {
+                    if node.is_pinned {
+                        Some(" · p unpin")
+                    } else if node.can_pin {
+                        Some(" · p pin")
+                    } else {
+                        None
+                    }
+                })
+                .unwrap_or_default();
+            format!(
+                "tree · {motion} · {counts}{pin} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
+            )
         };
         frame.render_widget(
             Paragraph::new(footer_text).style(Style::default().add_modifier(Modifier::DIM)),
@@ -417,6 +513,66 @@ impl Tree {
             .collect()
     }
 
+    pub(crate) fn select_after_reference_deletion(&mut self, fallback: SelectionFallback) {
+        self.selection_after_reference_deletion = Some(fallback);
+    }
+
+    fn selected_id(&self) -> Option<ObjectId> {
+        self.selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            .map(|node| node.id)
+    }
+
+    fn reference_deletion_fallback(&self) -> Option<SelectionFallback> {
+        let overview = self.overview.as_ref()?;
+        let selected = self.selected?;
+        let temporary;
+        let placed = match self.placed.as_ref() {
+            Some(placed) => placed,
+            None => {
+                temporary = place_rail(overview, self.overlay.as_ref());
+                &temporary
+            }
+        };
+        let mut rows: Vec<_> = overview
+            .nodes
+            .iter()
+            .enumerate()
+            .map(|(index, node)| (placed.nodes[index].y, node.id))
+            .collect();
+        rows.sort_by_key(|(row, _)| *row);
+        let position = rows.iter().position(|(_, id)| *id == overview.nodes[selected].id)?;
+        let candidates = rows[position + 1..]
+            .iter()
+            .map(|(_, id)| *id)
+            .chain(rows[..position].iter().rev().map(|(_, id)| *id))
+            .collect();
+        Some(SelectionFallback {
+            selected: overview.nodes[selected].id,
+            candidates,
+        })
+    }
+
+    fn toggle_count_anchor(&mut self) {
+        let Some(selected) = self.selected_id() else { return };
+        let previous = self.count_anchor.unwrap_or(selected);
+        self.count_anchor = (self.count_anchor != Some(selected)).then_some(selected);
+        let current = self.count_anchor.unwrap_or(selected);
+        if previous != current {
+            self.overlay = None;
+            self.placed = None;
+        }
+    }
+
+    fn node_label(&self, id: ObjectId) -> String {
+        self.overview
+            .as_ref()
+            .and_then(|overview| overview.nodes.iter().find(|node| node.id == id))
+            .map(node_label)
+            .filter(|label| !label.is_empty())
+            .unwrap_or_else(|| id.to_hex_with_len(7).to_string())
+    }
+
     fn navigate(&mut self, direction: Direction) {
         let Some(overview) = self.overview.as_ref() else { return };
         let Some(selected) = self.selected else { return };
@@ -445,8 +601,7 @@ impl Tree {
         };
         if let Some(next) = next {
             self.selected = Some(next);
-            self.overlay = None;
-            self.placed = None;
+            self.selection_changed();
             self.ensure_visible = true;
         }
     }
@@ -459,8 +614,7 @@ impl Tree {
             selected = parent;
         }
         self.selected = Some(selected);
-        self.overlay = None;
-        self.placed = None;
+        self.selection_changed();
         self.ensure_visible = true;
     }
 
@@ -475,8 +629,7 @@ impl Tree {
             selected = child;
         }
         self.selected = Some(selected);
-        self.overlay = None;
-        self.placed = None;
+        self.selection_changed();
         self.ensure_visible = true;
     }
 
@@ -496,12 +649,25 @@ impl Tree {
             .or_else(|| overview.nodes.iter().position(|node| node.raw_tip))
             .or((!overview.nodes.is_empty()).then_some(0));
         self.hide_tags = !self.hide_tags;
+        if self
+            .count_anchor
+            .is_some_and(|id| !overview.nodes.iter().any(|node| node.id == id))
+        {
+            self.count_anchor = None;
+        }
         self.choices = vec![0; overview.nodes.len()];
         self.overlay = None;
         self.placed = None;
         self.ensure_visible = true;
     }
 
+    fn selection_changed(&mut self) {
+        if self.count_anchor.is_none() {
+            self.overlay = None;
+            self.placed = None;
+        }
+    }
+
     fn pan(&mut self, direction: Direction, amount: usize) {
         let offset = &mut self.offset;
         match direction {
@@ -523,6 +689,8 @@ impl Overview {
         let mut labels = HashMap::<CommitIndex, Vec<Decoration>>::new();
         let mut heads = HashSet::new();
         let mut anchors = HashSet::new();
+        let mut pinned = HashSet::new();
+        let mut pinnable = HashSet::new();
         for (id, decorations) in decorations {
             let Some(index) = graph.index(*id) else { continue };
             for decoration in decorations {
@@ -532,9 +700,16 @@ impl Overview {
                 if decoration.kind == DecorationKind::Head {
                     heads.insert(index);
                     anchors.insert(index);
+                    pinnable.insert(index);
+                } else if decoration.kind == DecorationKind::Pin {
+                    pinned.insert(index);
+                    anchors.insert(index);
                 } else if decoration.kind != DecorationKind::Special {
                     labels.entry(index).or_default().push(decoration.clone());
                     anchors.insert(index);
+                    if decoration.kind != DecorationKind::Stash {
+                        pinnable.insert(index);
+                    }
                 }
             }
         }
@@ -545,6 +720,7 @@ impl Overview {
             .filter_map(|id| graph.index(*id))
             .inspect(|index| {
                 anchors.insert(*index);
+                pinnable.insert(*index);
             })
             .collect();
         if anchors.is_empty() {
@@ -611,6 +787,8 @@ impl Overview {
                     decorations,
                     is_head: heads.contains(&commit),
                     is_anchor: anchors.contains(&commit),
+                    is_pinned: pinned.contains(&commit),
+                    can_pin: pinnable.contains(&commit),
                     raw_tip: raw.contains(&commit),
                     sort_key,
                 }
@@ -986,17 +1164,45 @@ fn draw_nodes(
             &text,
             style,
         );
+        if let Some(pin) = text.chars().position(|symbol| symbol == '📌') {
+            put(
+                frame,
+                area,
+                offset,
+                Point {
+                    x: placed.rail_width + pin,
+                    y: point.y,
+                },
+                '📌',
+                decoration_style(DecorationKind::Pin),
+            );
+        }
     }
 }
 
 fn rail_label(node: &Node, count: Option<usize>) -> String {
     let mut out = count.map_or_else(String::new, |count| count.to_string());
+    let suffix = node_label(node);
+    if !out.is_empty() && !suffix.is_empty() {
+        out.push(' ');
+    }
+    out.push_str(&suffix);
+    if node.is_pinned {
+        if !out.is_empty() {
+            out.push(' ');
+        }
+        out.push('📌');
+    }
+    out
+}
+
+fn node_label(node: &Node) -> String {
     let labels: Vec<_> = node
         .decorations
         .iter()
         .map(|decoration| decoration.name.to_str_lossy())
         .collect();
-    let suffix = if !labels.is_empty() {
+    if !labels.is_empty() {
         labels.join(", ")
     } else if node.raw_tip {
         node.id.to_hex_with_len(7).to_string()
@@ -1004,12 +1210,7 @@ fn rail_label(node: &Node, count: Option<usize>) -> String {
         "<root>".into()
     } else {
         String::new()
-    };
-    if !out.is_empty() && !suffix.is_empty() {
-        out.push(' ');
     }
-    out.push_str(&suffix);
-    out
 }
 
 fn short_branch_list(names: &[gix::refs::FullName]) -> String {
@@ -1103,7 +1304,12 @@ fn render_overview(overview: &Overview, unicode: bool) -> String {
         out.push_str(&lane);
         out.extend(std::iter::repeat_n(' ', placed.rail_width.saturating_sub(width)));
         if let Some(node) = node {
-            out.push_str(&rail_label(&overview.nodes[node], None));
+            let label = rail_label(&overview.nodes[node], None);
+            if unicode {
+                out.push_str(&label);
+            } else {
+                out.push_str(&label.replace('📌', "[pin]"));
+            }
         }
         while out.ends_with(' ') {
             out.pop();
@@ -1279,12 +1485,17 @@ mod tests {
             "e arms the edit prefix"
         );
         assert!(tree.edit_expanded);
+        let Input::DeleteLocalBranches { names, .. } =
+            tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE))
+        else {
+            panic!("d should submit branch deletion")
+        };
         assert_eq!(
-            tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)),
-            Input::DeleteLocalBranches(vec![
+            names,
+            vec![
                 "refs/heads/also-main".try_into().expect("valid"),
                 "refs/heads/main".try_into().expect("valid"),
-            ]),
+            ],
             "d immediately submits every ordinary local branch and no protected decoration"
         );
         assert!(!tree.edit_expanded);
@@ -1369,6 +1580,263 @@ mod tests {
         assert_eq!(overlay.stamp, stamp, "a cached visible count is not traversed again");
     }
 
+    #[test]
+    fn space_keeps_counts_anchored_without_rebuilding_while_navigating() -> gix_testtools::Result {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.motion = Motion::Topological;
+        let mut terminal = Terminal::new(TestBackend::new(100, 18))?;
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        let main = tree
+            .selected
+            .and_then(|selected| tree.overview.as_ref()?.nodes.get(selected))
+            .map(|node| node.id)
+            .expect("the initial selection exists");
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
+        assert_eq!(tree.count_anchor, Some(main), "Space anchors counts to the cursor");
+        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+        assert!(tree.overlay.is_some(), "anchored navigation retains reachability");
+        assert!(tree.placed.is_some(), "anchored navigation retains tree placement");
+        assert_eq!(
+            tree.overlay.as_ref().map(|overlay| overlay.selected),
+            graph.index(main),
+            "the retained overlay still uses the anchored commit"
+        );
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        let footer: String = terminal
+            .backend()
+            .buffer()
+            .content
+            .chunks(100)
+            .last()
+            .expect("the terminal has a footer")
+            .iter()
+            .map(ratatui::buffer::Cell::symbol)
+            .collect();
+        assert!(
+            footer.contains("Space counts:main"),
+            "the fixed anchor remains identifiable"
+        );
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
+        assert!(
+            tree.overlay.is_none(),
+            "moving the anchor invalidates reachability once"
+        );
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        let moved = tree
+            .selected
+            .and_then(|selected| tree.overview.as_ref()?.nodes.get(selected))
+            .map(|node| node.id)
+            .expect("the moved selection exists");
+        assert_eq!(tree.count_anchor, Some(moved));
+
+        tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
+        assert!(
+            tree.count_anchor.is_none(),
+            "Space on the anchor restores automatic counts"
+        );
+        assert!(tree.overlay.is_some(), "clearing at the cursor reuses the same overlay");
+        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+        assert!(
+            tree.overlay.is_none(),
+            "automatic counts invalidate when the cursor moves"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn pins_are_markers_and_p_toggles_only_reference_nodes() {
+        let (graph, refs, mut decorations) = fixture();
+        *decorations.get_mut(&id(5)).expect("topic is decorated") = vec![
+            Decoration {
+                name: "pin:first".into(),
+                kind: DecorationKind::Pin,
+            },
+            Decoration {
+                name: "pin:second".into(),
+                kind: DecorationKind::Pin,
+            },
+        ];
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        let topic =
+            tree.overview.as_ref().expect("overview exists").by_commit[&graph.index(id(5)).expect("topic exists")];
+        tree.selected = Some(topic);
+
+        assert!(matches!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
+            Input::Unpin { id: selected, .. } if selected == id(5)
+        ));
+        let overview = tree.overview.as_ref().expect("overview exists");
+        assert!(
+            overview.nodes[topic].decorations.is_empty(),
+            "pin-only tips need no label"
+        );
+        let unicode = render_overview(overview, true);
+        let ascii = render_overview(overview, false);
+        assert_eq!(unicode.matches('📌').count(), 1, "multiple pins share one marker");
+        assert!(ascii.contains("[pin]"), "ASCII diagnostics retain the pin marker");
+        assert!(!unicode.contains("pin:"), "internal pin names are hidden");
+
+        let main = overview.by_commit[&graph.index(id(6)).expect("main exists")];
+        tree.selected = Some(main);
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
+            Input::Pin {
+                id: id(6),
+                include_tags: true,
+            },
+            "an unpinned reference offers pin creation"
+        );
+        let fork =
+            tree.overview.as_ref().expect("overview exists").by_commit[&graph.index(id(2)).expect("fork exists")];
+        tree.selected = Some(fork);
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
+            Input::Handled,
+            "structural-only nodes cannot be pinned"
+        );
+        assert_eq!(tree.message.as_deref(), Some("no reference at the selected node"));
+    }
+
+    #[test]
+    fn count_anchor_survives_refresh_and_clears_with_a_hidden_tag() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations.entry(id(3)).or_default().push(Decoration {
+            name: "v1".into(),
+            kind: DecorationKind::Tag,
+        });
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
+        let main = tree.count_anchor.expect("main is anchored");
+        tree.rebuild(&graph, &refs, &decorations);
+        assert_eq!(tree.count_anchor, Some(main), "refresh preserves a visible anchor");
+
+        tree.selected = tree.overview.as_ref().and_then(|overview| {
+            graph
+                .index(id(3))
+                .and_then(|commit| overview.by_commit.get(&commit).copied())
+        });
+        tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
+        assert_eq!(tree.count_anchor, Some(id(3)), "Space moves the anchor to the tag");
+        tree.toggle_tags();
+        assert!(
+            tree.count_anchor.is_none(),
+            "hiding the anchor tag restores automatic counts"
+        );
+    }
+
+    #[test]
+    fn deleted_reference_selection_uses_the_next_surviving_row_then_the_previous() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        let overview = tree.overview.as_ref().expect("overview exists");
+        let mut rows: Vec<_> = overview
+            .nodes
+            .iter()
+            .enumerate()
+            .map(|(index, node)| (tree.placed.as_ref().expect("placed").nodes[index].y, node.id))
+            .collect();
+        rows.sort_by_key(|(row, _)| *row);
+        let (_, selected) = rows[1];
+        tree.selected = overview.nodes.iter().position(|node| node.id == selected);
+        let fallback = tree.reference_deletion_fallback().expect("selection has neighbours");
+        tree.select_after_reference_deletion(fallback);
+
+        let mut without_refs = refs.clone();
+        without_refs.view_tips.retain(|id| *id != selected);
+        let mut without_selected = decorations.clone();
+        without_selected.remove(&selected);
+        tree.rebuild(&graph, &without_refs, &without_selected);
+        assert_eq!(
+            tree.selected_id(),
+            Some(id(1)),
+            "the first surviving row below is preferred"
+        );
+
+        let graph = HistoryGraph::from_test_commits(&[(id(1), vec![]), (id(2), vec![]), (id(3), vec![])]);
+        let refs = RefSnapshot {
+            view: HashMap::new(),
+            hidden: HashMap::new(),
+            view_tips: vec![id(1), id(2), id(3)],
+            hidden_tips: Vec::new(),
+            pins: Vec::new(),
+            worktrees: Vec::new(),
+        };
+        let decorations = HashMap::from([
+            (
+                id(1),
+                vec![
+                    Decoration {
+                        name: "a".into(),
+                        kind: DecorationKind::Local,
+                    },
+                    Decoration {
+                        name: "HEAD".into(),
+                        kind: DecorationKind::Head,
+                    },
+                ],
+            ),
+            (
+                id(2),
+                vec![Decoration {
+                    name: "b".into(),
+                    kind: DecorationKind::Local,
+                }],
+            ),
+            (
+                id(3),
+                vec![Decoration {
+                    name: "c".into(),
+                    kind: DecorationKind::Local,
+                }],
+            ),
+        ]);
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.selected = tree
+            .overview
+            .as_ref()
+            .and_then(|overview| overview.nodes.iter().position(|node| node.id == id(3)));
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        let fallback = tree.reference_deletion_fallback().expect("selection has neighbours");
+        tree.select_after_reference_deletion(fallback);
+        let mut remaining_refs = refs.clone();
+        remaining_refs.view_tips.retain(|candidate| *candidate != id(3));
+        let mut remaining_decorations = decorations.clone();
+        remaining_decorations.remove(&id(3));
+        tree.rebuild(&graph, &remaining_refs, &remaining_decorations);
+        assert_eq!(
+            tree.selected_id(),
+            Some(id(2)),
+            "the previous row is used when nothing follows"
+        );
+
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.selected = tree
+            .overview
+            .as_ref()
+            .and_then(|overview| overview.nodes.iter().position(|node| node.id == id(3)));
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        let fallback = tree.reference_deletion_fallback().expect("selection has neighbours");
+        tree.select_after_reference_deletion(fallback);
+        tree.selected = tree
+            .overview
+            .as_ref()
+            .and_then(|overview| overview.nodes.iter().position(|node| node.id == id(1)));
+        tree.rebuild(&graph, &remaining_refs, &remaining_decorations);
+        assert_eq!(
+            tree.selected_id(),
+            Some(id(1)),
+            "moving the cursor before refresh cancels deletion fallback"
+        );
+    }
+
     #[test]
     fn topological_navigation_and_g_shortcuts_reach_the_top_and_root() {
         let (graph, refs, decorations) = fixture();

From ba8ba3947ef9f04b7f747a1c93dd5080c5058ea7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 19:58:30 +0200
Subject: [PATCH 158/282] feat: delete remote references from the tix tree

Resolve selected remote-tracking references through their configured fetch mappings before offering deletion. Shift-D pushes exact deletion refspecs per remote with an interactive terminal, continues across failures, and refreshes successful removals without disturbing the existing local delete action.
---
 gix-tix/spec.md     |   5 +
 gix-tix/src/lib.rs  |  70 ++++++++++++++
 gix-tix/src/tree.rs | 227 ++++++++++++++++++++++++++++++++++++++++++--
 3 files changed, 293 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 12f252f9f71..1caf9ff4eeb 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -223,6 +223,11 @@ without trading responsiveness for metadata that is not visible.
 - `g` selects the top tree node, and `Shift-G` selects the root of the current
   component. Shift-modified directions pan the tree viewport; mouse and the existing
   Ctrl/Page keys scroll without moving the tree cursor.
+- `e` opens node-level reference editing. `d` deletes every eligible local branch
+  immediately. `Shift-D` is offered only when selected remote-tracking references
+  map uniquely through a named remote's fetch refspecs; it deletes every resolved
+  remote reference, grouped into one Git push per remote. Pushes continue after
+  individual failures and run with the terminal suspended for output and authentication.
 - Ordinary pins use the history view's single blue `📌`, without exposing their
   internal ref names. `p` removes all ordinary pins at a pinned node or creates one
   at a visible reference/raw tip. A sole visible reference produces a symbolic pin;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 72459e833e2..f2f2a77b6fb 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1495,6 +1495,17 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
+                    tree::Input::ResolveRemoteReferences(names) => {
+                        match open_repository(&repository_path, repository_is_bare, false) {
+                            Ok(repository) => {
+                                tree.set_remote_deletions(tree::resolve_remote_deletions(&repository, names));
+                            }
+                            Err(err) => tree.leave_message(format!("remote edit: {err:#}")),
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
                     tree::Input::DeleteLocalBranches { names, fallback } => {
                         let label = {
                             let names = names
@@ -1532,6 +1543,34 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
+                    tree::Input::DeleteRemoteReferences { groups, fallback } => {
+                        match with_suspended_terminal(terminal, enhanced_keyboard, || {
+                            Ok(push_remote_deletions(&repository_path, &groups))
+                        }) {
+                            Ok(outcome) => {
+                                if outcome.deleted != 0 {
+                                    tree.select_after_reference_deletion(fallback);
+                                    refresh_pending = true;
+                                }
+                                let deleted = format!(
+                                    "deleted {} remote reference{}",
+                                    outcome.deleted,
+                                    if outcome.deleted == 1 { "" } else { "s" }
+                                );
+                                tree.leave_message(if outcome.failures.is_empty() {
+                                    deleted
+                                } else if outcome.deleted == 0 {
+                                    format!("delete on remote: {}", outcome.failures.join("; "))
+                                } else {
+                                    format!("{deleted}; failed: {}", outcome.failures.join("; "))
+                                });
+                            }
+                            Err(err) => tree.leave_message(format!("delete on remote: {err:#}")),
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
                     tree::Input::Pin { id, include_tags } => {
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(repository) => match edit::time_travel::create_tree_pin(&repository, id, include_tags) {
@@ -3827,6 +3866,37 @@ fn with_suspended_terminal<T>(
     Ok(value)
 }
 
+struct RemoteDeleteOutcome {
+    deleted: usize,
+    failures: Vec<String>,
+}
+
+fn push_remote_deletions(repository_path: &Path, groups: &[tree::RemoteDeletion]) -> RemoteDeleteOutcome {
+    let mut outcome = RemoteDeleteOutcome {
+        deleted: 0,
+        failures: Vec::new(),
+    };
+    for group in groups {
+        let mut command = Command::new("git");
+        command
+            .arg("-C")
+            .arg(repository_path)
+            .arg("push")
+            .arg(gix::path::from_bstr(group.remote.as_bstr()).as_ref());
+        for reference in &group.references {
+            let mut refspec = b":".to_vec();
+            refspec.extend_from_slice(reference.as_bstr());
+            command.arg(gix::path::from_bstr(refspec.as_bstr()).as_ref());
+        }
+        match command.status() {
+            Ok(status) if status.success() => outcome.deleted += group.references.len(),
+            Ok(status) => outcome.failures.push(format!("{} exited with {status}", group.remote)),
+            Err(err) => outcome.failures.push(format!("{}: {err}", group.remote)),
+        }
+    }
+    outcome
+}
+
 fn external_diff_status(status: ExitStatus) -> Result<()> {
     if status.success() || status.code() == Some(1) {
         Ok(())
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
index 731bc79c867..64638ad0d3c 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/tree.rs
@@ -1,5 +1,5 @@
 use std::{
-    collections::{HashMap, HashSet},
+    collections::{BTreeMap, HashMap, HashSet},
     ffi::OsString,
     fmt::Write,
     sync::atomic::AtomicBool,
@@ -120,10 +120,15 @@ enum Direction {
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Input {
     Handled,
+    ResolveRemoteReferences(Vec<gix::refs::FullName>),
     DeleteLocalBranches {
         names: Vec<gix::refs::FullName>,
         fallback: SelectionFallback,
     },
+    DeleteRemoteReferences {
+        groups: Vec<RemoteDeletion>,
+        fallback: SelectionFallback,
+    },
     Pin {
         id: ObjectId,
         include_tags: bool,
@@ -135,6 +140,12 @@ pub(crate) enum Input {
     Quit,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RemoteDeletion {
+    pub remote: gix::bstr::BString,
+    pub references: Vec<gix::refs::FullName>,
+}
+
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) struct SelectionFallback {
     selected: ObjectId,
@@ -157,6 +168,7 @@ pub(crate) struct Tree {
     ensure_visible: bool,
     hide_tags: bool,
     edit_expanded: bool,
+    remote_deletions: Vec<RemoteDeletion>,
     message: Option<String>,
 }
 
@@ -256,6 +268,18 @@ impl Tree {
         }
         if self.edit_expanded {
             self.edit_expanded = false;
+            if (key.code == KeyCode::Char('D')
+                || key.code == KeyCode::Char('d') && key.modifiers.contains(KeyModifiers::SHIFT))
+                && !self.remote_deletions.is_empty()
+            {
+                return Input::DeleteRemoteReferences {
+                    groups: std::mem::take(&mut self.remote_deletions),
+                    fallback: self
+                        .reference_deletion_fallback()
+                        .expect("a selected remote reference has a deletion fallback"),
+                };
+            }
+            self.remote_deletions.clear();
             if key.code == KeyCode::Char('d') && key.modifiers.is_empty() {
                 let branches = self.selected_local_branches();
                 if branches.is_empty() {
@@ -274,7 +298,13 @@ impl Tree {
             }
         } else if key.code == KeyCode::Char('e') && key.modifiers.is_empty() {
             self.edit_expanded = true;
-            return Input::Handled;
+            self.remote_deletions.clear();
+            let references = self.selected_remote_references();
+            return if references.is_empty() {
+                Input::Handled
+            } else {
+                Input::ResolveRemoteReferences(references)
+            };
         }
         if key.code == KeyCode::Esc {
             self.leave();
@@ -459,10 +489,20 @@ impl Tree {
             message.clone()
         } else if self.edit_expanded {
             let branches = self.selected_local_branches();
-            if branches.is_empty() {
+            if branches.is_empty() && self.remote_deletions.is_empty() {
                 "tree · e edit (no actions)".into()
             } else {
-                format!("tree · e edit (d delete {})", short_branch_list(&branches))
+                let mut actions = Vec::new();
+                if !branches.is_empty() {
+                    actions.push(format!("d delete {}", short_branch_list(&branches)));
+                }
+                if !self.remote_deletions.is_empty() {
+                    actions.push(format!(
+                        "D delete on remote {}",
+                        short_remote_deletion_list(&self.remote_deletions)
+                    ));
+                }
+                format!("tree · e edit ({})", actions.join(" · "))
             }
         } else {
             let motion = match self.motion {
@@ -513,6 +553,28 @@ impl Tree {
             .collect()
     }
 
+    fn selected_remote_references(&self) -> Vec<gix::refs::FullName> {
+        self.selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
+            .into_iter()
+            .flat_map(|node| &node.decorations)
+            .filter(|decoration| decoration.kind == DecorationKind::Remote)
+            .map(|decoration| {
+                let mut name = b"refs/remotes/".to_vec();
+                name.extend_from_slice(&decoration.name);
+                gix::bstr::BString::from(name)
+                    .try_into()
+                    .expect("remote decorations originate from valid remote-tracking names")
+            })
+            .collect()
+    }
+
+    pub(crate) fn set_remote_deletions(&mut self, deletions: Vec<RemoteDeletion>) {
+        if self.edit_expanded {
+            self.remote_deletions = deletions;
+        }
+    }
+
     pub(crate) fn select_after_reference_deletion(&mut self, fallback: SelectionFallback) {
         self.selection_after_reference_deletion = Some(fallback);
     }
@@ -1221,6 +1283,44 @@ fn short_branch_list(names: &[gix::refs::FullName]) -> String {
         .join(", ")
 }
 
+fn short_remote_deletion_list(groups: &[RemoteDeletion]) -> String {
+    groups
+        .iter()
+        .flat_map(|group| {
+            group
+                .references
+                .iter()
+                .map(|reference| format!("{}/{}", group.remote.to_str_lossy(), reference.shorten().to_str_lossy()))
+        })
+        .collect::<Vec<_>>()
+        .join(", ")
+}
+
+pub(crate) fn resolve_remote_deletions(
+    repository: &gix::Repository,
+    tracking_references: Vec<gix::refs::FullName>,
+) -> Vec<RemoteDeletion> {
+    let mut groups = BTreeMap::<gix::bstr::BString, Vec<gix::refs::FullName>>::new();
+    for tracking in tracking_references {
+        match repository.upstream_branch_and_remote_for_tracking_branch(tracking.as_ref()) {
+            Ok(Some((upstream, remote))) => {
+                let Some(name) = remote.name() else { continue };
+                groups.entry(name.as_bstr().to_owned()).or_default().push(upstream);
+            }
+            Ok(None) => {}
+            Err(err) => tracing::warn!(name = %tracking, error = %err, "remote reference is not editable"),
+        }
+    }
+    groups
+        .into_iter()
+        .map(|(remote, mut references)| {
+            references.sort();
+            references.dedup();
+            RemoteDeletion { remote, references }
+        })
+        .collect()
+}
+
 fn edge_style(overview: &Overview, overlay: Option<&Overlay>, edge: &Edge) -> Style {
     let Some(overlay) = overlay else {
         return Style::default();
@@ -1479,11 +1579,12 @@ mod tests {
         tree.rebuild(&graph, &refs, &decorations);
         assert!(tree.toggle(), "the tree opens");
 
-        assert_eq!(
-            tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
-            Input::Handled,
-            "e arms the edit prefix"
-        );
+        let Input::ResolveRemoteReferences(remote) =
+            tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE))
+        else {
+            panic!("e should request remote resolution")
+        };
+        assert_eq!(remote, ["refs/remotes/origin/main".try_into().expect("valid")]);
         assert!(tree.edit_expanded);
         let Input::DeleteLocalBranches { names, .. } =
             tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE))
@@ -1501,6 +1602,114 @@ mod tests {
         assert!(!tree.edit_expanded);
     }
 
+    #[test]
+    fn shift_d_deletes_every_resolved_remote_reference_without_confirmation() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations
+            .get_mut(&id(6))
+            .expect("main is decorated")
+            .push(Decoration {
+                name: "origin/main".into(),
+                kind: DecorationKind::Remote,
+            });
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        assert!(tree.toggle());
+        assert!(matches!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
+            Input::ResolveRemoteReferences(_)
+        ));
+        let groups = vec![RemoteDeletion {
+            remote: "origin".into(),
+            references: vec![
+                "refs/heads/main".try_into().expect("valid"),
+                "refs/heads/other".try_into().expect("valid"),
+            ],
+        }];
+        tree.set_remote_deletions(groups.clone());
+
+        assert!(matches!(
+            tree.handle_key(KeyEvent::new(KeyCode::Char('D'), KeyModifiers::SHIFT)),
+            Input::DeleteRemoteReferences { groups: submitted, .. } if submitted == groups
+        ));
+        assert!(!tree.edit_expanded);
+    }
+
+    #[test]
+    fn resolves_only_remote_tracking_refs_with_an_upstream_mapping() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        for args in [
+            &["config", "remote.origin.url", "."][..],
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"][..],
+        ] {
+            assert!(
+                std::process::Command::new("git")
+                    .arg("-C")
+                    .arg(fixture.path())
+                    .args(args)
+                    .status()?
+                    .success()
+            );
+        }
+        let repository = crate::test_repository::open(fixture.path())?;
+        let groups = resolve_remote_deletions(
+            &repository,
+            vec![
+                "refs/remotes/origin/topic".try_into()?,
+                "refs/remotes/missing/topic".try_into()?,
+            ],
+        );
+        assert_eq!(
+            groups,
+            [RemoteDeletion {
+                remote: "origin".into(),
+                references: vec!["refs/heads/topic".try_into()?],
+            }],
+            "only uniquely reverse-mapped remote references are editable"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn remote_deletion_continues_after_a_failed_remote() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let git = |args: &[&str]| -> gix_testtools::Result<()> {
+            let status = std::process::Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(args)
+                .status()?;
+            assert!(status.success(), "git {} succeeds", args.join(" "));
+            Ok(())
+        };
+        git(&["remote", "add", "z-working", "."])?;
+        git(&["fetch", "z-working", "topic"])?;
+        git(&["remote", "add", "a-broken", "./missing"])?;
+
+        let outcome = crate::push_remote_deletions(
+            fixture.path(),
+            &[
+                RemoteDeletion {
+                    remote: "a-broken".into(),
+                    references: vec!["refs/heads/topic".try_into()?],
+                },
+                RemoteDeletion {
+                    remote: "z-working".into(),
+                    references: vec!["refs/heads/topic".try_into()?],
+                },
+            ],
+        );
+        assert_eq!(outcome.deleted, 1, "the later working remote is still attempted");
+        assert_eq!(outcome.failures.len(), 1, "the failed remote is reported");
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(repository.try_find_reference("refs/heads/topic")?.is_none());
+        assert!(
+            repository.try_find_reference("refs/remotes/z-working/topic")?.is_none(),
+            "git push removes the corresponding tracking reference"
+        );
+        Ok(())
+    }
+
     #[test]
     fn escape_cancels_the_edit_prefix_without_leaving_the_tree() {
         let (graph, refs, decorations) = fixture();

From 6ebe9b084da8b19deeed3f7bfa7b63fc753e6077 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 20:04:43 +0200
Subject: [PATCH 159/282] feat: visualize worktrees in the tix tree

Read each worktree's symbolic HEAD or private HEAD pin so remembered branch labels stay at the branch's actual tip while detached checkout commits receive their own marker. Attached and fallback labels retain the history view's current- and linked-worktree forms.

Remove tree pin creation and removal along with ordinary pin anchors. The tree and its ASCII diagnostics now reserve the pin marker for detached worktrees, making detached checkout state visible without exposing internal pin references.
---
 gix-tix/spec.md                 |  30 +++----
 gix-tix/src/edit/time_travel.rs |  74 -----------------
 gix-tix/src/history.rs          | 137 +++++++++++++++++++++++++-----
 gix-tix/src/lib.rs              |  34 --------
 gix-tix/src/tree.rs             | 142 ++++++++++++--------------------
 gix-tix/src/ui.rs               |  13 ++-
 6 files changed, 194 insertions(+), 236 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1caf9ff4eeb..82d17e001d3 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -136,11 +136,12 @@ without trading responsiveness for metadata that is not visible.
   visible. If it has visible descendants, its unselected non-whitespace content
   is underlined and `@` is bold; a selected row keeps only bold `@`.
 - Local branches checked out in other worktrees are displayed as `short-name@`
-  in light blue instead of their plain branch decoration. Other detached
-  worktrees use their checkout directory basename. The current worktree's
-  symbolic branch is displayed as `@short-name` in the local-reference color;
-  if its HEAD is detached, a branch that happens to point at the same commit
-  remains an ordinary branch label. Identical labels are deduplicated.
+  in light blue instead of their plain branch decoration. The current worktree's
+  symbolic branch is displayed as `@short-name` in the local-reference color.
+  A detached worktree with a symbolic HEAD pin labels the remembered branch at
+  that branch's actual tip, even when the checkout is elsewhere; otherwise its
+  checkout directory basename labels the detached commit. Identical labels are
+  deduplicated.
 - When reference labels are hidden, worktree labels are visible only on the
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
@@ -228,19 +229,20 @@ without trading responsiveness for metadata that is not visible.
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
   remote reference, grouped into one Git push per remote. Pushes continue after
   individual failures and run with the terminal suspended for output and authentication.
-- Ordinary pins use the history view's single blue `📌`, without exposing their
-  internal ref names. `p` removes all ordinary pins at a pinned node or creates one
-  at a visible reference/raw tip. A sole visible reference produces a symbolic pin;
-  ambiguous or unnamed targets produce a direct pin. Hidden tags do not participate.
-- After deleting selected branches or pins, refresh keeps the commit when it remains
-  a tree node, otherwise selects the next surviving node row or the nearest previous
-  row when nothing below survives.
+- Worktree branch labels keep the history view's `@branch`, `branch@`, and
+  `★branch` forms at the branch's actual tip. Every detached worktree checkout is
+  additionally shown with one `📌`; ordinary tix pins neither anchor nor decorate
+  the tree. A detached worktree without a usable remembered branch falls back to
+  its checkout directory basename.
+- After deleting selected local or remote references, refresh keeps the commit
+  when it remains a tree node, otherwise selects the next surviving node row or
+  the nearest previous row when nothing below survives.
 
 ### Tree diagnostics
 
 - `tix tree` prints the entire reference projection to standard output without
-  terminal colors, selection state, counts, or viewport clipping. Pins render as
-  `[pin]` in ASCII output and `📌` with `--unicode`. It traverses
+  terminal colors, selection state, counts, or viewport clipping. Detached
+  worktrees render as `[pin]` in ASCII output and `📌` with `--unicode`. It traverses
   all normal references by default; positional revisions scope traversal.
 - `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
   corresponding tree inputs. Output uses ASCII lines and `o` nodes by default;
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index a60c1b32991..27358054a9a 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -653,42 +653,6 @@ pub(crate) fn create_or_reuse_pin(
     Ok((history::Pin { name, target, id }, true))
 }
 
-pub(crate) fn create_tree_pin(
-    repository: &gix::Repository,
-    id: ObjectId,
-    include_tags: bool,
-) -> Result<(history::Pin, bool)> {
-    let mut references = Vec::new();
-    for reference in repository
-        .references()
-        .context("could not open references for tree pinning")?
-        .all()
-        .context("could not iterate references for tree pinning")?
-    {
-        let mut reference =
-            reference.map_err(|err| anyhow::anyhow!("could not read a reference for tree pinning: {err}"))?;
-        let name = reference.name().to_owned();
-        let kind = history::decoration_kind(name.as_bstr());
-        if matches!(
-            kind,
-            history::DecorationKind::Pin | history::DecorationKind::Stash | history::DecorationKind::Special
-        ) || !include_tags && matches!(kind, history::DecorationKind::Tag)
-            || name.as_bstr().starts_with(history::REVIEW_STASH_PREFIX)
-        {
-            continue;
-        }
-        let Ok(target) = reference.peel_to_id() else { continue };
-        if target.detach() == id && repository.find_header(target)?.kind() == gix::object::Kind::Commit {
-            references.push(name);
-        }
-    }
-    let target = match references.as_slice() {
-        [name] => Target::Symbolic(name.clone()),
-        _ => Target::Object(id),
-    };
-    create_or_reuse_pin(repository, target, id, "tix tree pin")
-}
-
 pub(super) fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
     repository
         .edit_references([delete_pin_edit(pin)])
@@ -1320,44 +1284,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn tree_pins_follow_one_visible_reference_and_freeze_ambiguous_targets() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        let main = repository.rev_parse_single("main")?.detach();
-        let (pin, created) = create_tree_pin(&repository, main, true)?;
-        assert!(created, "the first tree pin is created");
-        assert_eq!(
-            pin.target.try_name().map(gix::refs::FullNameRef::as_bstr),
-            Some(b"refs/heads/main".as_bstr()),
-            "one visible reference produces a symbolic pin"
-        );
-        remove_pins(repository.git_dir(), repository.is_bare(), main)?;
-
-        repository.reference(
-            "refs/tags/also-main",
-            main,
-            PreviousValue::MustNotExist,
-            "test ambiguous tree pin",
-        )?;
-        let (pin, created) = create_tree_pin(&repository, main, true)?;
-        assert!(created);
-        assert_eq!(
-            pin.target,
-            Target::Object(main),
-            "multiple visible refs produce a direct pin"
-        );
-        remove_pins(repository.git_dir(), repository.is_bare(), main)?;
-
-        let (pin, created) = create_tree_pin(&repository, main, false)?;
-        assert!(created);
-        assert!(
-            pin.target.try_name().is_some(),
-            "a hidden tag does not make the branch target ambiguous"
-        );
-        Ok(())
-    }
-
     #[test]
     fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index e623b57bcdc..e87ae4c9b05 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -34,6 +34,7 @@ pub(crate) enum DecorationKind {
     Stash,
     Review,
     CurrentWorktreeBranch,
+    CurrentWorktreeDetached,
     WorktreeBranch,
     WorktreeDetached,
     Local,
@@ -67,9 +68,11 @@ impl Pin {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct WorktreeCheckout {
     pub id: ObjectId,
+    pub label_id: ObjectId,
     pub name: BString,
     pub reference: Option<gix::refs::FullName>,
     pub is_current: bool,
+    pub is_detached: bool,
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1213,7 +1216,7 @@ pub(crate) fn tree_revisions(repo: &gix::Repository, include_tags: bool) -> Resu
         };
         let name = reference.name().as_bstr().to_owned();
         let kind = decoration_kind(&name);
-        if kind == DecorationKind::Special
+        if matches!(kind, DecorationKind::Special | DecorationKind::Pin)
             || matches!(kind, DecorationKind::Tag) && !include_tags
             || name.starts_with(STASH_PREFIX)
             || name.starts_with(REVIEW_STASH_PREFIX)
@@ -1299,6 +1302,7 @@ pub(crate) fn worktree_checkouts(repo: &gix::Repository) -> Vec<WorktreeCheckout
     }
     out.sort_by(|a, b| {
         a.id.cmp(&b.id)
+            .then_with(|| a.label_id.cmp(&b.label_id))
             .then_with(|| a.name.cmp(&b.name))
             .then_with(|| a.reference.cmp(&b.reference))
     });
@@ -1320,7 +1324,8 @@ fn add_worktree_checkout(
             return;
         }
     };
-    let reference = head.referent_name().map(ToOwned::to_owned);
+    let is_detached = head.is_detached();
+    let head_reference = head.referent_name().map(ToOwned::to_owned);
     let id = match head.try_peel_to_id() {
         Ok(Some(id)) => id.detach(),
         Ok(None) => return,
@@ -1329,6 +1334,12 @@ fn add_worktree_checkout(
             return;
         }
     };
+    let remembered = is_detached
+        .then(|| remembered_worktree_branch(repo, worktree))
+        .flatten();
+    let (reference, label_id) = remembered
+        .or_else(|| head_reference.map(|reference| (reference, id)))
+        .map_or((None, id), |(reference, id)| (Some(reference), id));
     let name = match &reference {
         Some(reference) => reference.shorten().to_owned(),
         None => match detached_name {
@@ -1341,12 +1352,51 @@ fn add_worktree_checkout(
     };
     out.push(WorktreeCheckout {
         id,
+        label_id,
         name,
         reference,
         is_current,
+        is_detached,
     });
 }
 
+fn remembered_worktree_branch(repo: &gix::Repository, worktree: &BStr) -> Option<(gix::refs::FullName, ObjectId)> {
+    let mut pin = match repo.try_find_reference(HEAD_PIN_NAME.as_bstr()) {
+        Ok(Some(pin)) => pin,
+        Ok(None) => return None,
+        Err(err) => {
+            tracing::warn!(%worktree, error = %err, "ignoring unreadable worktree HEAD pin");
+            return None;
+        }
+    };
+    let Some(reference) = pin.target().try_name().map(ToOwned::to_owned) else {
+        tracing::warn!(%worktree, "ignoring direct worktree HEAD pin");
+        return None;
+    };
+    if !reference.as_bstr().starts_with(b"refs/heads/") {
+        tracing::warn!(%worktree, name = %reference, "ignoring non-branch worktree HEAD pin");
+        return None;
+    }
+    let id = match pin.peel_to_id() {
+        Ok(id) => id.detach(),
+        Err(err) => {
+            tracing::warn!(%worktree, name = %reference, error = %err, "ignoring unresolved worktree HEAD pin");
+            return None;
+        }
+    };
+    match repo.find_header(id) {
+        Ok(header) if header.kind() == gix::object::Kind::Commit => Some((reference, id)),
+        Ok(_) => {
+            tracing::warn!(%worktree, name = %reference, "ignoring worktree HEAD pin with a non-commit target");
+            None
+        }
+        Err(err) => {
+            tracing::warn!(%worktree, name = %reference, error = %err, "ignoring unreadable worktree HEAD pin target");
+            None
+        }
+    }
+}
+
 fn worktree_basename(path: &std::path::Path) -> Option<BString> {
     path.file_name()
         .and_then(|name| gix::path::os_str_into_bstr(name).ok())
@@ -1742,13 +1792,12 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             continue;
         };
         let id = id.detach();
-        if worktrees
-            .iter()
-            .any(|worktree| worktree.is_current && worktree.id == id && worktree.reference.as_ref() == Some(&full_name))
-        {
+        if worktrees.iter().any(|worktree| {
+            worktree.is_current && worktree.label_id == id && worktree.reference.as_ref() == Some(&full_name)
+        }) {
             kind = DecorationKind::CurrentWorktreeBranch;
         } else if worktrees.iter().any(|worktree| {
-            !worktree.is_current && worktree.id == id && worktree.reference.as_ref() == Some(&full_name)
+            !worktree.is_current && worktree.label_id == id && worktree.reference.as_ref() == Some(&full_name)
         }) {
             kind = DecorationKind::WorktreeBranch;
         }
@@ -1775,13 +1824,14 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         }
         out.entry(id).or_default().push(Decoration { name, kind });
     }
-    for worktree in worktrees.iter().filter(|worktree| !worktree.is_current) {
-        let kind = if worktree.reference.is_some() {
-            DecorationKind::WorktreeBranch
-        } else {
-            DecorationKind::WorktreeDetached
+    for worktree in worktrees.iter().filter(|worktree| worktree.reference.is_none()) {
+        let kind = match (worktree.is_current, worktree.is_detached) {
+            (true, true) => DecorationKind::CurrentWorktreeDetached,
+            (true, false) => DecorationKind::CurrentWorktreeBranch,
+            (false, true) => DecorationKind::WorktreeDetached,
+            (false, false) => DecorationKind::WorktreeBranch,
         };
-        let decorations = out.entry(worktree.id).or_default();
+        let decorations = out.entry(worktree.label_id).or_default();
         if !decorations
             .iter()
             .any(|decoration| decoration.kind == kind && decoration.name == worktree.name)
@@ -2094,8 +2144,10 @@ mod tests {
         let worktrees = worktree_checkouts(&repo);
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == main
+                && worktree.label_id == main
                 && worktree.name == "main"
                 && worktree.is_current
+                && !worktree.is_detached
                 && worktree
                     .reference
                     .as_ref()
@@ -2103,8 +2155,10 @@ mod tests {
         }));
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == topic
+                && worktree.label_id == topic
                 && worktree.name == "topic"
                 && !worktree.is_current
+                && !worktree.is_detached
                 && worktree
                     .reference
                     .as_ref()
@@ -2112,9 +2166,11 @@ mod tests {
         }));
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == root
+                && worktree.label_id == root
                 && worktree.name == "detached-wt"
                 && worktree.reference.is_none()
                 && !worktree.is_current
+                && worktree.is_detached
         }));
         assert_eq!(worktrees.len(), 3, "the malformed worktree is ignored");
 
@@ -2181,14 +2237,43 @@ mod tests {
             .find(|worktree| worktree.is_current)
             .expect("the current detached worktree is discovered");
         assert!(current.reference.is_none());
+        assert!(current.is_detached);
+        assert_eq!(current.label_id, current.id);
         let detached_decorations = decorations(&detached_repo, &[], &detached_worktrees)?;
+        assert!(detached_decorations.get(&current.id).is_some_and(|decorations| {
+            decorations.iter().any(|decoration| {
+                decoration.kind == DecorationKind::CurrentWorktreeDetached && decoration.name == current.name
+            })
+        }));
+
+        let symbolic = Command::new("git")
+            .current_dir(&linked_path)
+            .args(["symbolic-ref", "refs/worktree/tix/pins/HEAD", "refs/heads/topic"])
+            .status()?;
+        assert!(symbolic.success(), "git remembers the detached worktree's branch");
+        let remembered_repo = crate::test_repository::open(&linked_path)?;
+        let remembered_worktrees = worktree_checkouts(&remembered_repo);
+        let current = remembered_worktrees
+            .iter()
+            .find(|worktree| worktree.is_current)
+            .expect("the remembered detached worktree is discovered");
+        assert_ne!(current.id, topic, "the worktree remains detached away from its branch");
+        assert_eq!(current.label_id, topic, "the label follows the remembered branch tip");
+        assert_eq!(current.name, "topic");
+        assert!(current.is_detached);
         assert!(
-            !detached_decorations
-                .get(&current.id)
-                .is_some_and(|decorations| decorations.iter().any(|decoration| {
-                    decoration.kind == DecorationKind::WorktreeDetached && decoration.name == current.name
-                }))
+            current
+                .reference
+                .as_ref()
+                .is_some_and(|name| name.as_bstr() == b"refs/heads/topic")
         );
+        let remembered_pins = applicable_pins(&remembered_repo)?;
+        let remembered_decorations = decorations(&remembered_repo, &remembered_pins, &remembered_worktrees)?;
+        assert!(remembered_decorations.get(&topic).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::HeadPinBranch && decoration.name == "topic")
+        }));
         Ok(())
     }
 
@@ -2531,8 +2616,14 @@ mod tests {
 
     #[test]
     fn tree_revisions_cover_normal_refs_and_optionally_tags() -> gix_testtools::Result {
-        let fixture = fixture()?;
-        let repo = crate::test_repository::open(&fixture)?;
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        repo.reference(
+            "refs/worktree/tix/pins/test",
+            repo.head_id()?,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test tree revisions",
+        )?;
         let names = |include_tags| {
             tree_revisions(&repo, include_tags).map(|revisions| {
                 revisions
@@ -2556,6 +2647,12 @@ mod tests {
             without_tags.iter().all(|name| !name.starts_with("refs/tags/")),
             "tagless rendering does not traverse tag-only history"
         );
+        assert!(
+            with_tags
+                .iter()
+                .all(|name| !name.starts_with("refs/worktree/tix/pins/")),
+            "ordinary pins never become tree traversal tips"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index f2f2a77b6fb..db311b46e64 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1571,40 +1571,6 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
-                    tree::Input::Pin { id, include_tags } => {
-                        match open_repository(&repository_path, repository_is_bare, false) {
-                            Ok(repository) => match edit::time_travel::create_tree_pin(&repository, id, include_tags) {
-                                Ok((pin, created)) => {
-                                    let label = edit::time_travel::pin_label(&pin);
-                                    tree.leave_message(if created {
-                                        format!("created {label}")
-                                    } else {
-                                        format!("already pinned as {label}")
-                                    });
-                                    refresh_pending |= created;
-                                }
-                                Err(err) => tree.leave_message(format!("pin: {err:#}")),
-                            },
-                            Err(err) => tree.leave_message(format!("pin: {err:#}")),
-                        }
-                        dirty = true;
-                        urgent = true;
-                        continue;
-                    }
-                    tree::Input::Unpin { id, fallback } => {
-                        match edit::time_travel::remove_pins(&repository_path, repository_is_bare, id) {
-                            Ok(0) => tree.leave_message("no pins removed"),
-                            Ok(count) => {
-                                tree.leave_message(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
-                                tree.select_after_reference_deletion(fallback);
-                                refresh_pending = true;
-                            }
-                            Err(err) => tree.leave_message(format!("unpin: {err:#}")),
-                        }
-                        dirty = true;
-                        urgent = true;
-                        continue;
-                    }
                     tree::Input::Quit => return Ok(None),
                 },
                 TerminalEvent::Mouse(mouse) if tree.handle_mouse(mouse.kind, 1) => {
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
index 64638ad0d3c..ddadd462e9a 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/tree.rs
@@ -46,8 +46,7 @@ struct Node {
     decorations: Vec<Decoration>,
     is_head: bool,
     is_anchor: bool,
-    is_pinned: bool,
-    can_pin: bool,
+    is_detached_worktree: bool,
     raw_tip: bool,
     sort_key: String,
 }
@@ -129,14 +128,6 @@ pub(crate) enum Input {
         groups: Vec<RemoteDeletion>,
         fallback: SelectionFallback,
     },
-    Pin {
-        id: ObjectId,
-        include_tags: bool,
-    },
-    Unpin {
-        id: ObjectId,
-        fallback: SelectionFallback,
-    },
     Quit,
 }
 
@@ -314,30 +305,6 @@ impl Tree {
             self.toggle_count_anchor();
             return Input::Handled;
         }
-        if key.code == KeyCode::Char('p') && key.modifiers.is_empty() {
-            let Some(node) = self
-                .selected
-                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
-            else {
-                return Input::Handled;
-            };
-            if node.is_pinned {
-                return Input::Unpin {
-                    id: node.id,
-                    fallback: self
-                        .reference_deletion_fallback()
-                        .expect("a selected pin has a deletion fallback"),
-                };
-            }
-            if !node.can_pin {
-                self.message = Some("no reference at the selected node".into());
-                return Input::Handled;
-            }
-            return Input::Pin {
-                id: node.id,
-                include_tags: !self.hide_tags,
-            };
-        }
         if key.code == KeyCode::Char('G')
             || key.code == KeyCode::Char('g') && key.modifiers.contains(KeyModifiers::SHIFT)
         {
@@ -514,21 +481,8 @@ impl Tree {
                 || "Space counts:auto".into(),
                 |id| format!("Space counts:{}", self.node_label(id)),
             );
-            let pin = self
-                .selected
-                .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
-                .and_then(|node| {
-                    if node.is_pinned {
-                        Some(" · p unpin")
-                    } else if node.can_pin {
-                        Some(" · p pin")
-                    } else {
-                        None
-                    }
-                })
-                .unwrap_or_default();
             format!(
-                "tree · {motion} · {counts}{pin} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
+                "tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
             )
         };
         frame.render_widget(
@@ -751,8 +705,7 @@ impl Overview {
         let mut labels = HashMap::<CommitIndex, Vec<Decoration>>::new();
         let mut heads = HashSet::new();
         let mut anchors = HashSet::new();
-        let mut pinned = HashSet::new();
-        let mut pinnable = HashSet::new();
+        let mut detached_worktrees = HashSet::new();
         for (id, decorations) in decorations {
             let Some(index) = graph.index(*id) else { continue };
             for decoration in decorations {
@@ -762,27 +715,30 @@ impl Overview {
                 if decoration.kind == DecorationKind::Head {
                     heads.insert(index);
                     anchors.insert(index);
-                    pinnable.insert(index);
                 } else if decoration.kind == DecorationKind::Pin {
-                    pinned.insert(index);
-                    anchors.insert(index);
+                    continue;
                 } else if decoration.kind != DecorationKind::Special {
                     labels.entry(index).or_default().push(decoration.clone());
                     anchors.insert(index);
-                    if decoration.kind != DecorationKind::Stash {
-                        pinnable.insert(index);
-                    }
                 }
             }
         }
+        for worktree in refs.worktrees.iter().filter(|worktree| worktree.is_detached) {
+            let Some(index) = graph.index(worktree.id) else {
+                continue;
+            };
+            detached_worktrees.insert(index);
+            anchors.insert(index);
+        }
+        let pin_tips: HashSet<_> = refs.pins.iter().map(|pin| pin.id).collect();
         let raw: HashSet<_> = refs
             .view_tips
             .iter()
             .chain(&refs.hidden_tips)
+            .filter(|id| !pin_tips.contains(*id))
             .filter_map(|id| graph.index(*id))
             .inspect(|index| {
                 anchors.insert(*index);
-                pinnable.insert(*index);
             })
             .collect();
         if anchors.is_empty() {
@@ -849,8 +805,7 @@ impl Overview {
                     decorations,
                     is_head: heads.contains(&commit),
                     is_anchor: anchors.contains(&commit),
-                    is_pinned: pinned.contains(&commit),
-                    can_pin: pinnable.contains(&commit),
+                    is_detached_worktree: detached_worktrees.contains(&commit),
                     raw_tip: raw.contains(&commit),
                     sort_key,
                 }
@@ -1249,7 +1204,7 @@ fn rail_label(node: &Node, count: Option<usize>) -> String {
         out.push(' ');
     }
     out.push_str(&suffix);
-    if node.is_pinned {
+    if node.is_detached_worktree {
         if !out.is_empty() {
             out.push(' ');
         }
@@ -1262,7 +1217,17 @@ fn node_label(node: &Node) -> String {
     let labels: Vec<_> = node
         .decorations
         .iter()
-        .map(|decoration| decoration.name.to_str_lossy())
+        .map(|decoration| {
+            let name = decoration.name.to_str_lossy();
+            match decoration.kind {
+                DecorationKind::CurrentWorktreeBranch | DecorationKind::CurrentWorktreeDetached => {
+                    format!("@{name}")
+                }
+                DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => format!("{name}@"),
+                DecorationKind::HeadPinBranch => format!("★{name}"),
+                _ => name.into_owned(),
+            }
+        })
         .collect();
     if !labels.is_empty() {
         labels.join(", ")
@@ -1857,8 +1822,8 @@ mod tests {
     }
 
     #[test]
-    fn pins_are_markers_and_p_toggles_only_reference_nodes() {
-        let (graph, refs, mut decorations) = fixture();
+    fn detached_worktrees_are_pin_markers_while_ordinary_pins_and_p_are_hidden() {
+        let (graph, mut refs, mut decorations) = fixture();
         *decorations.get_mut(&id(5)).expect("topic is decorated") = vec![
             Decoration {
                 name: "pin:first".into(),
@@ -1869,46 +1834,41 @@ mod tests {
                 kind: DecorationKind::Pin,
             },
         ];
+        refs.pins.push(crate::history::Pin {
+            name: "refs/worktree/tix/pins/first".try_into().expect("valid"),
+            target: gix::refs::Target::Object(id(5)),
+            id: id(5),
+        });
+        refs.worktrees.push(crate::history::WorktreeCheckout {
+            id: id(3),
+            label_id: id(6),
+            name: "main".into(),
+            reference: Some("refs/heads/main".try_into().expect("valid")),
+            is_current: true,
+            is_detached: true,
+        });
+        decorations.get_mut(&id(6)).expect("main is decorated")[0].kind = DecorationKind::HeadPinBranch;
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        let topic =
-            tree.overview.as_ref().expect("overview exists").by_commit[&graph.index(id(5)).expect("topic exists")];
-        tree.selected = Some(topic);
-
-        assert!(matches!(
-            tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
-            Input::Unpin { id: selected, .. } if selected == id(5)
-        ));
         let overview = tree.overview.as_ref().expect("overview exists");
         assert!(
-            overview.nodes[topic].decorations.is_empty(),
-            "pin-only tips need no label"
+            !overview.nodes.iter().any(|node| node.id == id(5)),
+            "ordinary pin-only tips are absent"
         );
         let unicode = render_overview(overview, true);
         let ascii = render_overview(overview, false);
-        assert_eq!(unicode.matches('📌').count(), 1, "multiple pins share one marker");
-        assert!(ascii.contains("[pin]"), "ASCII diagnostics retain the pin marker");
-        assert!(!unicode.contains("pin:"), "internal pin names are hidden");
-
-        let main = overview.by_commit[&graph.index(id(6)).expect("main exists")];
-        tree.selected = Some(main);
-        assert_eq!(
-            tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
-            Input::Pin {
-                id: id(6),
-                include_tags: true,
-            },
-            "an unpinned reference offers pin creation"
+        assert_eq!(unicode.matches('📌').count(), 1, "detached HEAD has one marker");
+        assert!(
+            unicode.contains("★main"),
+            "the remembered branch stays at its actual tip"
         );
-        let fork =
-            tree.overview.as_ref().expect("overview exists").by_commit[&graph.index(id(2)).expect("fork exists")];
-        tree.selected = Some(fork);
+        assert!(ascii.contains("[pin]"), "ASCII diagnostics retain detached state");
+        assert!(!unicode.contains("pin:"), "ordinary pin names remain hidden");
         assert_eq!(
             tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
             Input::Handled,
-            "structural-only nodes cannot be pinned"
+            "the tree has no pin action"
         );
-        assert_eq!(tree.message.as_deref(), Some("no reference at the selected node"));
     }
 
     #[test]
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 1c480e51dc3..b47da580725 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1753,7 +1753,9 @@ fn metadata_line<'a>(
                 selected
                     && matches!(
                         decoration.kind,
-                        DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
+                        DecorationKind::WorktreeBranch
+                            | DecorationKind::WorktreeDetached
+                            | DecorationKind::CurrentWorktreeDetached
                     )
             }
         })
@@ -1773,7 +1775,10 @@ fn metadata_line<'a>(
                     format!("{name}@").into()
                 } else if decoration.kind == DecorationKind::HeadPinBranch {
                     format!("★{name}").into()
-                } else if decoration.kind == DecorationKind::CurrentWorktreeBranch {
+                } else if matches!(
+                    decoration.kind,
+                    DecorationKind::CurrentWorktreeBranch | DecorationKind::CurrentWorktreeDetached
+                ) {
                     format!("@{name}").into()
                 } else {
                     name
@@ -1951,7 +1956,9 @@ pub(crate) fn decoration_style(kind: DecorationKind) -> Style {
         DecorationKind::HeadPinBranch => Style::default().fg(Color::Cyan),
         DecorationKind::Stash => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
         DecorationKind::Review => Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
-        DecorationKind::CurrentWorktreeBranch => Style::default().fg(Color::Cyan),
+        DecorationKind::CurrentWorktreeBranch | DecorationKind::CurrentWorktreeDetached => {
+            Style::default().fg(Color::Cyan)
+        }
         DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached => Style::default().fg(Color::LightBlue),
         DecorationKind::Local => Style::default().fg(Color::Cyan),
         DecorationKind::Remote => Style::default().fg(Color::Yellow),

From 9c3a8a70f6688811f2001674bbc48344124e2a47 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 20:44:51 +0200
Subject: [PATCH 160/282] feat: move remote tree deletion to e r

Keep remote-reference deletion inside the tree node edit prefix alongside local branch deletion. After e resolves uniquely reverse-mapped remote references, r immediately submits the grouped remote deletions and the footer advertises that action.

Remove the Shift-D shortcut instead of retaining a compatibility alias, and update the behavioral specification and key-path regression test to match.
---
 gix-tix/spec.md     |  2 +-
 gix-tix/src/tree.rs | 11 ++++-------
 2 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 82d17e001d3..311a237d94d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -225,7 +225,7 @@ without trading responsiveness for metadata that is not visible.
   component. Shift-modified directions pan the tree viewport; mouse and the existing
   Ctrl/Page keys scroll without moving the tree cursor.
 - `e` opens node-level reference editing. `d` deletes every eligible local branch
-  immediately. `Shift-D` is offered only when selected remote-tracking references
+  immediately. `e r` is offered only when selected remote-tracking references
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
   remote reference, grouped into one Git push per remote. Pushes continue after
   individual failures and run with the terminal suspended for output and authentication.
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/tree.rs
index ddadd462e9a..22ff204c768 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/tree.rs
@@ -259,10 +259,7 @@ impl Tree {
         }
         if self.edit_expanded {
             self.edit_expanded = false;
-            if (key.code == KeyCode::Char('D')
-                || key.code == KeyCode::Char('d') && key.modifiers.contains(KeyModifiers::SHIFT))
-                && !self.remote_deletions.is_empty()
-            {
+            if key.code == KeyCode::Char('r') && key.modifiers.is_empty() && !self.remote_deletions.is_empty() {
                 return Input::DeleteRemoteReferences {
                     groups: std::mem::take(&mut self.remote_deletions),
                     fallback: self
@@ -465,7 +462,7 @@ impl Tree {
                 }
                 if !self.remote_deletions.is_empty() {
                     actions.push(format!(
-                        "D delete on remote {}",
+                        "r delete on remote {}",
                         short_remote_deletion_list(&self.remote_deletions)
                     ));
                 }
@@ -1568,7 +1565,7 @@ mod tests {
     }
 
     #[test]
-    fn shift_d_deletes_every_resolved_remote_reference_without_confirmation() {
+    fn e_r_deletes_every_resolved_remote_reference_without_confirmation() {
         let (graph, refs, mut decorations) = fixture();
         decorations
             .get_mut(&id(6))
@@ -1594,7 +1591,7 @@ mod tests {
         tree.set_remote_deletions(groups.clone());
 
         assert!(matches!(
-            tree.handle_key(KeyEvent::new(KeyCode::Char('D'), KeyModifiers::SHIFT)),
+            tree.handle_key(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE)),
             Input::DeleteRemoteReferences { groups: submitted, .. } if submitted == groups
         ));
         assert!(!tree.edit_expanded);

From 9363b62a8b12efa008f049d7c62fea29b103a80d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:03:30 +0200
Subject: [PATCH 161/282] rename!: call the tix reference view ref-tree

Rename the experimental reference projection to ref-tree across the command line, terminal UI, specification, module, actions, helpers, and tests. The diagnostic command is now tix ref-tree, while plain tree remains reserved for Git tree objects and diffs.

Do not retain a command alias: the old word is parsed only as an ordinary revision, preserving the existing ability to inspect a branch named tree.
---
 gix-tix/spec.md                      | 35 ++++++-------
 gix-tix/src/app.rs                   |  6 +--
 gix-tix/src/command.rs               | 53 +++++++++++---------
 gix-tix/src/history.rs               |  6 +--
 gix-tix/src/lib.rs                   | 74 ++++++++++++++--------------
 gix-tix/src/{tree.rs => ref_tree.rs} | 28 +++++------
 gix-tix/src/ui.rs                    |  8 +--
 7 files changed, 110 insertions(+), 100 deletions(-)
 rename gix-tix/src/{tree.rs => ref_tree.rs} (98%)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 311a237d94d..2da6738be48 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -187,12 +187,13 @@ without trading responsiveness for metadata that is not visible.
   can be made, and cache completed results. They must never reopen a repository
   merely because selection moved.
 
-### Tree overviews
+### Ref-tree overviews
 
-- After traversal completes, `t` toggles history and a rounded rail tree.
-  `Escape` also returns directly to history. The tree cursor and viewport are
-  independent of the history selection and panes, and the tree provides
-  navigation only. The direct tree action appears in the `?` information group.
+- After traversal completes, `t` toggles history and a rounded rail ref-tree.
+  `Escape` also returns directly to history. The ref-tree cursor and viewport are
+  independent of the history selection and panes, and the ref-tree provides
+  navigation only. The direct ref-tree action appears in the `?` information group.
+  “Tree” without the `ref-` prefix refers to Git tree objects and tree diffs.
 - The overview uses normal references and raw revision tips already present in
   the completed graph, including traversed hidden history; it never causes more
   repository traversal. Special refs are excluded. First-parent paths form a
@@ -202,7 +203,7 @@ without trading responsiveness for metadata that is not visible.
   projection.
 - The component containing `HEAD` sorts first. Children sort by their smallest
   reference label and then object ID. Initial selection is `HEAD`, then a raw
-  tip, then the first node; refresh and re-entry preserve the tree cursor when
+  tip, then the first node; refresh and re-entry preserve the ref-tree cursor when
   its commit remains available.
 - The selected node shows the exact number of commits reachable
   through all parents. Other reference and raw-tip nodes show the number reachable
@@ -213,7 +214,7 @@ without trading responsiveness for metadata that is not visible.
   dimmed, and exclusive history remains normal. A non-selectable `●` splits a
   contracted edge where it becomes reachable. Exact exclusive counts are computed
   and cached only for reference rows visible in the viewport.
-- The tree orders tips above roots and renders one retained or boundary
+- The ref-tree orders tips above roots and renders one retained or boundary
   node per row. Rounded ancestry lanes precede aligned counts and labels; their
   disk is the node marker, so counts do not repeat it.
 - Rendering clips lanes and node labels to the viewport.
@@ -221,9 +222,9 @@ without trading responsiveness for metadata that is not visible.
   Nearest movement chooses the closest node in the requested screen direction.
   Topological Up moves toward leaves, Down toward roots, and Left/Right chooses
   a remembered child; `i/n` and an emphasized edge show the choice.
-- `g` selects the top tree node, and `Shift-G` selects the root of the current
-  component. Shift-modified directions pan the tree viewport; mouse and the existing
-  Ctrl/Page keys scroll without moving the tree cursor.
+- `g` selects the top ref-tree node, and `Shift-G` selects the root of the current
+  component. Shift-modified directions pan the ref-tree viewport; mouse and the existing
+  Ctrl/Page keys scroll without moving the ref-tree cursor.
 - `e` opens node-level reference editing. `d` deletes every eligible local branch
   immediately. `e r` is offered only when selected remote-tracking references
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
@@ -232,21 +233,21 @@ without trading responsiveness for metadata that is not visible.
 - Worktree branch labels keep the history view's `@branch`, `branch@`, and
   `★branch` forms at the branch's actual tip. Every detached worktree checkout is
   additionally shown with one `📌`; ordinary tix pins neither anchor nor decorate
-  the tree. A detached worktree without a usable remembered branch falls back to
+  the ref-tree. A detached worktree without a usable remembered branch falls back to
   its checkout directory basename.
 - After deleting selected local or remote references, refresh keeps the commit
-  when it remains a tree node, otherwise selects the next surviving node row or
+  when it remains a ref-tree node, otherwise selects the next surviving node row or
   the nearest previous row when nothing below survives.
 
-### Tree diagnostics
+### Ref-tree diagnostics
 
-- `tix tree` prints the entire reference projection to standard output without
+- `tix ref-tree` prints the entire reference projection to standard output without
   terminal colors, selection state, counts, or viewport clipping. Detached
   worktrees render as `[pin]` in ASCII output and `📌` with `--unicode`. It traverses
   all normal references by default; positional revisions scope traversal.
 - `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
-  corresponding tree inputs. Output uses ASCII lines and `o` nodes by default;
-  `--unicode` uses the interactive tree's rounded line and node glyphs.
+  corresponding ref-tree inputs. Output uses ASCII lines and `o` nodes by default;
+  `--unicode` uses the interactive ref-tree's rounded line and node glyphs.
 
 ## Interaction
 
@@ -261,7 +262,7 @@ without trading responsiveness for metadata that is not visible.
 | `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. Its actions remain direct shortcuts. |
-| `t` | Toggle the rounded tree overview. |
+| `t` | Toggle the rounded ref-tree overview. |
 | `[` | Toggle graph/metadata alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Toggle committer dates. |
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 8ad931b8904..353340b9c6a 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -288,7 +288,7 @@ pub(crate) enum Action {
     Refresh,
     ToggleHidden,
     ToggleHistoryDisplay,
-    ToggleTree,
+    ToggleRefTree,
     ToggleEdit,
     ToggleInformation,
     ToggleAlign,
@@ -846,7 +846,7 @@ impl App {
                 | Action::ToggleAlign
                 | Action::ToggleCommit
                 | Action::ToggleChanges
-                | Action::ToggleTree
+                | Action::ToggleRefTree
         ) {
             self.information_expanded = false;
         }
@@ -3495,7 +3495,7 @@ mod tests {
             Action::ToggleCommit,
             Action::ToggleChanges,
             Action::VerifySignatures,
-            Action::ToggleTree,
+            Action::ToggleRefTree,
         ] {
             app.update(action);
             assert!(app.information_expanded, "information actions keep the group open");
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index e30bf6a1449..5ce7dd95f42 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -32,8 +32,8 @@ pub struct Platform {
 
 #[derive(Debug, clap::Subcommand)]
 enum Command {
-    /// Print the complete reference tree without opening the terminal UI.
-    Tree(Tree),
+    /// Print the complete ref-tree without opening the terminal UI.
+    RefTree(RefTree),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend,
     /// Move the changes introduced by HEAD into the worktree.
@@ -52,7 +52,7 @@ enum Command {
 }
 
 #[derive(Debug, clap::Args)]
-struct Tree {
+struct RefTree {
     /// Print help.
     #[arg(long, action = clap::ArgAction::HelpLong)]
     help: Option<bool>,
@@ -65,7 +65,7 @@ struct Tree {
     /// Hide this revision and every commit reachable from it.
     #[arg(long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
-    /// Use the tree view's Unicode line and node glyphs instead of ASCII.
+    /// Use the ref-tree view's Unicode line and node glyphs instead of ASCII.
     #[arg(long)]
     unicode: bool,
     /// Revisions to traverse instead of all normal references.
@@ -122,12 +122,12 @@ impl Platform {
 
         let repository = repository.to_thread_local();
         let command = match command {
-            Command::Tree(args) => return print_tree(&repository, args),
+            Command::RefTree(args) => return print_ref_tree(&repository, args),
             command => command,
         };
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         match command {
-            Command::Tree(_) => unreachable!("tree commands return before logging"),
+            Command::RefTree(_) => unreachable!("ref-tree commands return before logging"),
             Command::Amend => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?;
@@ -149,13 +149,13 @@ impl Platform {
     }
 }
 
-fn print_tree(repository: &gix::Repository, args: Tree) -> Result<()> {
+fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
     let revisions = if args.revisions.is_empty() {
-        crate::history::tree_revisions(repository, !args.no_tags)?
+        crate::history::ref_tree_revisions(repository, !args.no_tags)?
     } else {
         args.revisions
     };
-    let rendered = crate::tree::render_full(
+    let rendered = crate::ref_tree::render_full(
         repository,
         &revisions,
         &args.hide,
@@ -163,7 +163,8 @@ fn print_tree(repository: &gix::Repository, args: Tree) -> Result<()> {
         !args.no_tags,
         args.unicode,
     )?;
-    std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes()).context("could not write tree")?;
+    std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes())
+        .context("could not write ref-tree")?;
     Ok(())
 }
 
@@ -283,9 +284,9 @@ mod tests {
         );
         assert!(cli.platform.command.is_none(), "omitting a command launches the TUI");
 
-        let tree = Cli::try_parse_from([
+        let ref_tree = Cli::try_parse_from([
             "tix",
-            "tree",
+            "ref-tree",
             "--no-tags",
             "--worktrees",
             "--hide",
@@ -294,23 +295,31 @@ mod tests {
             "main",
             "topic",
         ])
-        .expect("tree options parse")
+        .expect("ref-tree options parse")
         .platform
         .command;
-        let Some(Command::Tree(tree)) = tree else {
-            panic!("tree was expected")
+        let Some(Command::RefTree(ref_tree)) = ref_tree else {
+            panic!("ref-tree was expected")
         };
-        assert!(tree.help.is_none());
-        assert!(tree.no_tags);
-        assert!(tree.worktrees);
-        assert_eq!(tree.hide, ["private"]);
-        assert!(tree.unicode);
-        assert_eq!(tree.revisions, ["main", "topic"]);
+        assert!(ref_tree.help.is_none());
+        assert!(ref_tree.no_tags);
+        assert!(ref_tree.worktrees);
+        assert_eq!(ref_tree.hide, ["private"]);
+        assert!(ref_tree.unicode);
+        assert_eq!(ref_tree.revisions, ["main", "topic"]);
 
         assert!(
-            Cli::try_parse_from(["tix", "tree", "--layout", "rail"]).is_err(),
+            Cli::try_parse_from(["tix", "ref-tree", "--layout", "rail"]).is_err(),
             "the removed layout selector is rejected"
         );
+        let old_name = Cli::try_parse_from(["tix", "tree"])
+            .expect("tree remains a valid revision")
+            .platform;
+        assert!(
+            old_name.command.is_none(),
+            "the old tree command has no compatibility alias"
+        );
+        assert_eq!(old_name.revisions, ["tree"]);
 
         assert!(matches!(
             Cli::try_parse_from(["tix", "amend"])
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index e87ae4c9b05..9a5b6dee1ca 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1201,7 +1201,7 @@ pub(crate) fn snapshot(
     snapshot_ignoring_pin(repo, revisions, hidden, include_worktrees, None)
 }
 
-pub(crate) fn tree_revisions(repo: &gix::Repository, include_tags: bool) -> Result<Vec<OsString>> {
+pub(crate) fn ref_tree_revisions(repo: &gix::Repository, include_tags: bool) -> Result<Vec<OsString>> {
     let mut out = Vec::new();
     for reference in repo
         .references()
@@ -2615,7 +2615,7 @@ mod tests {
     }
 
     #[test]
-    fn tree_revisions_cover_normal_refs_and_optionally_tags() -> gix_testtools::Result {
+    fn ref_tree_revisions_cover_normal_refs_and_optionally_tags() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repo = crate::test_repository::open(fixture.path())?;
         repo.reference(
@@ -2625,7 +2625,7 @@ mod tests {
             "test tree revisions",
         )?;
         let names = |include_tags| {
-            tree_revisions(&repo, include_tags).map(|revisions| {
+            ref_tree_revisions(&repo, include_tags).map(|revisions| {
                 revisions
                     .into_iter()
                     .map(|revision| revision.to_string_lossy().into_owned())
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index db311b46e64..413e8e3e2db 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -8,9 +8,9 @@ pub mod command;
 mod edit;
 mod history;
 mod logging;
+mod ref_tree;
 #[cfg(test)]
 mod test_repository;
-mod tree;
 mod ui;
 
 use std::{
@@ -950,7 +950,7 @@ fn event_loop(
         }
     }
     let mut decorations = Decorations::new();
-    let mut tree = tree::Tree::default();
+    let mut ref_tree = ref_tree::Tree::default();
     let mut motion = MotionState::default();
     let mut filesystem_responses = logging::FilesystemResponses::default();
     let mut focused = true;
@@ -969,7 +969,7 @@ fn event_loop(
         &mut line_diff_pool,
         &mut motion,
         focused,
-        &mut tree,
+        &mut ref_tree,
         &mut filesystem_responses,
     )?;
     let mut last_draw = Instant::now();
@@ -1251,7 +1251,7 @@ fn event_loop(
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     let result = result?;
-                    tree.rebuild(&graph, &result.refs, &result.decorations);
+                    ref_tree.rebuild(&graph, &result.refs, &result.decorations);
                     history_graph = Some(graph);
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
@@ -1377,7 +1377,7 @@ fn event_loop(
                 &mut line_diff_pool,
                 &mut motion,
                 focused,
-                &mut tree,
+                &mut ref_tree,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1416,7 +1416,7 @@ fn event_loop(
                     history_finished = true;
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
-                    tree.rebuild(&graph, &ref_snapshot, &decorations);
+                    ref_tree.rebuild(&graph, &ref_snapshot, &decorations);
                     history_graph = Some(graph);
                     update_hidden_branch_updates(&mut app, history_graph.as_ref(), &ref_snapshot);
                     selection_relation = None;
@@ -1447,7 +1447,7 @@ fn event_loop(
                 &mut line_diff_pool,
                 &mut motion,
                 focused,
-                &mut tree,
+                &mut ref_tree,
                 &mut filesystem_responses,
             )?;
             last_draw = Instant::now();
@@ -1487,26 +1487,26 @@ fn event_loop(
         let Some(terminal_event) = terminal_event else {
             continue;
         };
-        if tree.is_active() {
+        if ref_tree.is_active() {
             match &terminal_event {
-                TerminalEvent::Key(key) if key.kind != KeyEventKind::Release => match tree.handle_key(*key) {
-                    tree::Input::Handled => {
+                TerminalEvent::Key(key) if key.kind != KeyEventKind::Release => match ref_tree.handle_key(*key) {
+                    ref_tree::Input::Handled => {
                         dirty = true;
                         urgent = true;
                         continue;
                     }
-                    tree::Input::ResolveRemoteReferences(names) => {
+                    ref_tree::Input::ResolveRemoteReferences(names) => {
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(repository) => {
-                                tree.set_remote_deletions(tree::resolve_remote_deletions(&repository, names));
+                                ref_tree.set_remote_deletions(ref_tree::resolve_remote_deletions(&repository, names));
                             }
-                            Err(err) => tree.leave_message(format!("remote edit: {err:#}")),
+                            Err(err) => ref_tree.leave_message(format!("remote edit: {err:#}")),
                         }
                         dirty = true;
                         urgent = true;
                         continue;
                     }
-                    tree::Input::DeleteLocalBranches { names, fallback } => {
+                    ref_tree::Input::DeleteLocalBranches { names, fallback } => {
                         let label = {
                             let names = names
                                 .iter()
@@ -1522,34 +1522,34 @@ fn event_loop(
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(mut repository) => match repository.delete_local_branches(names) {
                                 Ok(()) => {
-                                    tree.leave_message(format!("deleted {label}"));
+                                    ref_tree.leave_message(format!("deleted {label}"));
                                     deleted = true;
                                     refresh_pending = true;
                                 }
                                 Err(err) => {
                                     let changed =
                                         matches!(&err, gix::repository::branch::delete::Error::Cleanup { .. });
-                                    tree.leave_message(format!("delete {label}: {err}"));
+                                    ref_tree.leave_message(format!("delete {label}: {err}"));
                                     deleted = changed;
                                     refresh_pending |= changed;
                                 }
                             },
-                            Err(err) => tree.leave_message(format!("delete {label}: {err:#}")),
+                            Err(err) => ref_tree.leave_message(format!("delete {label}: {err:#}")),
                         }
                         if deleted {
-                            tree.select_after_reference_deletion(fallback);
+                            ref_tree.select_after_reference_deletion(fallback);
                         }
                         dirty = true;
                         urgent = true;
                         continue;
                     }
-                    tree::Input::DeleteRemoteReferences { groups, fallback } => {
+                    ref_tree::Input::DeleteRemoteReferences { groups, fallback } => {
                         match with_suspended_terminal(terminal, enhanced_keyboard, || {
                             Ok(push_remote_deletions(&repository_path, &groups))
                         }) {
                             Ok(outcome) => {
                                 if outcome.deleted != 0 {
-                                    tree.select_after_reference_deletion(fallback);
+                                    ref_tree.select_after_reference_deletion(fallback);
                                     refresh_pending = true;
                                 }
                                 let deleted = format!(
@@ -1557,7 +1557,7 @@ fn event_loop(
                                     outcome.deleted,
                                     if outcome.deleted == 1 { "" } else { "s" }
                                 );
-                                tree.leave_message(if outcome.failures.is_empty() {
+                                ref_tree.leave_message(if outcome.failures.is_empty() {
                                     deleted
                                 } else if outcome.deleted == 0 {
                                     format!("delete on remote: {}", outcome.failures.join("; "))
@@ -1565,15 +1565,15 @@ fn event_loop(
                                     format!("{deleted}; failed: {}", outcome.failures.join("; "))
                                 });
                             }
-                            Err(err) => tree.leave_message(format!("delete on remote: {err:#}")),
+                            Err(err) => ref_tree.leave_message(format!("delete on remote: {err:#}")),
                         }
                         dirty = true;
                         urgent = true;
                         continue;
                     }
-                    tree::Input::Quit => return Ok(None),
+                    ref_tree::Input::Quit => return Ok(None),
                 },
-                TerminalEvent::Mouse(mouse) if tree.handle_mouse(mouse.kind, 1) => {
+                TerminalEvent::Mouse(mouse) if ref_tree.handle_mouse(mouse.kind, 1) => {
                     dirty = true;
                     urgent = true;
                     continue;
@@ -1868,8 +1868,8 @@ fn event_loop(
         let Some(action) = action else {
             continue;
         };
-        if action == Action::ToggleTree {
-            tree.toggle();
+        if action == Action::ToggleRefTree {
+            ref_tree.toggle();
             app.history_display_expanded = false;
             dirty = true;
             urgent = true;
@@ -2783,25 +2783,25 @@ fn draw(
     line_diff_pool: &mut Option<LineDiffPool>,
     motion: &mut MotionState,
     focused: bool,
-    tree: &mut tree::Tree,
+    ref_tree: &mut ref_tree::Tree,
     filesystem_responses: &mut logging::FilesystemResponses,
 ) -> Result<()> {
     let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
     if !history_is_ready_to_draw(app.state, app.rows.len()) {
         return Ok(());
     }
-    if tree.is_active() {
+    if ref_tree.is_active() {
         motion.cancel_pending();
         terminal
             .autoresize()
             .context("could not resize the terminal before drawing")?;
         {
             let mut frame = terminal.get_frame();
-            tree.draw(&mut frame, history_graph.as_ref());
+            ref_tree.draw(&mut frame, history_graph.as_ref());
         }
         terminal
             .apply_buffer_with_cursor(None)
-            .context("could not draw tree overview")?;
+            .context("could not draw ref-tree overview")?;
         filesystem_responses.frame_presented();
         return Ok(());
     }
@@ -3837,7 +3837,7 @@ struct RemoteDeleteOutcome {
     failures: Vec<String>,
 }
 
-fn push_remote_deletions(repository_path: &Path, groups: &[tree::RemoteDeletion]) -> RemoteDeleteOutcome {
+fn push_remote_deletions(repository_path: &Path, groups: &[ref_tree::RemoteDeletion]) -> RemoteDeleteOutcome {
     let mut outcome = RemoteDeleteOutcome {
         deleted: 0,
         failures: Vec::new(),
@@ -4579,7 +4579,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
-        KeyCode::Char('t') => Some(Action::ToggleTree),
+        KeyCode::Char('t') => Some(Action::ToggleRefTree),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
@@ -5577,7 +5577,7 @@ mod tests {
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE)),
-            Some(Action::ToggleTree)
+            Some(Action::ToggleRefTree)
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE)),
@@ -5667,8 +5667,8 @@ mod tests {
         }
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE), false, true),
-            Some(Action::ToggleTree),
-            "the direct tree key remains available while edit is expanded"
+            Some(Action::ToggleRefTree),
+            "the direct ref-tree key remains available while edit is expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE), false, true),
@@ -5732,8 +5732,8 @@ mod tests {
         );
         assert_eq!(
             action_with_shortcut_groups(key, false, false),
-            Some(Action::ToggleTree),
-            "plain t toggles the tree"
+            Some(Action::ToggleRefTree),
+            "plain t toggles the ref-tree"
         );
     }
 
diff --git a/gix-tix/src/tree.rs b/gix-tix/src/ref_tree.rs
similarity index 98%
rename from gix-tix/src/tree.rs
rename to gix-tix/src/ref_tree.rs
index 22ff204c768..708facfc98c 100644
--- a/gix-tix/src/tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -395,7 +395,7 @@ impl Tree {
         let [body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
         frame.render_widget(Clear, frame.area());
         let Some(overview) = self.overview.as_ref() else {
-            frame.render_widget(Paragraph::new("tree overview unavailable"), body);
+            frame.render_widget(Paragraph::new("ref-tree overview unavailable"), body);
             return;
         };
         if self.placed.is_none() {
@@ -454,7 +454,7 @@ impl Tree {
         } else if self.edit_expanded {
             let branches = self.selected_local_branches();
             if branches.is_empty() && self.remote_deletions.is_empty() {
-                "tree · e edit (no actions)".into()
+                "ref-tree · e edit (no actions)".into()
             } else {
                 let mut actions = Vec::new();
                 if !branches.is_empty() {
@@ -466,7 +466,7 @@ impl Tree {
                         short_remote_deletion_list(&self.remote_deletions)
                     ));
                 }
-                format!("tree · e edit ({})", actions.join(" · "))
+                format!("ref-tree · e edit ({})", actions.join(" · "))
             }
         } else {
             let motion = match self.motion {
@@ -479,7 +479,7 @@ impl Tree {
                 |id| format!("Space counts:{}", self.node_label(id)),
             );
             format!(
-                "tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
+                "ref-tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
             )
         };
         frame.render_widget(
@@ -1539,7 +1539,7 @@ mod tests {
         ]);
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        assert!(tree.toggle(), "the tree opens");
+        assert!(tree.toggle(), "the ref-tree opens");
 
         let Input::ResolveRemoteReferences(remote) =
             tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE))
@@ -1673,11 +1673,11 @@ mod tests {
     }
 
     #[test]
-    fn escape_cancels_the_edit_prefix_without_leaving_the_tree() {
+    fn escape_cancels_the_edit_prefix_without_leaving_the_ref_tree() {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        assert!(tree.toggle(), "the tree opens");
+        assert!(tree.toggle(), "the ref-tree opens");
 
         tree.handle_key(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE));
         tree.handle_key(KeyEvent::new(KeyCode::Esc, KeyModifiers::NONE));
@@ -1864,7 +1864,7 @@ mod tests {
         assert_eq!(
             tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
             Input::Handled,
-            "the tree has no pin action"
+            "the ref-tree has no pin action"
         );
     }
 
@@ -2079,7 +2079,7 @@ mod tests {
         ]);
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        assert!(tree.toggle(), "the available tree opens");
+        assert!(tree.toggle(), "the available ref-tree opens");
         let tagged = graph.index(id(3)).expect("tagged commit exists");
         assert!(
             tree.overview
@@ -2143,7 +2143,7 @@ mod tests {
     }
 
     #[test]
-    fn interactive_tree_renders_exact_visible_counts() -> gix_testtools::Result {
+    fn interactive_ref_tree_renders_exact_visible_counts() -> gix_testtools::Result {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
@@ -2158,9 +2158,9 @@ mod tests {
             .map(|row| row.iter().map(ratatui::buffer::Cell::symbol).collect::<String>())
             .collect::<Vec<_>>()
             .join("\n");
-        assert!(rendered.contains("main"), "the rounded tree shows main");
-        assert!(rendered.contains("topic"), "the rounded tree shows topic");
-        assert!(rendered.contains("tree ·"), "the footer identifies the tree");
+        assert!(rendered.contains("main"), "the rounded ref-tree shows main");
+        assert!(rendered.contains("topic"), "the rounded ref-tree shows topic");
+        assert!(rendered.contains("ref-tree ·"), "the footer identifies the ref-tree");
         assert!(
             rendered.contains("5 main"),
             "the selected reference shows its exact count"
@@ -2177,7 +2177,7 @@ mod tests {
     }
 
     #[test]
-    fn tree_toggle_opens_and_closes_the_single_layout() {
+    fn ref_tree_toggle_opens_and_closes_the_single_layout() {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index b47da580725..0e67e3f93b8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -969,7 +969,7 @@ pub(crate) fn draw_with_worktree(
         }
         ordered.push(toggle("[ align", app.align_metadata));
         ordered.push(Span::raw(" · "));
-        ordered.extend(shortcut("tree", 't', false));
+        ordered.extend(shortcut("ref-tree", 't', false));
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("message", 'm', app.show_commit));
         ordered.push(Span::raw(" · "));
@@ -3049,14 +3049,14 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         assert!(
             footer.starts_with(
-                    "0 commits · view · edit · copy · refs · ? ([ align · tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                    "0 commits · view · edit · copy · refs · ? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
         assert_reversed_group(
             &terminal,
             1,
-            "? ([ align · tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
+            "? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
         );
         Ok(())
     }
@@ -4130,7 +4130,7 @@ mod tests {
         })?;
         assert!(
             rendered_line(&footer_terminal, 15).contains(
-                "? ([ align · tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                "? ([ align · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
             ),
             "the expanded information prefix contains every following action except quit"
         );

From 647800ddc1ce44a05b58f7dda5a49221c3cf7ad1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:07:49 +0200
Subject: [PATCH 162/282] feat: show foreign detached worktrees in the ref-tree

Keep each worktree checkout name separate from its symbolic branch label. With --worktrees, retain both the actual HEAD and the valid symbolic HEAD-pin target as traversal tips, and track the target branch so later movement refreshes the view.

Render a detached foreign checkout as directory@ at its actual HEAD and its remembered branch as a star-prefixed label at the branch tip in both history and ref-tree. Reserve the pin marker for a detached current worktree, and fall back to the worktree administration name when no directory basename is available.
---
 gix-tix/spec.md         | 26 +++++++------
 gix-tix/src/command.rs  |  4 +-
 gix-tix/src/history.rs  | 85 ++++++++++++++++++++++++++---------------
 gix-tix/src/ref_tree.rs | 32 ++++++++++++++--
 4 files changed, 98 insertions(+), 49 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2da6738be48..26504630d38 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -39,8 +39,9 @@ without trading responsiveness for metadata that is not visible.
 - `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-w/--worktrees` adds every successfully resolved main and linked worktree
-  `HEAD` to the visible traversal tips, in addition to implicit or explicit
-  revisions. Hidden revisions still exclude matching ancestry.
+  `HEAD` plus every valid symbolic `refs/worktree/tix/pins/HEAD` target to the
+  visible traversal tips, in addition to implicit or explicit revisions. Hidden
+  revisions still exclude matching ancestry.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
 - `tix rebase todo -h HIDDEN... [--onto REV] [TIP...]` writes a self-contained
@@ -138,10 +139,10 @@ without trading responsiveness for metadata that is not visible.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. The current worktree's
   symbolic branch is displayed as `@short-name` in the local-reference color.
-  A detached worktree with a symbolic HEAD pin labels the remembered branch at
-  that branch's actual tip, even when the checkout is elsewhere; otherwise its
-  checkout directory basename labels the detached commit. Identical labels are
-  deduplicated.
+  A detached foreign worktree is shown as `directory@` at its actual `HEAD`,
+  without a pin marker. Its symbolic HEAD pin is shown separately as `★branch`
+  at that branch's actual tip. The worktree administration name is used when no
+  directory basename is available. Identical labels are deduplicated.
 - When reference labels are hidden, worktree labels are visible only on the
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
@@ -231,10 +232,10 @@ without trading responsiveness for metadata that is not visible.
   remote reference, grouped into one Git push per remote. Pushes continue after
   individual failures and run with the terminal suspended for output and authentication.
 - Worktree branch labels keep the history view's `@branch`, `branch@`, and
-  `★branch` forms at the branch's actual tip. Every detached worktree checkout is
-  additionally shown with one `📌`; ordinary tix pins neither anchor nor decorate
-  the ref-tree. A detached worktree without a usable remembered branch falls back to
-  its checkout directory basename.
+  `★branch` forms at the branch's actual tip. A detached current worktree is
+  additionally shown with one `📌`; a detached foreign worktree instead uses
+  `directory@` at its actual `HEAD`. Ordinary tix pins neither anchor nor
+  decorate the ref-tree.
 - After deleting selected local or remote references, refresh keeps the commit
   when it remains a ref-tree node, otherwise selects the next surviving node row or
   the nearest previous row when nothing below survives.
@@ -242,8 +243,9 @@ without trading responsiveness for metadata that is not visible.
 ### Ref-tree diagnostics
 
 - `tix ref-tree` prints the entire reference projection to standard output without
-  terminal colors, selection state, counts, or viewport clipping. Detached
-  worktrees render as `[pin]` in ASCII output and `📌` with `--unicode`. It traverses
+  terminal colors, selection state, counts, or viewport clipping. A detached
+  current worktree renders as `[pin]` in ASCII output and `📌` with `--unicode`.
+  It traverses
   all normal references by default; positional revisions scope traversal.
 - `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
   corresponding ref-tree inputs. Output uses ASCII lines and `o` nodes by default;
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 5ce7dd95f42..827315cd278 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -18,7 +18,7 @@ pub struct Platform {
     /// Exit once all commits and graph lanes have been computed.
     #[arg(long)]
     quit_on_finish: bool,
-    /// Add all worktree HEADs as visible traversal tips.
+    /// Add all worktree HEADs and remembered branch tips as visible traversal tips.
     #[arg(short = 'w', long)]
     worktrees: bool,
     /// Hide this revision and every commit reachable from it.
@@ -59,7 +59,7 @@ struct RefTree {
     /// Omit tags as labels, traversal tips, and topology anchors.
     #[arg(long)]
     no_tags: bool,
-    /// Include detached and linked-worktree HEADs as traversal tips.
+    /// Include detached and linked-worktree HEADs and remembered branch tips as traversal tips.
     #[arg(short = 'w', long)]
     worktrees: bool,
     /// Hide this revision and every commit reachable from it.
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 9a5b6dee1ca..52d69a16aaa 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -69,7 +69,7 @@ impl Pin {
 pub(crate) struct WorktreeCheckout {
     pub id: ObjectId,
     pub label_id: ObjectId,
-    pub name: BString,
+    pub checkout_name: BString,
     pub reference: Option<gix::refs::FullName>,
     pub is_current: bool,
     pub is_detached: bool,
@@ -1254,7 +1254,12 @@ pub(crate) fn snapshot_ignoring_pin(
     let mut view_tips = resolve_tips(repo, revisions)?.unwrap_or_default();
     view_tips.extend(pins.iter().map(|pin| pin.id));
     if include_worktrees {
-        view_tips.extend(worktrees.iter().map(|worktree| worktree.id));
+        for worktree in &worktrees {
+            view_tips.extend([worktree.id, worktree.label_id]);
+            if let Some(reference) = &worktree.reference {
+                insert_ref_chain(repo, reference.as_bstr(), &mut view)?;
+            }
+        }
     }
     let mut seen = HashSet::new();
     view_tips.retain(|id| seen.insert(*id));
@@ -1303,7 +1308,7 @@ pub(crate) fn worktree_checkouts(repo: &gix::Repository) -> Vec<WorktreeCheckout
     out.sort_by(|a, b| {
         a.id.cmp(&b.id)
             .then_with(|| a.label_id.cmp(&b.label_id))
-            .then_with(|| a.name.cmp(&b.name))
+            .then_with(|| a.checkout_name.cmp(&b.checkout_name))
             .then_with(|| a.reference.cmp(&b.reference))
     });
     out.dedup();
@@ -1312,7 +1317,7 @@ pub(crate) fn worktree_checkouts(repo: &gix::Repository) -> Vec<WorktreeCheckout
 
 fn add_worktree_checkout(
     repo: &gix::Repository,
-    detached_name: Option<BString>,
+    checkout_name: Option<BString>,
     worktree: &BStr,
     is_current: bool,
     out: &mut Vec<WorktreeCheckout>,
@@ -1340,20 +1345,11 @@ fn add_worktree_checkout(
     let (reference, label_id) = remembered
         .or_else(|| head_reference.map(|reference| (reference, id)))
         .map_or((None, id), |(reference, id)| (Some(reference), id));
-    let name = match &reference {
-        Some(reference) => reference.shorten().to_owned(),
-        None => match detached_name {
-            Some(name) => name,
-            None => {
-                tracing::warn!(%worktree, "ignoring detached worktree without a directory basename");
-                return;
-            }
-        },
-    };
+    let checkout_name = checkout_name.unwrap_or_else(|| worktree.to_owned());
     out.push(WorktreeCheckout {
         id,
         label_id,
-        name,
+        checkout_name,
         reference,
         is_current,
         is_detached,
@@ -1793,6 +1789,10 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         };
         let id = id.detach();
         if worktrees.iter().any(|worktree| {
+            worktree.is_detached && worktree.label_id == id && worktree.reference.as_ref() == Some(&full_name)
+        }) {
+            kind = DecorationKind::HeadPinBranch;
+        } else if worktrees.iter().any(|worktree| {
             worktree.is_current && worktree.label_id == id && worktree.reference.as_ref() == Some(&full_name)
         }) {
             kind = DecorationKind::CurrentWorktreeBranch;
@@ -1824,20 +1824,22 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
         }
         out.entry(id).or_default().push(Decoration { name, kind });
     }
-    for worktree in worktrees.iter().filter(|worktree| worktree.reference.is_none()) {
-        let kind = match (worktree.is_current, worktree.is_detached) {
-            (true, true) => DecorationKind::CurrentWorktreeDetached,
-            (true, false) => DecorationKind::CurrentWorktreeBranch,
-            (false, true) => DecorationKind::WorktreeDetached,
-            (false, false) => DecorationKind::WorktreeBranch,
+    for worktree in worktrees
+        .iter()
+        .filter(|worktree| worktree.reference.is_none() || worktree.is_detached && !worktree.is_current)
+    {
+        let kind = if worktree.is_current {
+            DecorationKind::CurrentWorktreeDetached
+        } else {
+            DecorationKind::WorktreeDetached
         };
-        let decorations = out.entry(worktree.label_id).or_default();
+        let decorations = out.entry(worktree.id).or_default();
         if !decorations
             .iter()
-            .any(|decoration| decoration.kind == kind && decoration.name == worktree.name)
+            .any(|decoration| decoration.kind == kind && decoration.name == worktree.checkout_name)
         {
             decorations.push(Decoration {
-                name: worktree.name.clone(),
+                name: worktree.checkout_name.clone(),
                 kind,
             });
         }
@@ -2131,6 +2133,16 @@ mod tests {
             let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
             assert!(status.success(), "git creates the worktree fixture");
         }
+        let remembered_branch = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["branch", "remembered", "main~1"])
+            .status()?;
+        assert!(remembered_branch.success(), "git creates the remembered branch");
+        let remembered_pin = Command::new("git")
+            .current_dir(fixture.path().join("detached-wt"))
+            .args(["symbolic-ref", "refs/worktree/tix/pins/HEAD", "refs/heads/remembered"])
+            .status()?;
+        assert!(remembered_pin.success(), "the foreign worktree remembers its branch");
         std::fs::remove_dir_all(fixture.path().join("detached-wt"))?;
         std::fs::write(
             fixture.path().join(".git/worktrees/broken-wt/HEAD"),
@@ -2141,11 +2153,11 @@ mod tests {
         let main = repo.rev_parse_single("main")?.detach();
         let topic = repo.rev_parse_single("topic")?.detach();
         let root = repo.rev_parse_single("main~2")?.detach();
+        let remembered = repo.rev_parse_single("remembered")?.detach();
         let worktrees = worktree_checkouts(&repo);
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == main
                 && worktree.label_id == main
-                && worktree.name == "main"
                 && worktree.is_current
                 && !worktree.is_detached
                 && worktree
@@ -2156,7 +2168,7 @@ mod tests {
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == topic
                 && worktree.label_id == topic
-                && worktree.name == "topic"
+                && worktree.checkout_name == "topic-wt"
                 && !worktree.is_current
                 && !worktree.is_detached
                 && worktree
@@ -2166,9 +2178,12 @@ mod tests {
         }));
         assert!(worktrees.iter().any(|worktree| {
             worktree.id == root
-                && worktree.label_id == root
-                && worktree.name == "detached-wt"
-                && worktree.reference.is_none()
+                && worktree.label_id == remembered
+                && worktree.checkout_name == "detached-wt"
+                && worktree
+                    .reference
+                    .as_ref()
+                    .is_some_and(|name| name.as_bstr() == b"refs/heads/remembered")
                 && !worktree.is_current
                 && worktree.is_detached
         }));
@@ -2194,14 +2209,22 @@ mod tests {
                 decoration.kind == DecorationKind::WorktreeDetached && decoration.name == "detached-wt"
             })
         }));
+        assert!(main_repo_decorations.get(&remembered).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::HeadPinBranch && decoration.name == "remembered")
+        }));
 
         let explicit = [OsString::from("main")];
         let without = snapshot(&repo, &explicit, &[], false)?;
         assert_eq!(without.view_tips, [main], "explicit revisions are unchanged by default");
+        assert!(!without.view.contains_key(b"refs/heads/remembered".as_bstr()));
         let with = snapshot(&repo, &explicit, &[], true)?;
         assert!(with.view_tips.contains(&main));
         assert!(with.view_tips.contains(&topic));
         assert!(with.view_tips.contains(&root));
+        assert!(with.view_tips.contains(&remembered));
+        assert!(with.view.contains_key(b"refs/heads/remembered".as_bstr()));
 
         let linked_path = fixture.path().join("topic-wt");
         let linked_repo = crate::test_repository::open(&linked_path)?;
@@ -2242,7 +2265,7 @@ mod tests {
         let detached_decorations = decorations(&detached_repo, &[], &detached_worktrees)?;
         assert!(detached_decorations.get(&current.id).is_some_and(|decorations| {
             decorations.iter().any(|decoration| {
-                decoration.kind == DecorationKind::CurrentWorktreeDetached && decoration.name == current.name
+                decoration.kind == DecorationKind::CurrentWorktreeDetached && decoration.name == current.checkout_name
             })
         }));
 
@@ -2259,7 +2282,7 @@ mod tests {
             .expect("the remembered detached worktree is discovered");
         assert_ne!(current.id, topic, "the worktree remains detached away from its branch");
         assert_eq!(current.label_id, topic, "the label follows the remembered branch tip");
-        assert_eq!(current.name, "topic");
+        assert_eq!(current.checkout_name, "topic-wt");
         assert!(current.is_detached);
         assert!(
             current
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 708facfc98c..c5d6079688d 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -720,7 +720,11 @@ impl Overview {
                 }
             }
         }
-        for worktree in refs.worktrees.iter().filter(|worktree| worktree.is_detached) {
+        for worktree in refs
+            .worktrees
+            .iter()
+            .filter(|worktree| worktree.is_current && worktree.is_detached)
+        {
             let Some(index) = graph.index(worktree.id) else {
                 continue;
             };
@@ -1819,7 +1823,7 @@ mod tests {
     }
 
     #[test]
-    fn detached_worktrees_are_pin_markers_while_ordinary_pins_and_p_are_hidden() {
+    fn only_the_current_detached_worktree_is_a_pin_marker() {
         let (graph, mut refs, mut decorations) = fixture();
         *decorations.get_mut(&id(5)).expect("topic is decorated") = vec![
             Decoration {
@@ -1839,12 +1843,24 @@ mod tests {
         refs.worktrees.push(crate::history::WorktreeCheckout {
             id: id(3),
             label_id: id(6),
-            name: "main".into(),
+            checkout_name: "main-wt".into(),
             reference: Some("refs/heads/main".try_into().expect("valid")),
             is_current: true,
             is_detached: true,
         });
+        refs.worktrees.push(crate::history::WorktreeCheckout {
+            id: id(4),
+            label_id: id(6),
+            checkout_name: "foreign-wt".into(),
+            reference: Some("refs/heads/main".try_into().expect("valid")),
+            is_current: false,
+            is_detached: true,
+        });
         decorations.get_mut(&id(6)).expect("main is decorated")[0].kind = DecorationKind::HeadPinBranch;
+        decorations.entry(id(4)).or_default().push(Decoration {
+            name: "foreign-wt".into(),
+            kind: DecorationKind::WorktreeDetached,
+        });
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
         let overview = tree.overview.as_ref().expect("overview exists");
@@ -1859,7 +1875,15 @@ mod tests {
             unicode.contains("★main"),
             "the remembered branch stays at its actual tip"
         );
-        assert!(ascii.contains("[pin]"), "ASCII diagnostics retain detached state");
+        assert!(
+            unicode.contains("foreign-wt@"),
+            "the foreign checkout identifies its actual HEAD"
+        );
+        assert_eq!(
+            ascii.matches("[pin]").count(),
+            1,
+            "only current detached state is marked"
+        );
         assert!(!unicode.contains("pin:"), "ordinary pin names remain hidden");
         assert_eq!(
             tree.handle_key(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),

From 9ee2aa558e42cf34ff16370f2f1cd05f6f987724 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:30:05 +0200
Subject: [PATCH 163/282] change!: always include worktrees in ref-tree
 traversal

Remove the opt-in worktree flags from both the interactive and diagnostic commands. Entering the interactive ref-tree now expands the persistent graph with every known worktree HEAD and remembered branch tip, while projecting the history rows from their original tips so the history view remains scoped.

The standalone ref-tree uses the same automatic worktree traversal. Existing cached commits and refresh workers are reused so expansion stays asynchronous and does not introduce a second graph.
---
 gix-tix/spec.md         | 15 +++----
 gix-tix/src/command.rs  | 40 +++++------------
 gix-tix/src/lib.rs      | 99 ++++++++++++++++++++++++++++++-----------
 gix-tix/src/ref_tree.rs |  5 +--
 4 files changed, 93 insertions(+), 66 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 26504630d38..82cfd4b8a0f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -38,10 +38,6 @@ without trading responsiveness for metadata that is not visible.
   an explicit no-op.
 - `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
-- `-w/--worktrees` adds every successfully resolved main and linked worktree
-  `HEAD` plus every valid symbolic `refs/worktree/tix/pins/HEAD` target to the
-  visible traversal tips, in addition to implicit or explicit revisions. Hidden
-  revisions still exclude matching ancestry.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
 - `tix rebase todo -h HIDDEN... [--onto REV] [TIP...]` writes a self-contained
@@ -195,9 +191,10 @@ without trading responsiveness for metadata that is not visible.
   independent of the history selection and panes, and the ref-tree provides
   navigation only. The direct ref-tree action appears in the `?` information group.
   “Tree” without the `ref-` prefix refers to Git tree objects and tree diffs.
-- The overview uses normal references and raw revision tips already present in
-  the completed graph, including traversed hidden history; it never causes more
-  repository traversal. Special refs are excluded. First-parent paths form a
+- Entering the overview expands its completed graph with every successfully
+  resolved main and linked worktree `HEAD` plus every valid symbolic
+  `refs/worktree/tix/pins/HEAD` target. This does not add those commits to the
+  history view. Special refs are excluded. First-parent paths form a
   forest whose referenced commits, forks, roots, shallow boundaries, and raw
   tips remain as nodes while linear runs are contracted. `Shift-T` toggles
   tags; when hidden, tag labels and tag-only anchors are removed before this
@@ -247,8 +244,8 @@ without trading responsiveness for metadata that is not visible.
   current worktree renders as `[pin]` in ASCII output and `📌` with `--unicode`.
   It traverses
   all normal references by default; positional revisions scope traversal.
-- `--no-tags`, `--worktrees`, and repeatable `--hide <revision>` match the
-  corresponding ref-tree inputs. Output uses ASCII lines and `o` nodes by default;
+- Worktree traversal is always enabled. `--no-tags` and repeatable
+  `--hide <revision>` match the corresponding ref-tree inputs. Output uses ASCII lines and `o` nodes by default;
   `--unicode` uses the interactive ref-tree's rounded line and node glyphs.
 
 ## Interaction
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 827315cd278..08d57e843c1 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -18,9 +18,6 @@ pub struct Platform {
     /// Exit once all commits and graph lanes have been computed.
     #[arg(long)]
     quit_on_finish: bool,
-    /// Add all worktree HEADs and remembered branch tips as visible traversal tips.
-    #[arg(short = 'w', long)]
-    worktrees: bool,
     /// Hide this revision and every commit reachable from it.
     #[arg(short = 'h', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
@@ -59,9 +56,6 @@ struct RefTree {
     /// Omit tags as labels, traversal tips, and topology anchors.
     #[arg(long)]
     no_tags: bool,
-    /// Include detached and linked-worktree HEADs and remembered branch tips as traversal tips.
-    #[arg(short = 'w', long)]
-    worktrees: bool,
     /// Hide this revision and every commit reachable from it.
     #[arg(long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
@@ -103,21 +97,12 @@ impl Platform {
         let Platform {
             help: _,
             quit_on_finish,
-            worktrees,
             hide,
             command,
             revisions,
         } = self;
         let Some(command) = command else {
-            return crate::run(
-                repository,
-                revisions,
-                crate::Options {
-                    quit_on_finish,
-                    hide,
-                    worktrees,
-                },
-            );
+            return crate::run(repository, revisions, crate::Options { quit_on_finish, hide });
         };
 
         let repository = repository.to_thread_local();
@@ -155,14 +140,7 @@ fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
     } else {
         args.revisions
     };
-    let rendered = crate::ref_tree::render_full(
-        repository,
-        &revisions,
-        &args.hide,
-        args.worktrees,
-        !args.no_tags,
-        args.unicode,
-    )?;
+    let rendered = crate::ref_tree::render_full(repository, &revisions, &args.hide, !args.no_tags, args.unicode)?;
     std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes())
         .context("could not write ref-tree")?;
     Ok(())
@@ -272,10 +250,9 @@ mod tests {
 
     #[test]
     fn parses_tui_options_and_top_level_commands() {
-        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-w", "-h", "main", "--hide", "tag", "topic"])
+        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-h", "main", "--hide", "tag", "topic"])
             .expect("TUI arguments parse");
         assert!(cli.platform.quit_on_finish);
-        assert!(cli.platform.worktrees);
         assert_eq!(cli.platform.hide, ["main", "tag"], "hide options append");
         assert_eq!(
             cli.platform.revisions,
@@ -288,7 +265,6 @@ mod tests {
             "tix",
             "ref-tree",
             "--no-tags",
-            "--worktrees",
             "--hide",
             "private",
             "--unicode",
@@ -303,11 +279,19 @@ mod tests {
         };
         assert!(ref_tree.help.is_none());
         assert!(ref_tree.no_tags);
-        assert!(ref_tree.worktrees);
         assert_eq!(ref_tree.hide, ["private"]);
         assert!(ref_tree.unicode);
         assert_eq!(ref_tree.revisions, ["main", "topic"]);
 
+        assert!(
+            Cli::try_parse_from(["tix", "--worktrees"]).is_err(),
+            "the removed TUI worktree option is rejected"
+        );
+        assert!(
+            Cli::try_parse_from(["tix", "ref-tree", "-w"]).is_err(),
+            "the removed diagnostic worktree option is rejected"
+        );
+
         assert!(
             Cli::try_parse_from(["tix", "ref-tree", "--layout", "rail"]).is_err(),
             "the removed layout selector is rejected"
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 413e8e3e2db..3a933274ecf 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -742,8 +742,12 @@ pub struct Options {
     pub quit_on_finish: bool,
     /// Revisions whose reachable commits should initially be hidden.
     pub hide: Vec<OsString>,
-    /// Add every successfully resolved worktree HEAD as a visible traversal tip.
-    pub worktrees: bool,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum RefreshKind {
+    History,
+    RefTree { enter: bool },
 }
 
 fn detect_commit_pane_background() -> Option<(u8, u8, u8)> {
@@ -797,7 +801,6 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     tracing::info!(
         revision_count = revisions.len(),
         hidden_revision_count = options.hide.len(),
-        include_worktrees = options.worktrees,
         "starting tix"
     );
     let commit_pane_background = detect_commit_pane_background();
@@ -860,11 +863,7 @@ fn event_loop(
     enhanced_keyboard: bool,
     commit_pane_background: Option<(u8, u8, u8)>,
 ) -> Result<Option<Duration>> {
-    let Options {
-        quit_on_finish,
-        hide,
-        worktrees,
-    } = options;
+    let Options { quit_on_finish, hide } = options;
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
@@ -872,7 +871,7 @@ fn event_loop(
     let (mut repository_is_bare, mut mailmap, mut ref_snapshot, mut worktree_head_unborn) = {
         let bare = view_repository.workdir().is_none();
         let mailmap = view_repository.open_mailmap();
-        let refs = history::snapshot(&view_repository, &revisions, &hide, worktrees)?;
+        let refs = history::snapshot(&view_repository, &revisions, &hide, false)?;
         let unborn = !bare && view_repository.head()?.is_unborn();
         (bare, mailmap, refs, unborn)
     };
@@ -897,7 +896,7 @@ fn event_loop(
         repository,
         &revisions,
         &hide,
-        worktrees,
+        false,
         gix::features::threading::OwnShared::clone(&authors),
     );
 
@@ -908,8 +907,9 @@ fn event_loop(
         app.leave_message("worktree removed; using the common repository without worktree changes");
     }
     let mut lane_receiver = None;
-    let mut refresh_receiver: Option<mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)>> = None;
+    let mut refresh_receiver: Option<mpsc::Receiver<(RefreshKind, HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
+    let mut ref_tree_refresh_pending = false;
     let mut refresh_from_filesystem = false;
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_expand_hidden = false;
@@ -1247,13 +1247,32 @@ fn event_loop(
         }
         if let Some(result) = refresh_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
-                Ok((graph, result)) => {
+                Ok((kind, graph, result)) => {
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     let result = result?;
                     ref_tree.rebuild(&graph, &result.refs, &result.decorations);
                     history_graph = Some(graph);
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
+                    if let RefreshKind::RefTree { enter } = kind {
+                        let hidden_tips = if app.show_hidden {
+                            &[][..]
+                        } else {
+                            ref_snapshot.hidden_tips.as_slice()
+                        };
+                        if let Some(rows) =
+                            app.start_refresh(result.commits, &ref_snapshot.view_tips, hidden_tips, false)
+                        {
+                            lane_receiver = Some(start_lane_worker(rows));
+                        }
+                        if enter {
+                            ref_tree.toggle();
+                            app.history_display_expanded = false;
+                        }
+                        refresh_receiver = None;
+                        dirty = true;
+                        continue;
+                    }
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "history-refresh-completed");
                     filesystem_responses.queue_frame(&response_ids, "history-refresh-completed");
@@ -1293,6 +1312,29 @@ fn event_loop(
                 Err(mpsc::TryRecvError::Disconnected) => anyhow::bail!("history refresh worker stopped unexpectedly"),
             }
         }
+        if ref_tree_refresh_pending
+            && refresh_receiver.is_none()
+            && lane_receiver.is_none()
+            && history_graph.is_some()
+            && matches!(app.state, State::Complete | State::Cancelled)
+        {
+            ref_tree_refresh_pending = false;
+            refresh_receiver = Some(start_history_refresh(
+                repository_path.clone(),
+                repository_is_bare,
+                revisions.clone(),
+                if app.show_hidden { Vec::new() } else { hide.clone() },
+                true,
+                Default::default(),
+                gix::features::threading::OwnShared::clone(&authors),
+                history_graph
+                    .take()
+                    .expect("ref-tree refresh starts only with a cached history graph"),
+                RefreshKind::RefTree { enter: true },
+            ));
+            app.deferred_history_state = Some(app.state);
+            app.state = State::Loading;
+        }
         if refresh_pending
             && refresh_receiver.is_none()
             && lane_receiver.is_none()
@@ -1306,9 +1348,9 @@ fn event_loop(
                 Err(_err) if worktree_repository_is_gone(&repository_path) => continue,
                 Err(err) => return Err(err).context("could not inspect changed references"),
             };
-            let next = history::snapshot(&repository, &revisions, &hide, worktrees)?;
+            let next = history::snapshot(&repository, &revisions, &hide, false)?;
             let hidden_changed = next.hidden != ref_snapshot.hidden;
-            let worktree_tips_changed = worktrees && next.worktrees != ref_snapshot.worktrees;
+            let worktree_tips_changed = ref_tree.is_active() && next.worktrees != ref_snapshot.worktrees;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed || worktree_tips_changed;
             let from_filesystem = std::mem::take(&mut refresh_from_filesystem);
             if tips_changed && from_filesystem {
@@ -1335,12 +1377,13 @@ fn event_loop(
                 repository_is_bare,
                 revisions.clone(),
                 hidden,
-                worktrees,
+                false,
                 expand,
                 gix::features::threading::OwnShared::clone(&authors),
                 history_graph
                     .take()
                     .expect("refresh starts only with a cached history graph"),
+                RefreshKind::History,
             ));
             refresh_expand_hidden = false;
             app.deferred_history_state = Some(app.state);
@@ -1753,7 +1796,7 @@ fn event_loop(
                     &repository_path,
                     repository_is_bare,
                     &revisions,
-                    worktrees,
+                    false,
                 ) {
                     Ok((notice, id)) => {
                         pending_todo_rebase_plan = Some(plan);
@@ -1820,7 +1863,7 @@ fn event_loop(
                                 repository_is_bare,
                                 selected,
                                 &revisions,
-                                worktrees,
+                                false,
                             )
                         })
                         .transpose()
@@ -1869,8 +1912,11 @@ fn event_loop(
             continue;
         };
         if action == Action::ToggleRefTree {
-            ref_tree.toggle();
-            app.history_display_expanded = false;
+            if ref_tree.is_active() {
+                ref_tree.leave();
+            } else {
+                ref_tree_refresh_pending = !ref_tree_refresh_pending;
+            }
             dirty = true;
             urgent = true;
             continue;
@@ -2086,7 +2132,7 @@ fn event_loop(
                                         &graph,
                                         &review_roots,
                                         &revisions,
-                                        worktrees,
+                                        false,
                                     )
                                 });
                             match travel {
@@ -2250,7 +2296,7 @@ fn event_loop(
                                     repository_is_bare,
                                     name,
                                     &revisions,
-                                    worktrees,
+                                    false,
                                 )
                             });
                             match returned.transpose() {
@@ -2315,7 +2361,7 @@ fn event_loop(
                                     repository_is_bare,
                                     &outcome,
                                     &revisions,
-                                    worktrees,
+                                    false,
                                 )
                             } else {
                                 Ok(None)
@@ -2391,7 +2437,7 @@ fn event_loop(
                                 repository_is_bare,
                                 &finished.outcome,
                                 &revisions,
-                                worktrees,
+                                false,
                             );
                             match checkout {
                                 Ok(_) => app.leave_message(format!(
@@ -2424,7 +2470,7 @@ fn event_loop(
                                 graph,
                                 &review_roots,
                                 &revisions,
-                                worktrees,
+                                false,
                             )
                         });
                     match result {
@@ -2569,7 +2615,8 @@ fn start_history_refresh(
     expand: std::collections::HashSet<gix::ObjectId>,
     authors: SharedAuthors,
     mut graph: HistoryGraph,
-) -> mpsc::Receiver<(HistoryGraph, Result<history::Refresh>)> {
+    kind: RefreshKind,
+) -> mpsc::Receiver<(RefreshKind, HistoryGraph, Result<history::Refresh>)> {
     let (sender, receiver) = mpsc::channel();
     std::thread::spawn(move || {
         let result = open_repository(&repository_path, bare, true)
@@ -2585,7 +2632,7 @@ fn start_history_refresh(
                     &authors,
                 )
             });
-        let _ = sender.send((graph, result));
+        let _ = sender.send((kind, graph, result));
     });
     receiver
 }
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index c5d6079688d..b696dbfbe0e 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1306,11 +1306,10 @@ pub(crate) fn render_full(
     repository: &gix::Repository,
     revisions: &[OsString],
     hidden: &[OsString],
-    worktrees: bool,
     show_tags: bool,
     unicode: bool,
 ) -> anyhow::Result<String> {
-    let refs = crate::history::snapshot(repository, revisions, hidden, worktrees)?;
+    let refs = crate::history::snapshot(repository, revisions, hidden, true)?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
         crate::history::Authors::default(),
     ));
@@ -1320,7 +1319,7 @@ pub(crate) fn render_full(
         repository,
         revisions,
         hidden,
-        worktrees,
+        true,
         &authors,
         &AtomicBool::new(false),
         |event| {

From 32ba92c689e83ef4935d113338de476e1e4895dd Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:34:01 +0200
Subject: [PATCH 164/282] feat: pin selected ref-tree references into history

Make Enter on a reference-backed ref-tree node create or reuse symbolic current-worktree pins for every displayed local, remote, tag, or review reference. Synthetic topology nodes and detached worktree labels remain inert.

Symbolic pins now augment attached history regardless of topology, unlike direct preservation pins which remain limited to descendants. Returning from the ref-tree refreshes history and selects the pinned commit, so unrelated worktree branches can be brought into the editable view deliberately.
---
 gix-tix/spec.md         |  17 +++--
 gix-tix/src/app.rs      |  40 +++++++++++
 gix-tix/src/history.rs  |   9 +--
 gix-tix/src/lib.rs      |  30 ++++++++
 gix-tix/src/ref_tree.rs | 154 +++++++++++++++++++++++++++++++++++++++-
 5 files changed, 240 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 82cfd4b8a0f..96e84e24d3b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -188,8 +188,8 @@ without trading responsiveness for metadata that is not visible.
 
 - After traversal completes, `t` toggles history and a rounded rail ref-tree.
   `Escape` also returns directly to history. The ref-tree cursor and viewport are
-  independent of the history selection and panes, and the ref-tree provides
-  navigation only. The direct ref-tree action appears in the `?` information group.
+  independent of the history selection and panes. The direct ref-tree action
+  appears in the `?` information group.
   “Tree” without the `ref-` prefix refers to Git tree objects and tree diffs.
 - Entering the overview expands its completed graph with every successfully
   resolved main and linked worktree `HEAD` plus every valid symbolic
@@ -228,6 +228,12 @@ without trading responsiveness for metadata that is not visible.
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
   remote reference, grouped into one Git push per remote. Pushes continue after
   individual failures and run with the terminal suspended for output and authentication.
+- `<enter>` on a node with visible references creates or reuses symbolic
+  current-worktree pins for every displayed local branch, tag, remote-tracking
+  reference, or review reference at that commit. It returns to history and
+  selects the pinned commit in the first refreshed frame, with its cached
+  ancestry and hidden merge-base boundary already projected. Synthetic nodes, raw tips, detached-worktree labels,
+  and stash associations have no Enter action.
 - Worktree branch labels keep the history view's `@branch`, `branch@`, and
   `★branch` forms at the branch's actual tip. A detached current worktree is
   additionally shown with one `📌`; a detached foreign worktree instead uses
@@ -322,9 +328,10 @@ The Enter key is written as `<enter>` throughout.
   successor is not pinned; a distinct departure preserves its rewritten identity.
 - While `HEAD` is detached, every valid pin, including the HEAD pin, from the
   current worktree augments implicit and explicit revision tips. While it is
-  attached, only pins at strict descendants of `HEAD` do so and the HEAD pin is
-  inactive, preserving rewritten leaves after a history rebase moves the
-  checked-out branch down its stack. Pins from other worktrees, dangling,
+  attached, symbolic ordinary pins and direct pins at strict descendants of
+  `HEAD` do so while the HEAD pin is inactive. This lets explicitly pinned
+  references enter history while preserving rewritten leaves after a history
+  rebase moves the checked-out branch down its stack. Pins from other worktrees, dangling,
   malformed, and non-commit pins do not enter the view or its decorations.
   Normal hidden-revision exclusions still apply.
 - One or more worktree pins at a commit are shown as a single blue `📌`
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 353340b9c6a..4b285f5a2b9 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2526,6 +2526,46 @@ mod tests {
         );
     }
 
+    #[test]
+    fn ref_tree_pin_refresh_adds_cached_branch_ancestry_and_selects_its_tip() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+
+        let rows = app
+            .start_refresh(
+                vec![row_with_parents(5, &[4]), row_with_parents(4, &[2])].into(),
+                &[id(3)],
+                &[],
+                false,
+            )
+            .expect("ref-tree expansion caches its branch while retaining history tips");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(3), id(2), id(1)],
+            "worktree expansion does not broaden history"
+        );
+
+        app.select_commit_after_refresh(id(5));
+        let rows = app
+            .start_refresh(Vec::<LoadedCommit>::new().into(), &[id(3), id(5)], &[], false)
+            .expect("the new pin reprojects already cached commits");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(3), id(5), id(4), id(2), id(1)],
+            "the pinned branch and its shared base appear without restarting"
+        );
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(5)),
+            "the first frame of the refreshed history selects the pinned entry"
+        );
+    }
+
     #[test]
     fn lane_computation_keeps_cached_parents_outside_the_current_view() {
         let mut app = App::new(3);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 52d69a16aaa..cf5acf3f4ff 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1485,9 +1485,10 @@ pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
         .filter(|pin| {
             !pin.is_head()
                 && pin.id != head_id
-                && repo
-                    .merge_base(head_id, pin.id)
-                    .is_ok_and(|base| base.as_ref() == head_id)
+                && (pin.target.try_name().is_some()
+                    || repo
+                        .merge_base(head_id, pin.id)
+                        .is_ok_and(|base| base.as_ref() == head_id))
         })
         .collect())
 }
@@ -1858,7 +1859,7 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
     Ok(out)
 }
 
-fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
+pub(crate) fn is_missing_ref(mut err: &(dyn std::error::Error + 'static)) -> bool {
     loop {
         if err
             .downcast_ref::<std::io::Error>()
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 3a933274ecf..587e1eacbce 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -910,6 +910,7 @@ fn event_loop(
     let mut refresh_receiver: Option<mpsc::Receiver<(RefreshKind, HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
     let mut ref_tree_refresh_pending = false;
+    let mut return_to_history_after_refresh = None;
     let mut refresh_from_filesystem = false;
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_expand_hidden = false;
@@ -1224,6 +1225,9 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    if return_to_history_after_refresh.take().is_some() {
+                        ref_tree.leave();
+                    }
                     update_hidden_branch_updates(&mut app, history_graph.as_ref(), &ref_snapshot);
                     let response_ids = filesystem_responses.active_reference_ids().to_vec();
                     filesystem_responses.phase(&response_ids, "lane-computation-completed");
@@ -1289,6 +1293,9 @@ fn event_loop(
                     if let Some(successor) = decorated_successor {
                         app.select_commit_after_refresh(successor);
                     }
+                    if let Some(id) = return_to_history_after_refresh {
+                        app.select_commit_after_refresh(id);
+                    }
                     worktree_head_unborn = !repository_is_bare
                         && open_repository(&repository_path, false, false)
                             .and_then(|repo| Ok(repo.head()?.is_unborn()))
@@ -1538,6 +1545,29 @@ fn event_loop(
                         urgent = true;
                         continue;
                     }
+                    ref_tree::Input::PinReferences { id, kinds } => {
+                        let result = open_repository(&repository_path, repository_is_bare, false)
+                            .context("could not open repository to pin ref-tree references")
+                            .and_then(|repository| ref_tree::pin_references(&repository, id, &kinds));
+                        match result {
+                            Ok(pins) if !pins.is_empty() => {
+                                app.select_commit_after_refresh(pins[0].id);
+                                return_to_history_after_refresh = Some(pins[0].id);
+                                app.leave_message(if pins.len() == 1 {
+                                    "pinned selected reference".into()
+                                } else {
+                                    format!("pinned {} selected references", pins.len())
+                                });
+                                refresh_pending = true;
+                                refresh_expand_hidden = true;
+                            }
+                            Ok(_) => ref_tree.leave_message("selected references changed before they could be pinned"),
+                            Err(err) => ref_tree.leave_message(format!("pin selected references: {err:#}")),
+                        }
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
                     ref_tree::Input::ResolveRemoteReferences(names) => {
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(repository) => {
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index b696dbfbe0e..4c687210bc4 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -5,6 +5,7 @@ use std::{
     sync::atomic::AtomicBool,
 };
 
+use anyhow::Context;
 use crossterm::event::{KeyCode, KeyEvent, KeyModifiers, MouseEventKind};
 use gix::{ObjectId, bstr::ByteSlice};
 use ratatui::{
@@ -119,6 +120,10 @@ enum Direction {
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Input {
     Handled,
+    PinReferences {
+        id: ObjectId,
+        kinds: Vec<DecorationKind>,
+    },
     ResolveRemoteReferences(Vec<gix::refs::FullName>),
     DeleteLocalBranches {
         names: Vec<gix::refs::FullName>,
@@ -298,6 +303,11 @@ impl Tree {
             self.leave();
             return Input::Handled;
         }
+        if key.code == KeyCode::Enter {
+            return self
+                .selected_pin_target()
+                .map_or(Input::Handled, |(id, kinds)| Input::PinReferences { id, kinds });
+        }
         if key.code == KeyCode::Char(' ') && key.modifiers.is_empty() {
             self.toggle_count_anchor();
             return Input::Handled;
@@ -479,7 +489,7 @@ impl Tree {
                 |id| format!("Space counts:{}", self.node_label(id)),
             );
             format!(
-                "ref-tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · e edit · t/Esc history"
+                "ref-tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · <enter> pin · e edit · t/Esc history"
             )
         };
         frame.render_widget(
@@ -504,6 +514,22 @@ impl Tree {
             .collect()
     }
 
+    fn selected_pin_target(&self) -> Option<(ObjectId, Vec<DecorationKind>)> {
+        let node = self
+            .selected
+            .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))?;
+        let mut kinds = Vec::new();
+        for decoration in &node.decorations {
+            let Some(kind) = pinnable_kind(decoration.kind) else {
+                continue;
+            };
+            if !kinds.contains(&kind) {
+                kinds.push(kind);
+            }
+        }
+        (!kinds.is_empty()).then_some((node.id, kinds))
+    }
+
     fn selected_remote_references(&self) -> Vec<gix::refs::FullName> {
         self.selected
             .and_then(|selected| self.overview.as_ref()?.nodes.get(selected))
@@ -697,6 +723,65 @@ impl Tree {
     }
 }
 
+fn pinnable_kind(kind: DecorationKind) -> Option<DecorationKind> {
+    match kind {
+        DecorationKind::Local
+        | DecorationKind::CurrentWorktreeBranch
+        | DecorationKind::WorktreeBranch
+        | DecorationKind::HeadPinBranch => Some(DecorationKind::Local),
+        DecorationKind::Tag | DecorationKind::AnnotatedTag => Some(DecorationKind::Tag),
+        DecorationKind::Remote | DecorationKind::Review => Some(kind),
+        _ => None,
+    }
+}
+
+pub(crate) fn pin_references(
+    repository: &gix::Repository,
+    id: ObjectId,
+    kinds: &[DecorationKind],
+) -> anyhow::Result<Vec<crate::history::Pin>> {
+    let mut names = Vec::new();
+    for reference in repository
+        .references()
+        .context("could not open references while pinning the ref-tree selection")?
+        .all()
+        .context("could not iterate references while pinning the ref-tree selection")?
+    {
+        let mut reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if crate::history::is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read reference to pin: {err}")),
+        };
+        let Some(kind) = pinnable_kind(crate::history::decoration_kind(reference.name().as_bstr())) else {
+            continue;
+        };
+        if !kinds.contains(&kind) {
+            continue;
+        }
+        let Ok(target) = reference.peel_to_id() else {
+            continue;
+        };
+        if target.as_ref() != id {
+            continue;
+        }
+        names.push(reference.name().to_owned());
+    }
+    names.sort();
+    names.dedup();
+    names
+        .into_iter()
+        .map(|name| {
+            crate::edit::time_travel::create_or_reuse_pin(
+                repository,
+                gix::refs::Target::Symbolic(name),
+                id,
+                "tix ref-tree",
+            )
+            .map(|(pin, _created)| pin)
+        })
+        .collect()
+}
+
 impl Overview {
     fn new(graph: &HistoryGraph, refs: &RefSnapshot, decorations: &Decorations, show_tags: bool) -> Self {
         let mut labels = HashMap::<CommitIndex, Vec<Decoration>>::new();
@@ -2057,6 +2142,73 @@ mod tests {
         assert_eq!(tree.selected, Some(root), "shift-modified lowercase g reaches the root");
     }
 
+    #[test]
+    fn enter_pins_every_visible_reference_kind_but_not_synthetic_nodes() {
+        let (graph, refs, mut decorations) = fixture();
+        decorations.get_mut(&id(6)).expect("main is decorated").extend([
+            Decoration {
+                name: "tag: release".into(),
+                kind: DecorationKind::Tag,
+            },
+            Decoration {
+                name: "origin/main".into(),
+                kind: DecorationKind::Remote,
+            },
+        ]);
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
+            Input::PinReferences {
+                id: id(6),
+                kinds: vec![DecorationKind::Local, DecorationKind::Remote, DecorationKind::Tag],
+            },
+            "Enter retains every displayed reference namespace"
+        );
+
+        tree.selected = tree
+            .overview
+            .as_ref()
+            .and_then(|overview| overview.by_commit.get(&graph.index(id(2))?).copied());
+        assert_eq!(
+            tree.handle_key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
+            Input::Handled,
+            "fork-only nodes have no pin action"
+        );
+    }
+
+    #[test]
+    fn pin_references_uses_all_requested_refs_and_makes_symbolic_pins_visible() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let old = repo.rev_parse_single("main~2")?.detach();
+        for name in ["refs/heads/old", "refs/tags/old", "refs/remotes/origin/old"] {
+            repo.reference(
+                name,
+                old,
+                gix::refs::transaction::PreviousValue::MustNotExist,
+                "prepare ref-tree pin test",
+            )?;
+        }
+
+        let pins = pin_references(&repo, old, &[DecorationKind::Local, DecorationKind::Remote])?;
+        let targets: Vec<_> = pins
+            .iter()
+            .filter_map(|pin| pin.target.try_name().map(|name| name.as_bstr().to_owned()))
+            .collect();
+        assert!(targets.contains(&b"refs/heads/old".as_bstr().to_owned()));
+        assert!(targets.contains(&b"refs/remotes/origin/old".as_bstr().to_owned()));
+        assert!(!targets.contains(&b"refs/tags/old".as_bstr().to_owned()));
+        assert!(
+            crate::history::snapshot(&repo, &[], &[], false)?
+                .view_tips
+                .contains(&old),
+            "a symbolic reference pin augments attached history even below HEAD"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rebuild_preserves_selection_by_object_id() {
         let (graph, refs, decorations) = fixture();

From 8df971d52f904fb3a6a999f45fee814c3d2f5971 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:38:50 +0200
Subject: [PATCH 165/282] feat: show author dates by default

Retain the author timestamp while decoding commit metadata and make it the history row default. The view date action now cycles author date, committer date, and no date, preserving the prior ability to hide the column while exposing both Git timestamps.

The footer identifies the active date source, deferred metadata carries both timestamps, and rendering tests use distinct dates to protect the cycle.
---
 gix-tix/spec.md        |  4 +--
 gix-tix/src/app.rs     | 34 +++++++++++++++++---
 gix-tix/src/history.rs | 23 ++++++++++++-
 gix-tix/src/lib.rs     |  1 +
 gix-tix/src/ui.rs      | 73 +++++++++++++++++++++++++++++++++---------
 5 files changed, 113 insertions(+), 22 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 96e84e24d3b..125262cee76 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -120,7 +120,7 @@ without trading responsiveness for metadata that is not visible.
 ### Row content and visual states
 
 - A row contains graph lanes, a seven-character object ID, optional references,
-  committer date, author and attribution information, markers, and title.
+  author date by default, author and attribution information, markers, and title.
 - The commit marker is blue when unsigned, orange when signed but unverified or
   being verified, green when verified, and bright red when verification fails.
 - The current `HEAD` commit, including a review commit, uses `@` instead of the
@@ -270,7 +270,7 @@ without trading responsiveness for metadata that is not visible.
 | `t` | Toggle the rounded ref-tree overview. |
 | `[` | Toggle graph/metadata alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
-| `v d` | Toggle committer dates. |
+| `v d` | Cycle author dates, committer dates, and no dates. |
 | `v e` | Toggle full actors/emails and titles. |
 | `v n` | Cycle all attribution, author only, and no names, skipping inert states. |
 | `v t` | Toggle attribution trailers. |
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 4b285f5a2b9..b55d7f9e591 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -16,6 +16,7 @@ pub(crate) struct Commit<T> {
     pub id: ObjectId,
     pub parent_ids: ParentIds,
     pub committer_time: gix::date::Time,
+    pub author_time: gix::date::Time,
     pub author: &'static Author,
     pub attributions: Range<usize>,
     pub title: T,
@@ -28,6 +29,7 @@ pub(crate) struct Commit<T> {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) struct Metadata<T> {
     pub committer_time: gix::date::Time,
+    pub author_time: gix::date::Time,
     pub author: &'static Author,
     pub attributions: Range<usize>,
     pub title: T,
@@ -257,6 +259,14 @@ pub(crate) enum NameMode {
     None,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum DateMode {
+    #[default]
+    Author,
+    Committer,
+    None,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum CopyKind {
     Id,
@@ -393,7 +403,7 @@ pub(crate) struct App {
     pub(crate) deferred_history_state: Option<State>,
     pub viewport_rows: usize,
     pub lane_time: Option<Duration>,
-    pub show_committer_date: bool,
+    pub date_mode: DateMode,
     pub name_mode: NameMode,
     pub show_emails: bool,
     pub show_trailers: bool,
@@ -484,7 +494,7 @@ impl App {
             deferred_history_state: None,
             viewport_rows,
             lane_time: None,
-            show_committer_date: true,
+            date_mode: DateMode::default(),
             name_mode: NameMode::All,
             show_emails: false,
             show_trailers: true,
@@ -702,6 +712,7 @@ impl App {
                     id: row.id,
                     parent_ids: row.parent_ids,
                     committer_time: row.committer_time,
+                    author_time: row.author_time,
                     author: row.author,
                     attributions: attribution_base + row.attributions.start..attribution_base + row.attributions.end,
                     title: start..self.titles.len(),
@@ -744,6 +755,7 @@ impl App {
         let row = Arc::make_mut(row);
         let Metadata {
             committer_time,
+            author_time,
             author,
             attributions,
             title,
@@ -756,6 +768,7 @@ impl App {
         let attribution_start = self.attributions.len();
         self.attributions.extend(new_attributions);
         row.committer_time = committer_time;
+        row.author_time = author_time;
         row.author = author;
         row.attributions = attribution_start + attributions.start..attribution_start + attributions.end;
         row.title = title_start..self.titles.len();
@@ -922,7 +935,13 @@ impl App {
                 self.follow_tail = self.state == State::Loading;
                 self.ensure_visible();
             }
-            Action::ToggleDate => self.show_committer_date = !self.show_committer_date,
+            Action::ToggleDate => {
+                self.date_mode = match self.date_mode {
+                    DateMode::Author => DateMode::Committer,
+                    DateMode::Committer => DateMode::None,
+                    DateMode::None => DateMode::Author,
+                };
+            }
             Action::ToggleEmail => self.show_emails = !self.show_emails,
             Action::ToggleName => {
                 let start = self.offset.min(self.rows.len());
@@ -1387,6 +1406,7 @@ impl App {
                         row.id,
                         Metadata {
                             committer_time: row.committer_time,
+                            author_time: row.author_time,
                             author: row.author,
                             attributions: row.attributions.clone(),
                             title: row.title.clone(),
@@ -2386,6 +2406,7 @@ mod tests {
         Commit {
             id: id(n.into()),
             parent_ids: ParentIds::new(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: Box::leak(Box::new(Author {
                 name: b"author".as_bstr(),
@@ -2935,6 +2956,7 @@ mod tests {
         app.set_metadata(
             0,
             Metadata {
+                author_time: gix::date::Time::default(),
                 committer_time: gix::date::Time::default(),
                 author: row(1).author,
                 attributions: 0..0,
@@ -3429,7 +3451,11 @@ mod tests {
         app.update(Action::CycleChangesParent);
         app.update(Action::ToggleChanges);
 
-        assert!(!app.show_committer_date);
+        assert_eq!(app.date_mode, DateMode::Committer);
+        app.update(Action::ToggleDate);
+        assert_eq!(app.date_mode, DateMode::None);
+        app.update(Action::ToggleDate);
+        assert_eq!(app.date_mode, DateMode::Author);
         assert!(app.show_emails);
         assert_eq!(app.name_mode, NameMode::None);
         assert!(!app.show_trailers);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index cf5acf3f4ff..8aa9d26920c 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -722,6 +722,7 @@ impl HistoryGraph {
                 let metadata_loaded = metadata.is_some();
                 let Metadata {
                     committer_time,
+                    author_time,
                     author,
                     attributions: row_attributions,
                     title,
@@ -730,6 +731,7 @@ impl HistoryGraph {
                     signature,
                 } = metadata.unwrap_or_else(|| Metadata {
                     committer_time: Default::default(),
+                    author_time: Default::default(),
                     author: &EMPTY_AUTHOR,
                     attributions: 0..0,
                     title: BString::default(),
@@ -741,6 +743,7 @@ impl HistoryGraph {
                     id,
                     parent_ids: parent_ids.clone(),
                     committer_time,
+                    author_time,
                     author,
                     attributions: row_attributions,
                     title,
@@ -1072,6 +1075,7 @@ pub(crate) fn load(
             let metadata_loaded = metadata.is_some();
             let Metadata {
                 committer_time,
+                author_time,
                 author,
                 attributions: row_attributions,
                 title,
@@ -1080,6 +1084,7 @@ pub(crate) fn load(
                 signature,
             } = metadata.unwrap_or_else(|| Metadata {
                 committer_time: Default::default(),
+                author_time: Default::default(),
                 author: &EMPTY_AUTHOR,
                 attributions: 0..0,
                 title: BString::default(),
@@ -1094,6 +1099,7 @@ pub(crate) fn load(
                 id,
                 parent_ids: parent_ids.clone(),
                 committer_time,
+                author_time,
                 author,
                 attributions: row_attributions,
                 title,
@@ -1157,6 +1163,7 @@ pub(crate) fn load(
             let parent_ids = object.parent_ids().map(gix::Id::detach).collect();
             let Metadata {
                 committer_time,
+                author_time,
                 author,
                 attributions: row_attributions,
                 title,
@@ -1168,6 +1175,7 @@ pub(crate) fn load(
                 id,
                 parent_ids,
                 committer_time,
+                author_time,
                 author,
                 attributions: row_attributions,
                 title,
@@ -1554,6 +1562,7 @@ fn decode_metadata<'a>(
     attributions: &mut Vec<Attribution>,
 ) -> Result<Metadata<BString>> {
     let mut committer_time = None;
+    let mut author_time = None;
     let mut author = None;
     let attribution_start = attributions.len();
     let mut title = None;
@@ -1563,6 +1572,7 @@ fn decode_metadata<'a>(
     for token in tokens {
         match token.context("could not decode commit")? {
             Token::Author { signature } => {
+                author_time = Some(signature.time().context("could not decode author time")?);
                 let signature = signature.trim();
                 author = Some(authors.intern_author(signature.name, signature.email));
             }
@@ -1616,6 +1626,7 @@ fn decode_metadata<'a>(
     }
     Ok(Metadata {
         committer_time: committer_time.context("commit has no committer time")?,
+        author_time: author_time.context("commit has no author time")?,
         author: author.context("commit has no author")?,
         attributions: attribution_start..attributions.len(),
         title: title.context("commit has no message")?,
@@ -2320,7 +2331,7 @@ mod tests {
         let commit = Command::new("git")
             .current_dir(fixture_path)
             .env("GIT_AUTHOR_DATE", "2000-01-05T00:00:00 +0000")
-            .env("GIT_COMMITTER_DATE", "2000-01-05T00:00:00 +0000")
+            .env("GIT_COMMITTER_DATE", "2000-01-06T00:00:00 +0000")
             .args(["-c", "commit.gpgSign=false", "commit", "-q", "-m", "new"])
             .status()?;
         assert!(commit.success(), "a commit newer than the graph is created");
@@ -2337,6 +2348,16 @@ mod tests {
         let newest = rows.first().expect("the new commit is walked first");
         assert!(newest.metadata_loaded, "ODB commits are decoded during the walk");
         assert_eq!(newest.title, "new");
+        assert_eq!(
+            newest.author_time.format_or_unix(gix::date::time::format::SHORT),
+            "2000-01-05",
+            "author dates are retained independently"
+        );
+        assert_eq!(
+            newest.committer_time.format_or_unix(gix::date::time::format::SHORT),
+            "2000-01-06",
+            "committer dates remain available"
+        );
         let deferred = rows
             .iter()
             .find(|row| !row.metadata_loaded)
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 587e1eacbce..f98c7cf436c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3636,6 +3636,7 @@ fn preview_todo_rebase_conflict(
             id,
             parent_ids,
             committer_time: metadata.committer_time,
+            author_time: metadata.author_time,
             author: metadata.author,
             attributions: attribution_start..attribution_start + attribution_len,
             title: metadata.title,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 0e67e3f93b8..20b767e098c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -11,7 +11,7 @@ use crate::{
     BuiltInDiff,
     app::{
         App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesLayout, ChangesMode, CommitRow,
-        CopyKind, NameMode, RefMode, SelectionRelation, SignatureState, State,
+        CopyKind, DateMode, NameMode, RefMode, SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -396,7 +396,7 @@ pub(crate) fn draw_with_worktree(
         .min(content.width as usize);
     let align_width = max_lane_width.min(align_limit);
     let align_metadata = app.align_metadata;
-    let show_committer_date = app.show_committer_date;
+    let date_mode = app.date_mode;
     let name_mode = app.name_mode;
     let copy_feedback = app.copy_feedback.take();
     let show_author_name = copy_feedback == Some(CopyKind::Author) || name_mode != NameMode::None;
@@ -414,7 +414,7 @@ pub(crate) fn draw_with_worktree(
                 decorations,
                 mailmap,
                 MetadataOptions {
-                    show_committer_date,
+                    date_mode,
                     show_author_name,
                     show_emails: app.show_emails,
                     show_trailers,
@@ -900,7 +900,12 @@ pub(crate) fn draw_with_worktree(
         view_prefix_spans.push(Span::raw(" · "));
         view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
         view_prefix_spans.push(Span::raw("iew ("));
-        view_prefix_spans.extend(shortcut("date", 'd', app.show_committer_date));
+        let (date_label, date_visible) = match app.date_mode {
+            DateMode::Author => ("author date", true),
+            DateMode::Committer => ("committer date", true),
+            DateMode::None => ("date", false),
+        };
+        view_prefix_spans.extend(shortcut(date_label, 'd', date_visible));
         view_prefix_spans.push(Span::raw(" · "));
         view_prefix_spans.extend(shortcut("emails", 'e', app.show_emails));
         let (name_label, names_visible) = match app.name_mode {
@@ -1671,7 +1676,7 @@ fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
 
 #[derive(Clone, Copy)]
 struct MetadataOptions {
-    show_committer_date: bool,
+    date_mode: DateMode,
     show_author_name: bool,
     show_emails: bool,
     show_trailers: bool,
@@ -1692,7 +1697,7 @@ fn metadata_line<'a>(
 ) -> Line<'a> {
     debug_assert!(row.metadata_loaded, "visible rows have metadata");
     let MetadataOptions {
-        show_committer_date,
+        date_mode,
         show_author_name,
         show_emails,
         show_trailers,
@@ -1790,9 +1795,14 @@ fn metadata_line<'a>(
     } else {
         spans.push(Span::raw(" "));
     }
-    if show_committer_date {
+    let date = match date_mode {
+        DateMode::Author => Some(row.author_time),
+        DateMode::Committer => Some(row.committer_time),
+        DateMode::None => None,
+    };
+    if let Some(date) = date {
         spans.push(Span::styled(
-            format!("{} ", row.committer_time.format_or_unix(gix::date::time::format::SHORT)),
+            format!("{} ", date.format_or_unix(gix::date::time::format::SHORT)),
             color(Color::Blue),
         ));
     }
@@ -1897,7 +1907,7 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
         &decorations,
         mailmap,
         MetadataOptions {
-            show_committer_date: app.show_committer_date,
+            date_mode: app.date_mode,
             show_author_name: app.name_mode != crate::app::NameMode::None,
             show_emails: app.show_emails,
             show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
@@ -2103,6 +2113,7 @@ mod tests {
                 .map(|byte| Commit {
                     id: gix::ObjectId::Sha1([byte; 20]),
                     parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
                     attributions: 0..0,
@@ -2136,7 +2147,8 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
-            committer_time: gix::date::Time::default(),
+            author_time: gix::date::Time::new(0, 0),
+            committer_time: gix::date::Time::new(86_400, 0),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
             title: "subject".into(),
@@ -2223,6 +2235,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -2352,6 +2365,7 @@ mod tests {
         let row = Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -2465,6 +2479,7 @@ mod tests {
             rows: vec![Commit {
                 id: gix::ObjectId::Sha1([1; 20]),
                 parent_ids: Default::default(),
+                author_time: gix::date::Time::default(),
                 committer_time: gix::date::Time::default(),
                 author: author(b"Codex", b"codex@openai.com"),
                 attributions: 0..8,
@@ -2594,6 +2609,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -2625,6 +2641,7 @@ mod tests {
             rows: vec![Commit {
                 id: gix::ObjectId::Sha1([1; 20]),
                 parent_ids: Default::default(),
+                author_time: gix::date::Time::default(),
                 committer_time: gix::date::Time::default(),
                 author: author(b"Author", b"1+author@users.noreply.github.com"),
                 attributions: 0..1,
@@ -2664,7 +2681,8 @@ mod tests {
         app.extend_commits(vec![Commit {
             id,
             parent_ids: Default::default(),
-            committer_time: gix::date::Time::default(),
+            author_time: gix::date::Time::new(0, 0),
+            committer_time: gix::date::Time::new(86_400, 0),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
             title: "subject".into(),
@@ -2696,7 +2714,7 @@ mod tests {
         assert_eq!(
             super::todo_metadata(&app, &app.rows[0], &mailmap),
             "1970-01-01 mapped author subject",
-            "todo commit metadata excludes separately represented refs"
+            "todo commit metadata uses the author date and excludes separately represented refs"
         );
 
         let footer_text = "#1 · view · edit · copy · refs · ? · quit";
@@ -2816,11 +2834,19 @@ mod tests {
         );
         app.update(Action::ToggleMailmap);
 
+        app.update(Action::ToggleDate);
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
+        assert!(
+            rendered_row(&terminal).contains("1970-01-02"),
+            "the first d switches to the committer date"
+        );
+        assert!(rendered_line(&terminal, 1).contains("committer date"));
+
         app.update(Action::ToggleDate);
         app.update(Action::ToggleName);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         let row = rendered_row(&terminal);
-        assert!(!row.contains("1970-01-01"), "d hides the committer date");
+        assert!(!row.contains("1970-01-0"), "the second d hides dates");
         assert!(
             !row.contains("author"),
             "the first n hides the author when there are no attributions"
@@ -2902,6 +2928,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: selected,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3018,7 +3045,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let footer = rendered_line(&terminal, 1);
-        let view = "view (date · emails · names · mailmap · trailers · refs · show hidden)";
+        let view = "view (author date · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
             footer.starts_with(&format!("0 commits · {view} · copy · refs · ?")),
             "the active view prefix follows the history position"
@@ -3068,6 +3095,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3237,6 +3265,7 @@ mod tests {
         let commit = |id| Commit {
             id,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3310,6 +3339,7 @@ mod tests {
                 .map(|n| Commit {
                     id: gix::ObjectId::Sha1([n; 20]),
                     parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
                     attributions: 0..0,
@@ -3443,6 +3473,7 @@ mod tests {
         let commit = |id: gix::ObjectId, parent: Option<gix::ObjectId>| Commit {
             id,
             parent_ids: parent.into_iter().collect(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3533,6 +3564,7 @@ mod tests {
                 .map(|id| Commit {
                     id,
                     parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
                     attributions: 0..0,
@@ -3673,6 +3705,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3724,6 +3757,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3843,6 +3877,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -3924,6 +3959,7 @@ mod tests {
                 .map(|n| Commit {
                     id: gix::ObjectId::Sha1([n; 20]),
                     parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
                     attributions: 0..0,
@@ -4008,6 +4044,7 @@ mod tests {
                 parent_ids: [gix::ObjectId::Sha1([2; 20]), gix::ObjectId::Sha1([3; 20])]
                     .into_iter()
                     .collect(),
+                author_time: gix::date::Time::default(),
                 committer_time: gix::date::Time::default(),
                 author: author(b"author", b"author@example.com"),
                 attributions: 0..0,
@@ -4020,6 +4057,7 @@ mod tests {
             Commit {
                 id: gix::ObjectId::Sha1([2; 20]),
                 parent_ids: Default::default(),
+                author_time: gix::date::Time::default(),
                 committer_time: gix::date::Time::default(),
                 author: author(b"author", b"author@example.com"),
                 attributions: 0..0,
@@ -4780,6 +4818,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -4838,6 +4877,7 @@ mod tests {
                 .map(|n| Commit {
                     id: gix::ObjectId::Sha1([n; 20]),
                     parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
                     attributions: 0..0,
@@ -4902,6 +4942,7 @@ mod tests {
         let commit = |n: u8| Commit {
             id: gix::ObjectId::Sha1([n; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -5030,6 +5071,7 @@ mod tests {
         let commit = Commit {
             id,
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,
@@ -5076,7 +5118,7 @@ mod tests {
             &decorations,
             &mailmap,
             MetadataOptions {
-                show_committer_date: true,
+                date_mode: DateMode::Committer,
                 show_author_name: true,
                 show_emails: false,
                 show_trailers: true,
@@ -5136,6 +5178,7 @@ mod tests {
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
             committer_time: gix::date::Time::default(),
             author: author(b"author", b"author@example.com"),
             attributions: 0..0,

From 8a51821d0d953db8ef97bb2826a039c4737633f6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sun, 16 Aug 2026 21:45:15 +0200
Subject: [PATCH 166/282] fix: keep selected ref-tree disks uninverted
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Preserve the selected reference label’s reverse-video emphasis while leaving its disk marker unchanged. This keeps the rounded rail visually stable and avoids turning ordinary referenced commit disks into filled selection blocks.

Synthetic topology nodes have no reference label to carry that emphasis, so their selected disk remains inverted. Rendering assertions cover both styles and the ref-tree specification documents the distinction.
---
 gix-tix/spec.md         |  4 +++-
 gix-tix/src/ref_tree.rs | 42 ++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 125262cee76..9dcf85e0bbf 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -214,7 +214,9 @@ without trading responsiveness for metadata that is not visible.
   and cached only for reference rows visible in the viewport.
 - The ref-tree orders tips above roots and renders one retained or boundary
   node per row. Rounded ancestry lanes precede aligned counts and labels; their
-  disk is the node marker, so counts do not repeat it.
+  disk is the node marker, so counts do not repeat it. Selection emphasizes the
+  label without inverting the disk, while a selected synthetic node inverts its
+  otherwise-unlabelled disk.
 - Rendering clips lanes and node labels to the viewport.
 - `Tab` switches nearest-direction and topological movement.
   Nearest movement chooses the closest node in the requested screen direction.
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 4c687210bc4..e26712478af 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1255,7 +1255,19 @@ fn draw_nodes(
                 style = style.add_modifier(Modifier::DIM);
             }
         }
-        put(frame, area, offset, point, if node.is_head { '@' } else { '●' }, style);
+        let marker_style = if selected == Some(index) && node.is_anchor {
+            style.remove_modifier(Modifier::REVERSED)
+        } else {
+            style
+        };
+        put(
+            frame,
+            area,
+            offset,
+            point,
+            if node.is_head { '@' } else { '●' },
+            marker_style,
+        );
         draw_text(
             frame,
             area,
@@ -2348,6 +2360,34 @@ mod tests {
             !rendered.contains("5●"),
             "the rail marker is not repeated after a count"
         );
+        let selected = tree.selected.expect("the ref-tree selects a node");
+        let placed = tree.placed.as_ref().expect("drawing places the ref-tree");
+        let point = placed.nodes[selected];
+        assert!(
+            !terminal.backend().buffer()[(point.x as u16, point.y as u16)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the selected disk is not inverted"
+        );
+        assert!(
+            terminal.backend().buffer()[(placed.rail_width as u16, point.y as u16)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the selected node label remains inverted"
+        );
+
+        let fork = tree.overview.as_ref().expect("the ref-tree exists").by_commit
+            [&graph.index(id(2)).expect("the fork exists")];
+        tree.selected = Some(fork);
+        tree.selection_changed();
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        let point = tree.placed.as_ref().expect("drawing places the ref-tree").nodes[fork];
+        assert!(
+            terminal.backend().buffer()[(point.x as u16, point.y as u16)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "a selected synthetic node keeps its disk inverted"
+        );
         Ok(())
     }
 

From 0fd0cb5a58613ae69d08ee916fcf9366767f43fd Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 04:50:48 +0200
Subject: [PATCH 167/282] Document stderr for tix diagnostics
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reserve stdout for each command’s primary data output and direct warnings, diagnostics, and informational messages to stderr.

The existing unavailable-hidden-revision warnings already follow this convention; record it in gix-tix/AGENTS.md for future changes without adding dedicated regression coverage.
---
 gix-tix/AGENTS.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 8763fa5725c..2ed748e22c2 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -12,6 +12,11 @@
   or resource-ownership change to tix. Update the specification and its
   regression coverage in the same semantic patch as the implementation.
 
+## Command output
+
+- Write warnings, diagnostics, and informational messages to stderr. Reserve
+  stdout for a command's primary data output so it remains safe to redirect.
+
 ## Test repositories
 
 - Open fixture repositories through `crate::test_repository::open()` or

From b5c31a94cdf6269963c977ebdc7498dc908ccb07 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 04:59:35 +0200
Subject: [PATCH 168/282] feat: distinguish ref-tree counts with bullets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Append U+2022 BULLET to exact commit counts in the interactive ref-tree, producing compact labels such as `500•`. Keep U+25CF BLACK CIRCLE exclusively for actual topology nodes so the two visual roles remain distinct.

Update the rendering assertions and behavioral specification to record the count-unit convention.
---
 gix-tix/spec.md         | 8 ++++----
 gix-tix/src/ref_tree.rs | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 9dcf85e0bbf..c9ac09bdcb3 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -205,7 +205,7 @@ without trading responsiveness for metadata that is not visible.
   its commit remains available.
 - The selected node shows the exact number of commits reachable
   through all parents. Other reference and raw-tip nodes show the number reachable
-  from them but not from the selection as `N●`; multiple labels at one commit
+  from them but not from the selection as `N•`; multiple labels at one commit
   share one count. Space fixes this count anchor at the selected node or clears it
   when pressed there again, so cursor navigation can reuse reachability and layout
   caches. Selected first-parent ancestry is emphasized, other reachable history is
@@ -214,9 +214,9 @@ without trading responsiveness for metadata that is not visible.
   and cached only for reference rows visible in the viewport.
 - The ref-tree orders tips above roots and renders one retained or boundary
   node per row. Rounded ancestry lanes precede aligned counts and labels; their
-  disk is the node marker, so counts do not repeat it. Selection emphasizes the
-  label without inverting the disk, while a selected synthetic node inverts its
-  otherwise-unlabelled disk.
+  `●` disk is the node marker, while the smaller `•` is the commit-count unit.
+  Selection emphasizes the label without inverting the disk, while a selected
+  synthetic node inverts its otherwise-unlabelled disk.
 - Rendering clips lanes and node labels to the viewport.
 - `Tab` switches nearest-direction and topological movement.
   Nearest movement chooses the closest node in the requested screen direction.
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index e26712478af..e00d339ed2b 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1296,7 +1296,7 @@ fn draw_nodes(
 }
 
 fn rail_label(node: &Node, count: Option<usize>) -> String {
-    let mut out = count.map_or_else(String::new, |count| count.to_string());
+    let mut out = count.map_or_else(String::new, |count| format!("{count}•"));
     let suffix = node_label(node);
     if !out.is_empty() && !suffix.is_empty() {
         out.push(' ');
@@ -2349,11 +2349,11 @@ mod tests {
         assert!(rendered.contains("topic"), "the rounded ref-tree shows topic");
         assert!(rendered.contains("ref-tree ·"), "the footer identifies the ref-tree");
         assert!(
-            rendered.contains("5 main"),
+            rendered.contains("5• main"),
             "the selected reference shows its exact count"
         );
         assert!(
-            rendered.contains("1 topic"),
+            rendered.contains("1• topic"),
             "visible references show relative exact counts"
         );
         assert!(

From 83d795505085ae64be21240399a62a8b4af1c002 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:28:58 +0200
Subject: [PATCH 169/282] feat: color ref-tree nodes by history visibility

Track the completed history projection separately from the expanded ref-tree graph. Referenced commits already present in history use the current-history cyan, while linked-worktree nodes outside history use dark green.

Update the cached color state only when lane computation finishes so cursor drawing remains allocation-free, and cover the visibility precedence in the interactive renderer test.
---
 gix-tix/spec.md         |  2 ++
 gix-tix/src/lib.rs      |  1 +
 gix-tix/src/ref_tree.rs | 49 ++++++++++++++++++++++++++++++++++++-----
 3 files changed, 46 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c9ac09bdcb3..224b6fb6a56 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -215,6 +215,8 @@ without trading responsiveness for metadata that is not visible.
 - The ref-tree orders tips above roots and renders one retained or boundary
   node per row. Rounded ancestry lanes precede aligned counts and labels; their
   `●` disk is the node marker, while the smaller `•` is the commit-count unit.
+  Referenced or raw-tip nodes whose commits are present in history use the
+  current-history cyan; other linked-worktree nodes use dark green.
   Selection emphasizes the label without inverting the disk, while a selected
   synthetic node inverts its otherwise-unlabelled disk.
 - Rendering clips lanes and node labels to the viewport.
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index f98c7cf436c..0914e4713cc 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1225,6 +1225,7 @@ fn event_loop(
             match result {
                 Ok((rows, graph, lane_time)) => {
                     app.finish_lane_computation(rows, graph, lane_time);
+                    ref_tree.set_history_commits(app.rows.iter().map(|row| row.id));
                     if return_to_history_after_refresh.take().is_some() {
                         ref_tree.leave();
                     }
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index e00d339ed2b..b20a3844885 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -166,6 +166,7 @@ pub(crate) struct Tree {
     edit_expanded: bool,
     remote_deletions: Vec<RemoteDeletion>,
     message: Option<String>,
+    history_commits: HashSet<ObjectId>,
 }
 
 impl Tree {
@@ -191,6 +192,11 @@ impl Tree {
         self.message = Some(message.into());
     }
 
+    pub(crate) fn set_history_commits(&mut self, commits: impl IntoIterator<Item = ObjectId>) {
+        self.history_commits.clear();
+        self.history_commits.extend(commits);
+    }
+
     pub(crate) fn rebuild(&mut self, graph: &HistoryGraph, refs: &RefSnapshot, decorations: &Decorations) {
         let selected = self
             .selected
@@ -458,6 +464,7 @@ impl Tree {
             selected,
             self.motion,
             &self.choices,
+            &self.history_commits,
         );
         let footer_text = if let Some(message) = &self.message {
             message.clone()
@@ -1221,6 +1228,7 @@ fn draw_nodes(
     selected: Option<usize>,
     motion: Motion,
     choices: &[usize],
+    history_commits: &HashSet<ObjectId>,
 ) {
     for (index, node) in overview.nodes.iter().enumerate() {
         let point = placed.nodes[index];
@@ -1241,10 +1249,21 @@ fn draw_nodes(
             )
             .expect("writing to a string cannot fail");
         }
-        let mut style = node.decorations.first().map_or_else(
-            || Style::default().fg(Color::LightBlue),
-            |decoration| decoration_style(decoration.kind),
-        );
+        let mut style = if node.is_anchor && history_commits.contains(&node.id) {
+            Style::default().fg(Color::Cyan)
+        } else if node.decorations.iter().any(|decoration| {
+            matches!(
+                decoration.kind,
+                DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
+            )
+        }) {
+            Style::default().fg(Color::Green)
+        } else {
+            node.decorations.first().map_or_else(
+                || Style::default().fg(Color::LightBlue),
+                |decoration| decoration_style(decoration.kind),
+            )
+        };
         if selected == Some(index) {
             style = style.add_modifier(Modifier::REVERSED | Modifier::BOLD);
         } else if let Some(overlay) = overlay {
@@ -2331,8 +2350,10 @@ mod tests {
 
     #[test]
     fn interactive_ref_tree_renders_exact_visible_counts() -> gix_testtools::Result {
-        let (graph, refs, decorations) = fixture();
+        let (graph, refs, mut decorations) = fixture();
+        decorations.get_mut(&id(5)).expect("topic is decorated")[0].kind = DecorationKind::WorktreeBranch;
         let mut tree = Tree::default();
+        tree.set_history_commits([id(6)]);
         tree.rebuild(&graph, &refs, &decorations);
         let mut terminal = Terminal::new(TestBackend::new(100, 18))?;
 
@@ -2363,6 +2384,7 @@ mod tests {
         let selected = tree.selected.expect("the ref-tree selects a node");
         let placed = tree.placed.as_ref().expect("drawing places the ref-tree");
         let point = placed.nodes[selected];
+        let rail_width = placed.rail_width;
         assert!(
             !terminal.backend().buffer()[(point.x as u16, point.y as u16)]
                 .modifier
@@ -2370,11 +2392,26 @@ mod tests {
             "the selected disk is not inverted"
         );
         assert!(
-            terminal.backend().buffer()[(placed.rail_width as u16, point.y as u16)]
+            terminal.backend().buffer()[(rail_width as u16, point.y as u16)]
                 .modifier
                 .contains(Modifier::REVERSED),
             "the selected node label remains inverted"
         );
+        let topic =
+            tree.overview.as_ref().expect("the ref-tree exists").by_commit[&graph.index(id(5)).expect("topic exists")];
+        let point = tree.placed.as_ref().expect("drawing places the ref-tree").nodes[topic];
+        assert_eq!(
+            terminal.backend().buffer()[(rail_width as u16, point.y as u16)].fg,
+            Color::Green,
+            "an out-of-history linked worktree uses dark green"
+        );
+        tree.set_history_commits([id(6), id(5)]);
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        assert_eq!(
+            terminal.backend().buffer()[(rail_width as u16, point.y as u16)].fg,
+            Color::Cyan,
+            "history visibility takes precedence with the bright current-history color"
+        );
 
         let fork = tree.overview.as_ref().expect("the ref-tree exists").by_commit
             [&graph.index(id(2)).expect("the fork exists")];

From 3124a3a78c2fa07d1e01b9a99aaa3012bf2e7939 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:30:43 +0200
Subject: [PATCH 170/282] fix: omit redundant detached-worktree labels
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Suppress the current detached worktree’s textual `@directory` decoration in history rows because the graph marker already identifies HEAD with `@`.

Keep foreign detached worktree labels, detached-worktree discovery, dirty-state display, and ref-tree decorations unchanged.
---
 gix-tix/spec.md   | 4 +++-
 gix-tix/src/ui.rs | 9 +++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 224b6fb6a56..2f43644818d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -138,7 +138,9 @@ without trading responsiveness for metadata that is not visible.
   A detached foreign worktree is shown as `directory@` at its actual `HEAD`,
   without a pin marker. Its symbolic HEAD pin is shown separately as `★branch`
   at that branch's actual tip. The worktree administration name is used when no
-  directory basename is available. Identical labels are deduplicated.
+  directory basename is available. A detached current worktree is identified by
+  the graph `@` alone and has no redundant `@directory` label. Identical labels
+  are deduplicated.
 - When reference labels are hidden, worktree labels are visible only on the
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 20b767e098c..38b4da70256 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1749,6 +1749,7 @@ fn metadata_line<'a>(
     let mut labels = row_decorations
         .iter()
         .filter(|decoration| !matches!(decoration.kind, DecorationKind::Pin | DecorationKind::Stash))
+        .filter(|decoration| decoration.kind != DecorationKind::CurrentWorktreeDetached)
         .filter(|decoration| match ref_mode {
             _ if decoration.kind == DecorationKind::Head => false,
             _ if decoration.kind == DecorationKind::Review => true,
@@ -3293,6 +3294,10 @@ mod tests {
                     name: "detached".into(),
                     kind: DecorationKind::WorktreeDetached,
                 },
+                Decoration {
+                    name: "current-detached".into(),
+                    kind: DecorationKind::CurrentWorktreeDetached,
+                },
                 Decoration {
                     name: "HEAD".into(),
                     kind: DecorationKind::Head,
@@ -3305,6 +3310,10 @@ mod tests {
         assert!(row.contains("@current"));
         assert!(row.contains("main@"));
         assert!(row.contains("detached@"));
+        assert!(
+            !row.contains("current-detached"),
+            "the graph @ already identifies the current detached worktree"
+        );
         assert!(!row.contains("HEAD"), "a worktree label replaces textual HEAD");
         let x = row.find("main@").expect("the worktree label is visible") as u16;
         assert_eq!(terminal.backend().buffer()[(x, 0)].fg, Color::LightBlue);

From b508fcf0b5e6c5e93aa14c6109e28b147cdea5e0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:31:35 +0200
Subject: [PATCH 171/282] fix: retain direct pins while HEAD is attached

Treat every ordinary worktree-local pin away from the current attached HEAD as a history tip. Previously, unrelated direct pins were filtered out until HEAD detached, which made a stashed review tree disappear after travelling back to its branch even though its departure pin still existed.

Extend the review-boundary test through a fresh attached-HEAD snapshot and verify that returning consumes the retained pin and restores review state.
---
 gix-tix/spec.md                 | 11 ++++++-----
 gix-tix/src/edit/time_travel.rs | 16 ++++++++++++++++
 gix-tix/src/history.rs          |  9 +--------
 3 files changed, 23 insertions(+), 13 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2f43644818d..428978fa8ec 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -334,10 +334,9 @@ The Enter key is written as `<enter>` throughout.
   successor is not pinned; a distinct departure preserves its rewritten identity.
 - While `HEAD` is detached, every valid pin, including the HEAD pin, from the
   current worktree augments implicit and explicit revision tips. While it is
-  attached, symbolic ordinary pins and direct pins at strict descendants of
-  `HEAD` do so while the HEAD pin is inactive. This lets explicitly pinned
-  references enter history while preserving rewritten leaves after a history
-  rebase moves the checked-out branch down its stack. Pins from other worktrees, dangling,
+  attached, every ordinary pin away from `HEAD` does so while the HEAD pin is
+  inactive. This lets explicitly pinned references and unrelated retained trees
+  remain in history. Pins from other worktrees, dangling,
   malformed, and non-commit pins do not enter the view or its decorations.
   Normal hidden-revision exclusions still apply.
 - One or more worktree pins at a commit are shown as a single blue `📌`
@@ -371,7 +370,9 @@ The Enter key is written as `<enter>` throughout.
   `refs/worktree/tix/review/stashes/N`; ignored files remain untouched. Crossing
   into any commit in that review tree restores the state with `git stash apply
   --index` and always removes the companion ref after Git returns. Apply conflicts
-  remain in the ordinary index/worktree conflict workflow. Nested trees use the
+  remain in the ordinary index/worktree conflict workflow. Leaving a review tree
+  retains its leaf with the normal direct departure pin even after returning to
+  attached history; returning through that pin consumes it. Nested trees use the
   nearest review-root ancestor.
 - When loaded worktree status shows staged, unstaged, or untracked changes without
   conflicts, the edit menu offers `stas[h]` at the selected `@` entry. Missing or
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 27358054a9a..1cd3c98009c 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -962,6 +962,18 @@ mod tests {
 
         perform(&repository_path, false, tip, &graph, &[started.commit], &[], false)?.complete()?;
         let repo = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            repo.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "leaving the review returns to the attached branch"
+        );
+        let snapshot = history::snapshot(&repo, &[], &[], false)?;
+        assert_eq!(snapshot.pins.len(), 1, "only the review-tree departure remains pinned");
+        assert_eq!(snapshot.pins[0].id, child);
+        assert!(
+            snapshot.view_tips.contains(&child),
+            "a fresh attached-HEAD snapshot retains the review-tree leaf"
+        );
         assert!(repo.try_find_reference(stash_name.as_ref())?.is_some());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
         assert!(
@@ -977,6 +989,10 @@ mod tests {
             "returning through any review descendant restores exact review state"
         );
         let repo = crate::test_repository::open(fixture.path())?;
+        assert!(
+            history::all_pins(&repo)?.iter().all(history::Pin::is_head),
+            "returning consumes the ordinary review-tree pin"
+        );
         assert!(repo.try_find_reference(stash_name.as_ref())?.is_none());
         assert_eq!(repo.find_reference("refs/stash")?.id().detach(), existing_stash);
         Ok(())
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 8aa9d26920c..719fcf322a4 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1490,14 +1490,7 @@ pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
     }
     Ok(pins
         .into_iter()
-        .filter(|pin| {
-            !pin.is_head()
-                && pin.id != head_id
-                && (pin.target.try_name().is_some()
-                    || repo
-                        .merge_base(head_id, pin.id)
-                        .is_ok_and(|base| base.as_ref() == head_id))
-        })
+        .filter(|pin| !pin.is_head() && pin.id != head_id)
         .collect())
 }
 

From 1ce02d12d37798e85e9c8ed79c3834b92ff71bce Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:49:48 +0200
Subject: [PATCH 172/282] feat: show saved review state in history

Active review auto-stashes were deliberately kept out of traversal, but that also hid whether a review leaf had worktree state waiting to be restored.

Resolve each internal review stash commit to its first parent and render the existing stash marker on that saved leaf. The internal reference name and stash commit remain absent from history topology.
---
 gix-tix/spec.md        |  8 +++++---
 gix-tix/src/history.rs | 41 ++++++++++++++++++++++++++++++++++-------
 2 files changed, 39 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 428978fa8ec..35ca43967d1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -385,7 +385,9 @@ The Enter key is written as `<enter>` throughout.
   restores it with `git stash apply --index` and consumes its companion ref after
   Git returns, including when application leaves conflicts to resolve. Manual
   commit stashes use the same plumbing during reviews, while automatic review
-  stashes retain their review-tree identity and namespace.
+  stashes retain their review-tree identity and namespace. An active automatic
+  review stash likewise shows `🎁` on the review leaf whose worktree state it
+  saved, without exposing its internal reference or stash commit to traversal.
 - At a selected `@` with a commit stash, the edit menu offers `unstas[h]` even
   when other worktree changes are present. It applies and consumes the stash in
   place through the same path used when time travel returns to that commit.
@@ -674,8 +676,8 @@ space first; changes blocks adapt within the remaining history width.
   return checkout is restored, and the departure pin is consumed. Finishing a
   review or dropping one through a rebase todo also deletes its review ref and
   optional saved-worktree ref atomically; reordering or rewriting it preserves the
-  headers and resources. Review stash refs are internal: they are neither traversal
-  tips nor decorations.
+  headers and resources. Review stash refs are internal: they are not traversal
+  tips or named decorations, but their saved review leaf carries a `🎁` marker.
 
 ### Forget commits
 
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 719fcf322a4..f40d9fa664c 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1757,6 +1757,23 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             continue;
         }
         if full_name.as_bstr().starts_with(REVIEW_STASH_PREFIX) {
+            let leaf: Result<Option<ObjectId>> = (|| {
+                let stash = repo.find_commit(reference.peel_to_id()?)?;
+                Ok(stash.parent_ids().next().map(gix::Id::detach))
+            })();
+            let leaf = match leaf {
+                Ok(leaf) => leaf,
+                Err(err) => {
+                    tracing::warn!(name = %full_name, error = %err, "ignored malformed review stash reference");
+                    None
+                }
+            };
+            if let Some(id) = leaf {
+                out.entry(id).or_default().push(Decoration {
+                    name: "stash".into(),
+                    kind: DecorationKind::Stash,
+                });
+            }
             continue;
         }
         if full_name.as_bstr().starts_with(STASH_PREFIX) {
@@ -2755,10 +2772,14 @@ mod tests {
     }
 
     #[test]
-    fn review_resources_are_not_history_tips_and_stashes_are_not_decorations() -> gix_testtools::Result {
+    fn review_resources_are_not_history_tips_and_stashes_decorate_the_saved_leaf() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repo = crate::test_repository::open(fixture.path())?;
         let review = repo.rev_parse_single("topic")?.detach();
+        let mut stash = repo.find_commit(review)?.decode()?.into_owned()?;
+        stash.parents = [review].into_iter().collect();
+        stash.message = "review stash".into();
+        let stash = repo.write_object(&stash)?.detach();
         repo.reference(
             "refs/worktree/tix/review/1",
             review,
@@ -2767,7 +2788,7 @@ mod tests {
         )?;
         repo.reference(
             "refs/worktree/tix/review/stashes/1",
-            review,
+            stash,
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test review stash",
         )?;
@@ -2777,12 +2798,18 @@ mod tests {
             !snapshot(&repo, &[], &[], false)?.view_tips.contains(&review),
             "review resources do not retain history"
         );
+        let decorations = decorations(&repo, &[], &worktree_checkouts(&repo))?;
+        assert!(
+            decorations.get(&review).is_some_and(|decorations| decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::Stash)),
+            "saved review state decorates the review leaf"
+        );
         assert!(
-            decorations(&repo, &[], &worktree_checkouts(&repo))?
-                .values()
-                .flatten()
-                .all(|decoration| !decoration.name.contains_str("stashes")),
-            "saved review state is an internal resource"
+            decorations.get(&stash).is_none_or(|decorations| decorations
+                .iter()
+                .all(|decoration| decoration.kind != DecorationKind::Stash)),
+            "the internal stash commit is not decorated"
         );
         Ok(())
     }

From c197dfe9a49449d459bdf01b4ae58baffb9ffb6c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:51:44 +0200
Subject: [PATCH 173/282] fix: give reviews independent return pins

Review startup reused any existing pin with the same target. Multiple reviews could therefore record one return ref, and finishing either review consumed the shared resource.

Split out an always-create pin path and use it for review departures only. Ordinary time travel retains pin reuse, while each review now owns a return pin with an independent lifetime.
---
 gix-tix/spec.md                 |  6 ++++--
 gix-tix/src/edit/review.rs      | 10 ++++------
 gix-tix/src/edit/time_travel.rs | 29 ++++++++++++++++++++++++++++-
 3 files changed, 36 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 35ca43967d1..2eaeffa89ff 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -644,12 +644,14 @@ space first; changes blocks adapt within the remaining history width.
   files, and non-pending reviewed-tip and base commits. Only after confirmation,
   tix creates the first unused direct `refs/worktree/tix/review/N` ref at the
   reviewed tip and an unsigned ordinary `review` commit at the base with
-  `tix-rebase: onto refs/worktree/tix/review/N`. Starting always creates or reuses
-  a normal worktree-local tix pin for the departure, symbolic for an attached
+  `tix-rebase: onto refs/worktree/tix/review/N`. Starting always creates a
+  dedicated worktree-local tix pin for the departure, symbolic for an attached
   branch and direct for a detached checkout, and names it in the
   `tix-review-return-to` header. HEAD is detached at the review commit,
   its base tree fills the index, and the reviewed tip tree remains in the worktree
   as unstaged changes. The pin keeps the departure and its ancestry visible.
+  Reviews never share return pins, even when they depart from the same ref or
+  commit, so finishing one cannot consume another review's return path.
   Finishing maps the recorded return target through the rewrite and uses normal
   time-travel checkout semantics to restore attached or detached HEAD and consume
   its pin. Existing symbolic review refs remain readable.
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index b6728372144..ee459f3dd6a 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -127,12 +127,10 @@ pub(crate) fn start(
     let departure_pin = match restore.1 {
         Some(id) => {
             let target = restore.0.clone().map_or(Target::Object(id), Target::Symbolic);
-            Some(super::time_travel::create_or_reuse_pin(
-                &repo,
-                target,
-                id,
-                "tix review departure",
-            )?)
+            Some((
+                super::time_travel::create_pin(&repo, target, id, "tix review departure")?,
+                true,
+            ))
         }
         None => None,
     };
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 1cd3c98009c..1b1da7929b8 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -608,6 +608,15 @@ pub(crate) fn create_or_reuse_pin(
     if let Some(pin) = pins.iter().find(|pin| !pin.is_head() && pin.target == target) {
         return Ok((pin.clone(), false));
     }
+    Ok((create_pin(repository, target, id, reflog_message)?, true))
+}
+
+pub(crate) fn create_pin(
+    repository: &gix::Repository,
+    target: Target,
+    id: ObjectId,
+    reflog_message: &str,
+) -> Result<history::Pin> {
     let hex = id.to_hex().to_string();
     let mut suffix_len = 8.min(hex.len());
     let mut number = 2;
@@ -650,7 +659,7 @@ pub(crate) fn create_or_reuse_pin(
             deref: false,
         }])
         .context("could not create tix pin")?;
-    Ok((history::Pin { name, target, id }, true))
+    Ok(history::Pin { name, target, id })
 }
 
 pub(super) fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
@@ -1300,6 +1309,24 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn explicitly_created_pins_have_independent_lifetimes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let selected = repository.rev_parse_single("main")?.detach();
+        let target = Target::Object(selected);
+        let first = create_pin(&repository, target.clone(), selected, "first review")?;
+        let second = create_pin(&repository, target, selected, "second review")?;
+
+        assert_ne!(first.name, second.name, "reviews never share ownership of a return pin");
+        delete_pin(&repository, &first)?;
+        assert!(
+            repository.try_find_reference(second.name.as_ref())?.is_some(),
+            "consuming one review's pin leaves the other review's return pin intact"
+        );
+        Ok(())
+    }
+
     #[test]
     fn sideways_travel_preserves_an_unreferenced_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;

From 5e41d2a2b9be80b67ea25f60fa8e7799fe2f4a3f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 05:53:05 +0200
Subject: [PATCH 174/282] feat: recover reviews with missing return pins

Older reviews can retain a return-pin name after another review has consumed the shared pin. Finishing previously stopped at an unrecoverable missing-reference error even though the reviewed history remained valid.

Treat only an absent recorded return ref as a request for recovery. Constrain history navigation to visible non-review descendants of the reviewed tip, then let Enter finish onto the selected commit with detached checkout semantics; Escape leaves the review untouched.
---
 gix-tix/spec.md            |   7 +++
 gix-tix/src/app.rs         | 117 +++++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/review.rs | 112 +++++++++++++++++++++++++----------
 gix-tix/src/lib.rs         |  17 +++++-
 gix-tix/src/ui.rs          |   7 ++-
 5 files changed, 220 insertions(+), 40 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2eaeffa89ff..87bb7e73a73 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -673,6 +673,13 @@ space first; changes blocks adapt within the remaining history width.
   review-side leaf, the reviewed tip's prior descendants are lazily reparented
   after it; with multiple leaves they branch directly after the finished review.
   The review ref is deleted in the same atomic ref/worktree transaction.
+- If the recorded review return ref is missing, finishing leaves the repository
+  untouched and limits navigation to visible non-review commits descended from
+  the reviewed tip. The reviewed tip is selected initially when visible;
+  otherwise the nearest eligible row is selected. `<enter>` finishes the review,
+  maps the chosen commit through that rewrite, and checks it out detached, while
+  Escape cancels recovery.
+  Hidden, unrelated, and review commits are not selectable return targets.
 - Forget is unavailable for a review commit with descendants. Forgetting a review
   leaf cancels the review: tracked review changes are discarded, its recorded
   return checkout is restored, and the departure pin is consumed. Finishing a
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index b55d7f9e591..357bfef2c06 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -360,7 +360,10 @@ pub(crate) enum Effect {
         tip: ObjectId,
         base: ObjectId,
     },
-    FinishReview(ObjectId),
+    FinishReview {
+        review: ObjectId,
+        return_to: Option<ObjectId>,
+    },
     TimeTravel(ObjectId),
     Unpin(ObjectId),
     VerifySignatures(Vec<ObjectId>),
@@ -431,6 +434,7 @@ pub(crate) struct App {
     pub(crate) show_selection_tail: bool,
     reachability_anchor: Option<ObjectId>,
     review_tip: Option<ObjectId>,
+    review_return: Option<(ObjectId, ObjectId)>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
@@ -522,6 +526,7 @@ impl App {
             show_selection_tail: true,
             reachability_anchor: None,
             review_tip: None,
+            review_return: None,
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
@@ -1023,6 +1028,22 @@ impl App {
                 changes.error = None;
                 return vec![Effect::OpenDiff(pane, changes.selected)];
             }
+            Action::OpenDiff if self.review_return.is_some() => {
+                let (review, _) = self.review_return.expect("review return selection is active");
+                let Some(return_to) = self
+                    .selected
+                    .filter(|index| self.is_row_reachable(*index) && self.reachable_row_selectable(*index))
+                    .and_then(|index| self.rows.get(index))
+                    .map(|row| row.id)
+                else {
+                    return Vec::new();
+                };
+                self.clear_review_selection();
+                return vec![Effect::FinishReview {
+                    review,
+                    return_to: Some(return_to),
+                }];
+            }
             Action::OpenDiff if self.review_tip.is_some() => {
                 let tip = self.review_tip.expect("review selection has a tip");
                 let Some(base) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) else {
@@ -1110,9 +1131,10 @@ impl App {
                 }];
             }
             Action::Review if self.can_finish_review() => {
-                return vec![Effect::FinishReview(
-                    self.rows[self.selected.expect("finishing review requires a selection")].id,
-                )];
+                return vec![Effect::FinishReview {
+                    review: self.rows[self.selected.expect("finishing review requires a selection")].id,
+                    return_to: None,
+                }];
             }
             Action::Review if self.can_review() => {
                 let tip = self.rows[self.selected.expect("review requires a selection")].id;
@@ -1164,7 +1186,9 @@ impl App {
                 }
             }
             Action::ForceQuit => return vec![Effect::Quit],
-            Action::Cancel if self.review_tip.is_some() => self.clear_review_selection(),
+            Action::Cancel if self.review_tip.is_some() || self.review_return.is_some() => {
+                self.clear_review_selection()
+            }
             Action::Cancel | Action::Quit if self.changes_focus.is_some() => self.focus_history(),
             Action::Cancel if self.state == State::Loading => {
                 self.state = State::Cancelling;
@@ -1520,10 +1544,40 @@ impl App {
 
     fn clear_review_selection(&mut self) {
         self.review_tip = None;
+        self.review_return = None;
         self.reachability_anchor = None;
         self.reachable_rows = None;
     }
 
+    pub(crate) fn select_review_return(&mut self, review: ObjectId, tip: ObjectId) -> bool {
+        let reachable: Vec<_> = self
+            .rows
+            .iter()
+            .enumerate()
+            .map(|(index, row)| !row.is_review && !self.is_row_hidden(index) && self.is_known_ancestor(tip, row.id))
+            .collect();
+        let current = self.selected.unwrap_or_default();
+        let selected = self
+            .rows
+            .iter()
+            .position(|row| row.id == tip)
+            .filter(|index| reachable[*index])
+            .or_else(|| {
+                reachable
+                    .iter()
+                    .enumerate()
+                    .filter_map(|(index, reachable)| reachable.then_some(index))
+                    .min_by_key(|index| index.abs_diff(current))
+            });
+        let Some(selected) = selected else { return false };
+        self.review_tip = None;
+        self.review_return = Some((review, tip));
+        self.reachability_anchor = None;
+        self.reachable_rows = Some(reachable);
+        self.select(selected);
+        true
+    }
+
     pub(crate) fn focus_history(&mut self) {
         self.changes_focus = None;
         self.focus_feedback = None;
@@ -1798,6 +1852,10 @@ impl App {
         self.review_tip.is_some()
     }
 
+    pub(crate) fn review_return_selection_active(&self) -> bool {
+        self.review_return.is_some()
+    }
+
     fn can_edit_head(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -2768,7 +2826,13 @@ mod tests {
         app.set_head_edit_availability(false, false, false, false, true, false, false);
         complete(&mut app);
 
-        assert_eq!(app.update(Action::Review), vec![Effect::FinishReview(id(2))]);
+        assert_eq!(
+            app.update(Action::Review),
+            vec![Effect::FinishReview {
+                review: id(2),
+                return_to: None,
+            }]
+        );
 
         app.set_worktree_head(Some(id(4)), false);
         assert!(
@@ -2777,6 +2841,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn a_missing_review_return_can_select_a_detached_checkout() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(6, &[4]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[1]),
+            row_with_parents(2, &[1]),
+            row_with_parents(3, &[1]),
+            row(1),
+        ]);
+        std::sync::Arc::make_mut(&mut app.rows[3]).is_review = true;
+        app.hidden_rows.insert(id(6));
+        app.selected = Some(3);
+        complete(&mut app);
+
+        assert!(app.select_review_return(id(2), id(4)));
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+        assert!(!app.is_row_reachable(0), "hidden descendants are not return candidates");
+        assert!(!app.is_row_reachable(3), "review commits are not return candidates");
+        assert!(!app.is_row_reachable(4), "unrelated commits are not return candidates");
+        app.update(Action::MoveUp);
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(5)),
+            "navigation skips ineligible rows"
+        );
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::FinishReview {
+                review: id(2),
+                return_to: Some(id(5)),
+            }]
+        );
+        assert!(!app.review_return_selection_active());
+
+        assert!(app.select_review_return(id(2), id(4)));
+        assert!(app.update(Action::Cancel).is_empty());
+        assert!(!app.review_return_selection_active());
+    }
+
     #[test]
     fn forgetting_a_non_merge_tip_requires_a_second_d_and_navigation_cancels_it() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index ee459f3dd6a..2ed857b17f3 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -24,6 +24,11 @@ pub(crate) struct Finished {
     pub outcome: super::rebase::Outcome,
 }
 
+pub(crate) enum Finish {
+    Complete(Finished),
+    SelectReturn { tip: ObjectId },
+}
+
 pub(crate) fn reference(commit: &gix::objs::Commit) -> Result<Option<gix::refs::FullName>> {
     commit
         .extra_headers
@@ -205,7 +210,12 @@ pub(crate) fn start(
 }
 
 #[tracing::instrument(skip_all, fields(%review))]
-pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, review: ObjectId) -> Result<Finished> {
+pub(crate) fn finish(
+    repo: gix::Repository,
+    graph: &history::HistoryGraph,
+    review: ObjectId,
+    fallback: Option<ObjectId>,
+) -> Result<Finish> {
     let workdir = repo
         .workdir()
         .context("finishing review requires a worktree")?
@@ -231,27 +241,39 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
         .context("the review reference does not resolve")?
         .detach();
     let delete_refs = resources(&repo, review_ref.clone())?;
-    let return_to = return_to(&commit)?.or(legacy_reattach);
-    let checkout = return_to
-        .map(|name| {
-            let mut reference = repo
-                .find_reference(name.as_ref())
-                .context("the review return reference is missing")?;
-            let checkout_reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
-                reference.target().try_name().map(ToOwned::to_owned)
-            } else {
-                Some(name)
-            };
-            let id = reference
-                .peel_to_id()
-                .context("the review return reference does not resolve")?
-                .detach();
-            if !graph.is_ancestor(tip, id) {
-                anyhow::bail!("the review return reference no longer descends from the reviewed commit");
-            }
-            Ok((id, checkout_reference))
-        })
-        .transpose()?;
+    let return_name = return_to(&commit)?.or(legacy_reattach);
+    let has_return = return_name.is_some();
+    let checkout = if let Some(id) = fallback {
+        if !graph.is_ancestor(tip, id) {
+            anyhow::bail!("the selected review return commit does not descend from the reviewed commit");
+        }
+        Some((id, None))
+    } else {
+        return_name
+            .map(|name| {
+                let Some(mut reference) = repo.try_find_reference(name.as_ref())? else {
+                    return Ok(None);
+                };
+                let checkout_reference = if name.as_bstr().starts_with(history::PIN_PREFIX) {
+                    reference.target().try_name().map(ToOwned::to_owned)
+                } else {
+                    Some(name)
+                };
+                let id = reference
+                    .peel_to_id()
+                    .context("the review return reference does not resolve")?
+                    .detach();
+                if !graph.is_ancestor(tip, id) {
+                    anyhow::bail!("the review return reference no longer descends from the reviewed commit");
+                }
+                Ok(Some((id, checkout_reference)))
+            })
+            .transpose()?
+            .flatten()
+    };
+    if fallback.is_none() && has_return && checkout.is_none() {
+        return Ok(Finish::SelectReturn { tip });
+    }
     for (label, id) in [("reviewed commit", tip), ("review base", base)] {
         let endpoint = repo.find_commit(id)?.decode()?.into_owned()?;
         if super::rebase::is_pending(&endpoint) {
@@ -262,10 +284,10 @@ pub(crate) fn finish(repo: gix::Repository, graph: &history::HistoryGraph, revie
     let finished = outcome
         .map(review)
         .context("finishing review did not produce a commit")?;
-    Ok(Finished {
+    Ok(Finish::Complete(Finished {
         commit: finished,
         outcome,
-    })
+    }))
 }
 
 pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
@@ -486,20 +508,48 @@ mod tests {
             ],
         )?;
         drop(repo);
+        run(
+            fixture.path(),
+            &[
+                "update-ref",
+                "--no-deref",
+                "-d",
+                pins[0].name.as_bstr().to_str_lossy().as_ref(),
+            ],
+        )?;
         let repo = crate::test_repository::open_with(
             fixture.path(),
             ["user.name=reviewer", "user.email=reviewer@example.com"],
         )?;
         let graph = super::super::loaded_graph(&repo)?;
-        let finished = finish(repo, &graph, amended)?;
+        let Finish::SelectReturn { tip: return_tip } = finish(repo, &graph, amended, None)? else {
+            panic!("the deleted return pin requires replacement selection")
+        };
+        assert_eq!(return_tip, tip, "fallback checkout must descend from the reviewed tip");
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=reviewer", "user.email=reviewer@example.com"],
+        )?;
+        assert!(
+            repo.try_find_reference(started.reference.as_ref())?.is_some(),
+            "asking for a replacement leaves the review untouched"
+        );
+        let Finish::Complete(finished) = finish(repo, &graph, amended, Some(tip))? else {
+            panic!("the selected descendant completes the review")
+        };
         assert_eq!(
             finished
                 .outcome
                 .checkout_reference
                 .as_ref()
                 .map(gix::refs::FullName::as_bstr),
-            Some(BStr::new(b"refs/heads/main")),
-            "finishing retains the branch named by the symbolic departure pin"
+            None,
+            "a selected replacement commit is checked out detached"
+        );
+        assert_eq!(
+            finished.outcome.selected,
+            Some(finished.commit),
+            "the reviewed tip maps to the newly finished review commit"
         );
         super::super::time_travel::checkout_plan(fixture.path(), false, &finished.outcome, &[], false)?;
         let finished = finished.commit;
@@ -507,8 +557,8 @@ mod tests {
         assert_eq!(repo.head_id()?.detach(), finished);
         assert_eq!(
             repo.head()?.referent_name().map(gix::refs::FullNameRef::as_bstr),
-            Some(BStr::new(b"refs/heads/main")),
-            "finishing reattaches HEAD to the branch saved by the review resource"
+            None,
+            "replacement commit selection deliberately leaves HEAD detached"
         );
         assert_eq!(
             repo.find_commit(finished)?.parent_ids().next().map(gix::Id::detach),
@@ -631,7 +681,9 @@ mod tests {
 
         let repo = open()?;
         let graph = super::super::loaded_graph(&repo)?;
-        let finished = finish(repo, &graph, review)?;
+        let Finish::Complete(finished) = finish(repo, &graph, review, None)? else {
+            panic!("the recorded return pin exists")
+        };
         super::super::time_travel::checkout_plan(fixture.path(), false, &finished.outcome, &[], false)?;
         let finished = finished.commit;
         let repo = open()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 0914e4713cc..47f4592eb86 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2449,7 +2449,7 @@ fn event_loop(
                         Err(err) => app.leave_message(format!("review: {err:#}")),
                     }
                 }
-                Effect::FinishReview(id) => {
+                Effect::FinishReview { review: id, return_to } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let result = history_graph
@@ -2459,10 +2459,10 @@ fn event_loop(
                             let mut repo = open_repository(&repository_path, repository_is_bare, false)
                                 .context("could not open repository to finish review")?;
                             repo.object_cache_size(None);
-                            edit::review::finish(repo, graph, id)
+                            edit::review::finish(repo, graph, id, return_to)
                         });
                     match result {
-                        Ok(finished) => {
+                        Ok(edit::review::Finish::Complete(finished)) => {
                             let checkout = edit::time_travel::checkout_plan(
                                 &repository_path,
                                 repository_is_bare,
@@ -2483,6 +2483,17 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
+                        Ok(edit::review::Finish::SelectReturn { tip }) => {
+                            if app.select_review_return(id, tip) {
+                                app.leave_message(
+                                    "review return is missing · j/k select commit · <enter> finish detached · Esc cancel",
+                                );
+                            } else {
+                                app.leave_message(
+                                    "finish review: no visible return commit descends from the reviewed tip",
+                                );
+                            }
+                        }
                         Err(err) => app.leave_message(format!("finish review: {err:#}")),
                     }
                 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 38b4da70256..38255531bd1 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -768,7 +768,12 @@ pub(crate) fn draw_with_worktree(
         State::Cancelled => " · cancelled",
     };
     let mut footer_spans = vec![Span::raw(status)];
-    if app.review_selection_active() {
+    if app.review_return_selection_active() {
+        footer_spans.push(Span::styled(
+            " · review return (<enter> finish detached · Esc cancel)",
+            Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
+        ));
+    } else if app.review_selection_active() {
         footer_spans.push(Span::styled(
             " · review base (<enter> start · Esc cancel)",
             Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),

From 1ffdf690c97eeb61351f0f173acc3175e9ae0cd6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 06:42:57 +0200
Subject: [PATCH 175/282] change!: orient tix rebase todos bottom-to-top

History grows upward from older commits, while rebase todos previously presented and interpreted stacks in the opposite direction. This made visual comparison and editing unnecessarily disorienting.

Render the complete editable plan in reverse and parse it bottom-to-top, including squash and reference placement. Replace fork headings with centered content-width separators, and advance the embedded state marker to v2 so saved v1 documents cannot be misinterpreted.
---
 gix-tix/spec.md               |  40 ++++----
 gix-tix/src/command/rebase.rs |  10 +-
 gix-tix/src/edit/todo.rs      | 170 ++++++++++++++++++++++++----------
 3 files changed, 147 insertions(+), 73 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 87bb7e73a73..81f077f88ae 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -741,28 +741,31 @@ space first; changes blocks adapt within the remaining history width.
 ### History rebase editor
 
 - Selecting an eligible hidden boundary and pressing `e b` opens a Markdown
-  `.md` todo. It grows upward like the history view: each `## fork <id>` section
-  lists its commits oldest-to-newest as `` `pick <short-id>` <displayed metadata> ``.
+  `.md` todo. Its editable plan is read bottom-to-top like the history view:
+  newest commands and refs are highest, and each stack ends in a centered
+  `──── fork <id> ────` separator below its oldest command.
   IDs are shortened through repository configuration; metadata repeats the
   information visible in history and always includes the subject. Base-level
-  stacks begin with `## fork <id> (base) <title>`, using the Markdown-escaped
-  title exactly as displayed in history. Fork points within the editable tree
-  remain plain `## fork <id>` headings.
+  stacks end with `fork <id> (base) <title>` in the separator, using the
+  Markdown-escaped title exactly as displayed in history. Fork points within the editable tree
+  remain plain `fork <id>` separators. Every separator is centered with at least
+  four `─` characters per side, and all span the widest editable line.
 - When that boundary shows `⇣N`, `e u` opens the same editor with each base-level
   stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
-  heading is `## fork <id> (updated-base) <title>`, with the Markdown-escaped
+  separator is `fork <id> (updated-base) <title>`, with the Markdown-escaped
   title exactly as shown in history, including `[A]` and `[N]`. The hidden branch
   itself is not moved.
 - Pick lines may be reordered or removed. `squash <id>` folds an existing
-  non-merge commit into the preceding `pick` or `empty` in the same fork; it may
-  carry `@`, and fork headings naming any folded ID resolve to the combined
-  result. A fork cannot begin with `squash`. Fork headings may otherwise target
-  an earlier pick or any existing commit, so adding and removing headings creates
+  non-merge commit into the following `pick` or `empty` below it in the same
+  fork; it may carry `@`, and fork separators naming any folded ID resolve to
+  the combined result. A fork cannot begin with `squash` when read bottom-to-top.
+  Fork separators may otherwise target a pick below or any existing commit, so
+  adding and removing separators creates
   and joins branches. `empty <title>` inserts an empty commit. Markdown code
   spans and equivalent plain commands are accepted; display text after an ID is
   informational.
 - Squash groups are materialized eagerly on every fork by applying their source
-  deltas in todo order. The result retains the first member's author, author
+  deltas in bottom-to-top todo order. The result retains the first member's author, author
   time, encoding, extra headers, and message, receives the operation's committer,
   and is signed once. Before every later full message, a permanent
   `# <short-id> <subject>` line identifies its source. Distinct raw authors of
@@ -772,16 +775,19 @@ space first; changes blocks adapt within the remaining history width.
   mailmap. All folded IDs and mutable refs map to the one resulting commit;
   resources owned by a later folded review commit are removed.
 - The first line points to complete self-documenting help after the editable
-  todo. All instructions are enclosed in Markdown comments so only headings and
-  command lines participate in the editable plan.
+  todo. All instructions are enclosed in Markdown comments so only separators,
+  reference lines, and command lines participate in the editable plan.
 - A versioned Markdown state comment makes the document independently
   applicable in a later process. It records full base, target, scope and tip IDs,
   checkout requirements, and compare-and-swap state for mutable refs. Ref names
   use Git-compatible C-style quoting so arbitrary ref bytes round-trip. Missing
   state cancels; present invalid state never reaches repository mutation. The
-  state comment follows the complete help at the end of the document.
-- Standalone `(ref, ref)` lines place direct mutable refs at the preceding fork
-  heading or command result. Multiple consecutive lines share that destination.
+  state comment follows the complete help at the end of the document. Bottom-up
+  todos use `tix-rebase-state-v2`; older state versions are rejected rather than
+  interpreted with the opposite command order.
+- Standalone `(ref, ref)` lines place direct mutable refs at the following fork
+  separator or command result below them. Multiple consecutive lines share that
+  destination.
   Commit command metadata omits ref decorations because these lines are their
   sole editable representation.
   Existing displayed names may be moved or removed, and new unqualified names
@@ -856,7 +862,7 @@ space first; changes blocks adapt within the remaining history width.
   `tix rebase apply` always
   applies a valid plan, even when its editable commands are unchanged. The first
   Markdown comment states which of these modes applies and explains that emptying
-  the file or removing the `tix-rebase-state-v1` comment cancels. Continuation
+  the file or removing the `tix-rebase-state-v2` comment cancels. Continuation
   todos likewise state that saving unchanged continues the materialized rebase.
 
 ### Editing shortcuts
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 77241d9984c..28621137ca3 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -336,7 +336,7 @@ mod tests {
             },
         )?;
         let document = String::from_utf8(prepared.document)?;
-        assert!(document.contains("<!-- tix-rebase-state-v1"), "state is embedded");
+        assert!(document.contains("<!-- tix-rebase-state-v2"), "state is embedded");
         assert!(document.contains("`@pick "), "HEAD is the generated checkout");
         assert!(
             document.contains("2000-01-02 author middle"),
@@ -398,12 +398,12 @@ mod tests {
         )?;
         let generated = std::str::from_utf8(&prepared.document)?;
         let state = &generated[generated
-            .find("<!-- tix-rebase-state-v1")
+            .find("<!-- tix-rebase-state-v2")
             .expect("generated state is present")..];
         let edited = format!(
-            "## fork {}\n`@pick {}` tip\n\n{state}",
-            base.to_hex_with_len(7),
-            tip.to_hex_with_len(7)
+            "`@pick {}` tip\n──── fork {} ────\n\n{state}",
+            tip.to_hex_with_len(7),
+            base.to_hex_with_len(7)
         );
         let output_dir = gix_testtools::tempfile::tempdir()?;
         let output = output_dir.path().join("continue.md");
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 905a85371b7..84d9cdea132 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -6,6 +6,7 @@ use gix::{
     bstr::{BString, ByteSlice},
     prelude::ObjectIdExt,
 };
+use ratatui::text::Line;
 
 use super::rebase;
 
@@ -14,13 +15,13 @@ const HELP: &str = r#"
 <!--
 # Rebase todo help
 
-- Each fork section lists a stack from its oldest commit to its newest. Blank lines are ignored.
+- Read the editable plan from bottom to top. Each fork separator is the base of the stack above it. Blank lines are ignored.
 - `pick <id>` keeps a commit. Delete its line to drop it, or move the line to reorder it. Each listed commit may be picked only once.
-- `squash <id>` folds a commit into the preceding command in the same fork. Its full message is retained with a source heading, and additional authors become `Co-authored-by` trailers.
-- `## fork <id>` starts a stack at an existing commit or an earlier picked commit. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork headings stay terse. Delete a fork heading to continue its commits on the preceding stack; add one to create a fork. A listed commit must be picked before it can be a fork target.
+- `squash <id>` folds a commit into the following command below it in the same fork. Its full message is retained with a source heading, and additional authors become `Co-authored-by` trailers.
+- A centered `fork <id>` separator starts the stack above it at an existing commit or a commit picked below it. The selected hidden boundary is labelled `(base)` with its title; a newer hidden tip used by rebase-update is `(updated-base)`, and an explicit command-line target is `(onto)`. Other fork separators stay terse. Delete a separator to continue its commits on the stack below; add one to create a fork. A listed commit must be picked below before it can be a fork target.
 - `empty <title>` creates an empty commit with the text after the command as its title.
 - Commands may be plain text or enclosed in backticks. Text after a backticked command and text after a fork ID is display-only context.
-- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the preceding fork or command; moving, adding, or removing names moves, creates, or deletes refs, including existing editable refs outside the generated todo. The current attached ref stays attached while it remains at the `@` command. Prefix one editable ref with `@` to attach HEAD to it explicitly; it must point to the `@` command.
+- Prefix `pick`, `squash`, or `empty` with `@` to choose the post-rebase checkout. Reference lines like `(main, topic)` point refs at the following separator or command below them; moving, adding, or removing names moves, creates, or deletes refs, including existing editable refs outside the generated todo. The current attached ref stays attached while it remains at the `@` command. Prefix one editable ref with `@` to attach HEAD to it explicitly; it must point to the `@` command.
 - Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. Unchanged picks whose parent stays unchanged retain their IDs; replay starts at the first pending or structurally changed commit. Changed commits through `@` are cherry-picked and re-signed, while descendants and other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins, stashes, and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A ref checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
@@ -28,7 +29,7 @@ const HELP: &str = r#"
 -->
 "#;
 
-const STATE_START: &str = "<!-- tix-rebase-state-v1\n";
+const STATE_START: &str = "<!-- tix-rebase-state-v2\n";
 const STATE_END: &str = "-->";
 const STATE_CLOSE: &str = "\n-->";
 
@@ -195,18 +196,19 @@ pub(crate) fn prepare(
         }
     };
     let anchor_title = anchor_title(repo, onto)?;
+    let mut body = Vec::new();
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
-            document.push(b'\n');
+            body.push(b'\n');
         }
         write_fork_heading(
-            &mut document,
+            &mut body,
             repo,
             section.parent,
             (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
         )?;
         if !scope_set.contains(&section.parent) {
-            write_refs_at(&mut document, &state.expected_refs, section.parent)?;
+            write_refs_at(&mut body, &state.expected_refs, section.parent)?;
         }
         for id in &section.commits {
             let commit = by_id[id];
@@ -216,7 +218,7 @@ pub(crate) fn prepare(
                 "pick"
             };
             let states = commit_states(repo, *id)?;
-            document.extend_from_slice(
+            body.extend_from_slice(
                 format!(
                     "`{verb} {}` {states}{}\n",
                     short(repo, *id)?,
@@ -224,13 +226,14 @@ pub(crate) fn prepare(
                 )
                 .as_bytes(),
             );
-            write_refs_at(&mut document, &state.expected_refs, *id)?;
+            write_refs_at(&mut body, &state.expected_refs, *id)?;
         }
     }
     if sections.is_empty() {
-        write_fork_heading(&mut document, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
-        write_refs_at(&mut document, &state.expected_refs, onto)?;
+        write_fork_heading(&mut body, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
+        write_refs_at(&mut body, &state.expected_refs, onto)?;
     }
+    write_bottom_up(&mut document, &body)?;
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
     Ok(Prepared {
@@ -261,12 +264,13 @@ pub(crate) fn prepare_continuation(
         resolved,
         continuation_sources: plan.steps.iter().flat_map(|step| step.squash.iter().copied()).collect(),
     };
-    let mut document = b"<!-- Rebase help follows. Saving unchanged continues the materialized rebase; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->\n# Continue materialized rebase\n\n".to_vec();
+    let mut document = b"<!-- Rebase help follows. Saving unchanged continues the materialized rebase; empty this file or remove the tix-rebase-state-v2 comment to cancel. -->\n# Continue materialized rebase\n\n".to_vec();
+    let mut body = Vec::new();
     for (index, step) in plan.steps.iter().enumerate() {
         let continues = matches!(step.parent, rebase::PlanParent::Step(parent) if parent + 1 == index);
         if !continues {
             if index > 0 {
-                document.push(b'\n');
+                body.push(b'\n');
             }
             let parent = match step.parent {
                 rebase::PlanParent::Existing(id) => id,
@@ -282,13 +286,13 @@ pub(crate) fn prepare_continuation(
                 .transpose()?
                 .unwrap_or_default();
             write_fork_heading(
-                &mut document,
+                &mut body,
                 repo,
                 parent,
                 (parent == plan.base).then_some(("base", base_title.as_str())),
             )?;
             if matches!(step.parent, rebase::PlanParent::Existing(_)) {
-                write_plan_refs_at(&mut document, &plan.expected_refs, step.parent)?;
+                write_plan_refs_at(&mut body, &plan.expected_refs, step.parent)?;
             }
         }
         let marker = if plan
@@ -308,7 +312,7 @@ pub(crate) fn prepare_continuation(
                     short(repo, id)?
                 };
                 let title = anchor_title(repo, id)?;
-                document.extend_from_slice(
+                body.extend_from_slice(
                     format!(
                         "`{marker}pick {value}` {}{}\n",
                         commit_states(repo, id)?,
@@ -318,12 +322,12 @@ pub(crate) fn prepare_continuation(
                 );
             }
             rebase::PlanCommit::Empty(ref title) => {
-                document.extend_from_slice(format!("`{marker}empty {}`\n", title.to_str_lossy()).as_bytes());
+                body.extend_from_slice(format!("`{marker}empty {}`\n", title.to_str_lossy()).as_bytes());
             }
         }
         for id in &step.squash {
             let title = anchor_title(repo, *id)?;
-            document.extend_from_slice(
+            body.extend_from_slice(
                 format!(
                     "`squash {}` {}{}\n",
                     short(repo, *id)?,
@@ -333,8 +337,9 @@ pub(crate) fn prepare_continuation(
                 .as_bytes(),
             );
         }
-        write_plan_refs_at(&mut document, &plan.expected_refs, rebase::PlanParent::Step(index))?;
+        write_plan_refs_at(&mut body, &plan.expected_refs, rebase::PlanParent::Step(index))?;
     }
+    write_bottom_up(&mut document, &body)?;
     document.extend_from_slice(HELP.as_bytes());
     write_state(&mut document, &state);
     Ok(Prepared {
@@ -346,16 +351,16 @@ pub(crate) fn prepare_continuation(
 fn unchanged_notice(base_updated: bool, has_pending: bool) -> &'static str {
     match (base_updated, has_pending) {
         (false, false) => {
-            "<!-- Rebase help follows. Saving unchanged is a no-op; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Saving unchanged is a no-op; empty this file or remove the tix-rebase-state-v2 comment to cancel. -->"
         }
         (false, true) => {
-            "<!-- Rebase help follows. Pending commits on the @ ancestry make saving unchanged apply this todo: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Pending commits on the @ ancestry make saving unchanged apply this todo: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v2 comment to cancel. -->"
         }
         (true, false) => {
-            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base; empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base; empty this file or remove the tix-rebase-state-v2 comment to cancel. -->"
         }
         (true, true) => {
-            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base and applies pending commits on the @ ancestry: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v1 comment to cancel. -->"
+            "<!-- Rebase help follows. Saving unchanged rebases onto the updated base and applies pending commits on the @ ancestry: that ancestry is replayed now and other forks stay lazy. Empty this file or remove the tix-rebase-state-v2 comment to cancel. -->"
         }
     }
 }
@@ -536,7 +541,7 @@ fn write_fork_heading(
     id: ObjectId,
     annotation: Option<(&str, &str)>,
 ) -> Result<()> {
-    out.extend_from_slice(format!("## fork {}", short(repo, id)?).as_bytes());
+    out.extend_from_slice(format!("fork {}", short(repo, id)?).as_bytes());
     if let Some((kind, title)) = annotation {
         out.extend_from_slice(format!(" ({kind}) {}", escape_markdown(title)).as_bytes());
     }
@@ -544,6 +549,31 @@ fn write_fork_heading(
     Ok(())
 }
 
+fn write_bottom_up(out: &mut Vec<u8>, body: &[u8]) -> Result<()> {
+    let body = std::str::from_utf8(body).context("generated rebase todo is not UTF-8")?;
+    let width = body
+        .lines()
+        .map(|line| {
+            let width = Line::raw(line).width();
+            if line.starts_with("fork ") { width + 10 } else { width }
+        })
+        .max()
+        .unwrap_or_default();
+    for line in body.lines().rev() {
+        if line.starts_with("fork ") {
+            let label_width = Line::raw(line).width();
+            let rails = width.saturating_sub(label_width + 2).max(8);
+            let left = rails / 2;
+            let right = rails - left;
+            out.extend_from_slice(format!("{} {line} {}\n", "─".repeat(left), "─".repeat(right)).as_bytes());
+        } else {
+            out.extend_from_slice(line.as_bytes());
+            out.push(b'\n');
+        }
+    }
+    Ok(())
+}
+
 fn walk(id: ObjectId, children: &HashMap<ObjectId, Vec<ObjectId>>, section: &mut Section, sections: &mut Vec<Section>) {
     section.commits.push(id);
     let Some(child_ids) = children.get(&id) else { return };
@@ -773,7 +803,7 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
     let mut section_has_commit = false;
     let mut section_last_step = None;
     let mut in_comment = false;
-
+    let mut editable = Vec::new();
     for raw in input.lines() {
         let line = raw.trim();
         if in_comment {
@@ -789,7 +819,16 @@ pub(crate) fn parse(repo: &gix::Repository, edited: &[u8]) -> Result<Option<Pars
         if line.is_empty() || line.starts_with("# ") {
             continue;
         }
-        if let Some(target) = line.strip_prefix("## fork ") {
+        editable.push(line);
+    }
+
+    for line in editable.into_iter().rev() {
+        if line.starts_with('─') && line.ends_with('─') {
+            let target = line
+                .trim_matches('─')
+                .trim()
+                .strip_prefix("fork ")
+                .context("a fork separator needs a fork ID")?;
             if sections > 0 && !section_has_commit {
                 anyhow::bail!("a fork section contains no commits");
             }
@@ -1133,7 +1172,7 @@ mod tests {
             let notice = unchanged_notice(updated, pending);
             assert!(notice.contains(expected), "the notice explains its execution mode");
             assert!(
-                notice.contains("remove the tix-rebase-state-v1 comment to cancel"),
+                notice.contains("remove the tix-rebase-state-v2 comment to cancel"),
                 "every notice explains explicit cancellation"
             );
         }
@@ -1180,11 +1219,14 @@ mod tests {
         let document = std::str::from_utf8(&prepared.document).expect("generated todo is UTF-8");
         let start = document.find(STATE_START).expect("generated todo has state");
         let end = document[start..].find(STATE_CLOSE).expect("generated state is closed") + start + STATE_CLOSE.len();
-        format!("{}\n{commands}", &document[start..end]).into_bytes()
+        let mut bottom_up = Vec::new();
+        write_bottom_up(&mut bottom_up, commands.as_bytes()).expect("test todo commands are UTF-8");
+        let bottom_up = std::str::from_utf8(&bottom_up).expect("rendered test todo is UTF-8");
+        format!("{}\n{bottom_up}", &document[start..end]).into_bytes()
     }
 
     #[test]
-    fn markdown_flows_from_base_to_tip_and_uses_repository_abbreviations() -> gix_testtools::Result {
+    fn markdown_flows_from_tip_to_base_and_uses_repository_abbreviations() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
         repo.reference(
@@ -1202,10 +1244,34 @@ mod tests {
         );
         assert!(document.contains(STATE_START), "the todo carries its transaction state");
         assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
-        assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
-        assert!(middle < tip, "the todo grows from the base towards the tip");
+        let base = document.find("fork ").expect("the base separator is shown");
+        assert!(tip < middle && middle < base, "the todo grows upward from its base");
+        let separator = document
+            .lines()
+            .find(|line| line.contains("fork "))
+            .expect("separator is present");
+        assert!(separator.starts_with('─') && separator.ends_with('─'));
+        let plan = &document[..document.find("# Rebase todo help").expect("help is present")];
+        let width = plan
+            .lines()
+            .filter(|line| line.starts_with('`') || line.starts_with('(') || line.starts_with('─'))
+            .map(|line| Line::raw(line).width())
+            .max()
+            .expect("the editable plan has lines");
+        assert_eq!(
+            Line::raw(separator).width(),
+            width,
+            "the separator spans the widest plan line"
+        );
+        let left = separator.chars().take_while(|ch| *ch == '─').count();
+        let right = separator.chars().rev().take_while(|ch| *ch == '─').count();
+        assert!(
+            left >= 4 && right >= 4 && left.abs_diff(right) <= 1,
+            "the label is centered"
+        );
         assert!(
             document.contains("middle \\* markdown"),
             "metadata is escaped for Markdown"
@@ -1278,6 +1344,12 @@ mod tests {
         );
         let parsed = parse_state(&repo, &document)?.context("state is present")?;
         assert_eq!(parsed.expected_refs[0].name, name, "quoted names round-trip losslessly");
+        let old = document.replacen("tix-rebase-state-v2", "tix-rebase-state-v1", 1);
+        let err = match parse_state(&repo, &old) {
+            Ok(_) => panic!("v1 order would be ambiguous under v2 semantics"),
+            Err(err) => err,
+        };
+        assert!(format!("{err:#}").contains("unsupported state version"));
         assert_eq!(
             parsed.head_ref,
             Some(name),
@@ -1408,9 +1480,9 @@ mod tests {
 
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.contains(&format!("## fork {} (base) base", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
         assert!(
-            document.contains(&format!("## fork {}\n", middle.to_hex_with_len(7))),
+            document.contains(&format!("fork {} ", middle.to_hex_with_len(7))),
             "a fork within the editable tree has no external-anchor annotation"
         );
         let plan = parse_plan(&repo, document.as_bytes())?;
@@ -1451,7 +1523,7 @@ mod tests {
         );
         assert!(
             document.contains(&format!(
-                "## fork {} (updated-base) \\[A\\] \\[N\\] updated \\* hidden base",
+                "fork {} (updated-base) \\[A\\] \\[N\\] updated \\* hidden base",
                 onto.to_hex_with_len(7)
             )),
             "the unfamiliar fork target carries its escaped UI title"
@@ -1485,7 +1557,7 @@ mod tests {
         let (base, middle, tip, commits) = commits(&repo)?;
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
-            "# Rebase\n\n## fork {}\n`pick {}` ignored\n@empty a new checkpoint\n\n## fork {}\n@pick {}\n",
+            "# Rebase\n\nfork {}\n`pick {}` ignored\n@empty a new checkpoint\n\nfork {}\n@pick {}\n",
             base.to_hex_with_len(7),
             tip.to_hex_with_len(7),
             tip.to_hex_with_len(7),
@@ -1497,7 +1569,7 @@ mod tests {
 
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = format!(
-            "## fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\n## fork {}\n@pick {}\n",
+            "fork {}\npick {} ignored display metadata\nempty a new checkpoint\n\nfork {}\n@pick {}\n",
             base.to_hex_with_len(7),
             tip.to_hex_with_len(7),
             tip.to_hex_with_len(7),
@@ -1516,14 +1588,14 @@ mod tests {
     }
 
     #[test]
-    fn squash_folds_into_the_previous_command_and_may_carry_checkout() -> gix_testtools::Result {
+    fn squash_above_a_command_folds_into_it_and_may_carry_checkout() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
         let (base, middle, tip, commits) = commits(&repo)?;
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = with_state(
             &prepared,
             &format!(
-                "## fork {}\npick {}\n`@squash {}` ignored display metadata\n\n## fork {}\nempty side\n",
+                "fork {}\npick {}\n`@squash {}` ignored display metadata\n\nfork {}\nempty side\n",
                 base.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
@@ -1547,7 +1619,7 @@ mod tests {
         let invalid = with_state(
             &prepared,
             &format!(
-                "## fork {}\n@squash {}\npick {}\n",
+                "fork {}\n@squash {}\npick {}\n",
                 base.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
@@ -1628,7 +1700,7 @@ mod tests {
         let (_fixture, repo) = repo()?;
         let (base, _middle, tip, commits) = commits(&repo)?;
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
-        let edited = format!("## fork {}\n", base.to_hex_with_len(7));
+        let edited = format!("fork {}\n", base.to_hex_with_len(7));
         let edited = with_state(&prepared, &edited);
         let err = parse(&repo, &edited).expect_err("HEAD must be moved before its pick is dropped");
         assert!(format!("{err:#}").contains("checkout marker"));
@@ -1667,7 +1739,7 @@ mod tests {
         let mismatched = with_state(
             &prepared,
             &format!(
-                "## fork {}\npick {}\n(@main)\n@pick {}\n",
+                "fork {}\npick {}\n(@main)\n@pick {}\n",
                 base.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
@@ -1679,7 +1751,7 @@ mod tests {
         let edited = with_state(
             &prepared,
             &format!(
-                "## fork {}\npick {}\n(new-1, main)\n@pick {}\n",
+                "fork {}\npick {}\n(new-1, main)\n@pick {}\n",
                 base.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
@@ -1700,7 +1772,7 @@ mod tests {
         assert_eq!(
             repo.find_reference("refs/heads/new-1")?.id().detach(),
             outcome.map(middle).context("the middle commit is retained")?,
-            "the new branch points at its preceding command"
+            "the new branch line points at the following command below it"
         );
         assert!(
             repo.try_find_reference("refs/patches/middle")?.is_none()
@@ -1731,7 +1803,7 @@ mod tests {
         let edited = with_state(
             &prepared,
             &format!(
-                "## fork {}\npick {}\n(outside)\n@pick {}\n(@refs/patches/attach)\n",
+                "fork {}\npick {}\n(outside)\n@pick {}\n(@refs/patches/attach)\n",
                 base.to_hex_with_len(7),
                 middle.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
@@ -1788,7 +1860,7 @@ mod tests {
         let edited = with_state(
             &prepared,
             &format!(
-                "## fork {}\n@pick {}\n(main, refs/patches/tip)\n",
+                "fork {}\n@pick {}\n(main, refs/patches/tip)\n",
                 base.to_hex_with_len(7),
                 tip.to_hex_with_len(7),
             ),
@@ -1820,11 +1892,7 @@ mod tests {
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let edited = with_state(
             &prepared,
-            &format!(
-                "## fork {}\n@pick {}\n",
-                base.to_hex_with_len(7),
-                tip.to_hex_with_len(7)
-            ),
+            &format!("fork {}\n@pick {}\n", base.to_hex_with_len(7), tip.to_hex_with_len(7)),
         );
         let plan = parse_plan(&repo, &edited)?;
         let graph = super::super::loaded_graph(&repo)?;

From ae9e6626d89834ee370191f4ec2f6261b41ca73d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 06:48:44 +0200
Subject: [PATCH 176/282] change: show raw display metadata in tix todos

Todo metadata is informational, but Markdown escaping made subjects and anchor labels harder to compare with the history view and added noise to otherwise editable lines.

Emit commit metadata, continuation and squash titles, and annotated fork labels verbatim. Command parsing still stops at the command span, so raw Markdown punctuation remains display-only.
---
 gix-tix/spec.md          | 10 ++++-----
 gix-tix/src/edit/todo.rs | 45 ++++++++++------------------------------
 2 files changed, 16 insertions(+), 39 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 81f077f88ae..44de92d0d30 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -746,14 +746,14 @@ space first; changes blocks adapt within the remaining history width.
   `──── fork <id> ────` separator below its oldest command.
   IDs are shortened through repository configuration; metadata repeats the
   information visible in history and always includes the subject. Base-level
-  stacks end with `fork <id> (base) <title>` in the separator, using the
-  Markdown-escaped title exactly as displayed in history. Fork points within the editable tree
+  stacks end with `fork <id> (base) <title>` in the separator, using the title
+  exactly as displayed in history without Markdown escaping. Fork points within the editable tree
   remain plain `fork <id>` separators. Every separator is centered with at least
   four `─` characters per side, and all span the widest editable line.
 - When that boundary shows `⇣N`, `e u` opens the same editor with each base-level
   stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
-  separator is `fork <id> (updated-base) <title>`, with the Markdown-escaped
-  title exactly as shown in history, including `[A]` and `[N]`. The hidden branch
+  separator is `fork <id> (updated-base) <title>`, with the raw title exactly as
+  shown in history, including `[A]` and `[N]`. The hidden branch
   itself is not moved.
 - Pick lines may be reordered or removed. `squash <id>` folds an existing
   non-merge commit into the following `pick` or `empty` below it in the same
@@ -763,7 +763,7 @@ space first; changes blocks adapt within the remaining history width.
   adding and removing separators creates
   and joins branches. `empty <title>` inserts an empty commit. Markdown code
   spans and equivalent plain commands are accepted; display text after an ID is
-  informational.
+  informational and emitted verbatim without Markdown escaping.
 - Squash groups are materialized eagerly on every fork by applying their source
   deltas in bottom-to-top todo order. The result retains the first member's author, author
   time, encoding, extra headers, and message, receives the operation's committer,
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 84d9cdea132..8940626a1b4 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -218,14 +218,7 @@ pub(crate) fn prepare(
                 "pick"
             };
             let states = commit_states(repo, *id)?;
-            body.extend_from_slice(
-                format!(
-                    "`{verb} {}` {states}{}\n",
-                    short(repo, *id)?,
-                    escape_markdown(&commit.info)
-                )
-                .as_bytes(),
-            );
+            body.extend_from_slice(format!("`{verb} {}` {states}{}\n", short(repo, *id)?, &commit.info).as_bytes());
             write_refs_at(&mut body, &state.expected_refs, *id)?;
         }
     }
@@ -313,12 +306,7 @@ pub(crate) fn prepare_continuation(
                 };
                 let title = anchor_title(repo, id)?;
                 body.extend_from_slice(
-                    format!(
-                        "`{marker}pick {value}` {}{}\n",
-                        commit_states(repo, id)?,
-                        escape_markdown(&title)
-                    )
-                    .as_bytes(),
+                    format!("`{marker}pick {value}` {}{}\n", commit_states(repo, id)?, title).as_bytes(),
                 );
             }
             rebase::PlanCommit::Empty(ref title) => {
@@ -332,7 +320,7 @@ pub(crate) fn prepare_continuation(
                     "`squash {}` {}{}\n",
                     short(repo, *id)?,
                     commit_states(repo, *id)?,
-                    escape_markdown(&title)
+                    title
                 )
                 .as_bytes(),
             );
@@ -543,7 +531,7 @@ fn write_fork_heading(
 ) -> Result<()> {
     out.extend_from_slice(format!("fork {}", short(repo, id)?).as_bytes());
     if let Some((kind, title)) = annotation {
-        out.extend_from_slice(format!(" ({kind}) {}", escape_markdown(title)).as_bytes());
+        out.extend_from_slice(format!(" ({kind}) {title}").as_bytes());
     }
     out.push(b'\n');
     Ok(())
@@ -600,17 +588,6 @@ fn short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
         .to_string())
 }
 
-fn escape_markdown(input: &str) -> String {
-    let mut out = String::with_capacity(input.len());
-    for ch in input.chars() {
-        if matches!(ch, '\\' | '`' | '*' | '_' | '[' | ']' | '<' | '>') {
-            out.push('\\');
-        }
-        out.push(ch);
-    }
-    out
-}
-
 fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
     let Some(start) = input.find(STATE_START) else {
         if input.contains("<!-- tix-rebase-state-") {
@@ -1195,7 +1172,7 @@ mod tests {
                 Commit {
                     id: middle,
                     parents: vec![base],
-                    info: "2000-01-02 author middle * markdown".into(),
+                    info: "2000-01-02 author middle * _ [markdown] <view> `code` \\ raw".into(),
                 },
             ],
         ))
@@ -1273,8 +1250,8 @@ mod tests {
             "the label is centered"
         );
         assert!(
-            document.contains("middle \\* markdown"),
-            "metadata is escaped for Markdown"
+            document.contains("middle * _ [markdown] <view> `code` \\ raw"),
+            "display metadata is emitted verbatim"
         );
         assert!(
             document.find("# Rebase todo help").expect("help is present") > tip,
@@ -1496,7 +1473,7 @@ mod tests {
         let (base, middle, tip, commits) = commits(&repo)?;
         let mut commit = repo.find_commit(base)?.decode()?.into_owned()?;
         commit.parents = [base].into_iter().collect();
-        commit.message = "updated * hidden base\n\n<!-- agent -->".into();
+        commit.message = "updated * _ [hidden] <base> `raw` \\ base\n\n<!-- agent -->".into();
         let onto = repo.write_object(&commit)?.detach();
         repo.notes()
             .map_err(gix::Exn::into_error)?
@@ -1523,13 +1500,13 @@ mod tests {
         );
         assert!(
             document.contains(&format!(
-                "fork {} (updated-base) \\[A\\] \\[N\\] updated \\* hidden base",
+                "fork {} (updated-base) [A] [N] updated * _ [hidden] <base> `raw` \\ base",
                 onto.to_hex_with_len(7)
             )),
-            "the unfamiliar fork target carries its escaped UI title"
+            "the unfamiliar fork target carries its raw UI title"
         );
         assert_eq!(
-            document.matches("updated \\* hidden base").count(),
+            document.matches("updated * _ [hidden] <base> `raw` \\ base").count(),
             1,
             "only the new update target is labelled"
         );

From 9a0e73dfa68d031293a450d964eeb7de4e0cb625 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 06:57:04 +0200
Subject: [PATCH 177/282] feat: add index-only command-line amend

The default amend command intentionally falls back to tracked worktree changes when the index matches HEAD, but scripts sometimes need to guarantee that only explicitly staged content is consumed.

Add tix amend --index as a command-line-only strict mode. It uses staged content when present and reports the existing no-op result when the index is unchanged, leaving worktree-only changes untouched; TUI and default amend behavior remain unchanged.
---
 gix-tix/spec.md          |  4 ++++
 gix-tix/src/command.rs   | 41 +++++++++++++++++++++++++++++----------
 gix-tix/src/edit/head.rs | 42 ++++++++++++++++++++++++++++++++++++++--
 3 files changed, 75 insertions(+), 12 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 44de92d0d30..3ee22fc05b1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -571,6 +571,10 @@ space first; changes blocks adapt within the remaining history width.
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
   unavailable and report a no-op through `tix amend|spill`.
+- Command-line `tix amend --index` disables the worktree fallback. It amends
+  staged index content when present and reports `nothing to amend` when the
+  index matches `HEAD`, even if tracked worktree changes exist. This option does
+  not alter the history-view amend action.
 - Command-line edits use the same default HEAD, applicable pin, and review tips
   as the history view. Unrelated refs do not broaden their descendant rewrite
   scope, while mutable refs pointing into that scope are still retargeted.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 08d57e843c1..bfb1566d5e5 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -32,7 +32,7 @@ enum Command {
     /// Print the complete ref-tree without opening the terminal UI.
     RefTree(RefTree),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
-    Amend,
+    Amend(Amend),
     /// Move the changes introduced by HEAD into the worktree.
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
@@ -67,6 +67,13 @@ struct RefTree {
     revisions: Vec<OsString>,
 }
 
+#[derive(Debug, clap::Args)]
+struct Amend {
+    /// Amend only staged index changes, without falling back to worktree changes.
+    #[arg(long)]
+    index: bool,
+}
+
 #[derive(Debug, clap::Args)]
 struct Pin {
     /// Revisions resolving to commits to pin.
@@ -113,9 +120,17 @@ impl Platform {
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         match command {
             Command::RefTree(_) => unreachable!("ref-tree commands return before logging"),
-            Command::Amend => {
+            Command::Amend(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
-                edit_head(repository, &graph, crate::edit::head::Kind::Amend, "amend")?;
+                let amended = if args.index {
+                    crate::edit::head::amend_index(repository, &graph)?
+                } else {
+                    crate::edit::head::perform(repository, &graph, crate::edit::head::Kind::Amend, None)?
+                };
+                match amended {
+                    Some(id) => println!("{}", id.to_hex_with_len(7)),
+                    None => println!("nothing to amend"),
+                }
             }
             Command::Spill => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
@@ -305,13 +320,19 @@ mod tests {
         );
         assert_eq!(old_name.revisions, ["tree"]);
 
-        assert!(matches!(
-            Cli::try_parse_from(["tix", "amend"])
-                .expect("amend parses")
-                .platform
-                .command,
-            Some(Command::Amend)
-        ));
+        let amend = Cli::try_parse_from(["tix", "amend", "--index"])
+            .expect("index-only amend parses")
+            .platform
+            .command;
+        let Some(Command::Amend(amend)) = amend else {
+            panic!("amend was expected")
+        };
+        assert!(amend.index);
+        let amend = Cli::try_parse_from(["tix", "amend"])
+            .expect("default amend parses")
+            .platform
+            .command;
+        assert!(matches!(amend, Some(Command::Amend(Amend { index: false }))));
         assert!(matches!(
             Cli::try_parse_from(["tix", "spill"])
                 .expect("spill parses")
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 3d36299471b..fe9cfff6cf9 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -12,10 +12,25 @@ pub enum Kind {
 
 #[tracing::instrument(skip_all, fields(?kind))]
 pub fn perform(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    kind: Kind,
+    selected_path: Option<(&PathChange, Option<ObjectId>)>,
+) -> Result<Option<ObjectId>> {
+    perform_inner(repo, graph, kind, selected_path, false)
+}
+
+#[tracing::instrument(skip_all)]
+pub fn amend_index(repo: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<Option<ObjectId>> {
+    perform_inner(repo, graph, Kind::Amend, None, true)
+}
+
+fn perform_inner(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
+    index_only: bool,
 ) -> Result<Option<ObjectId>> {
     let head = repo
         .head_id()
@@ -59,7 +74,7 @@ pub fn perform(
                     anyhow::bail!("review commits can amend only staged paths");
                 }
                 amend_path_tree(&repo, old_tree, path, &index)?
-            } else if review {
+            } else if review || index_only {
                 let index_tree = create::index_tree(&repo, &index)?;
                 if index_tree == old_tree {
                     return Ok(None);
@@ -247,7 +262,7 @@ mod tests {
         let repo = open(fixture.path())?;
         let old = repo.head_id()?.detach();
         let graph = super::super::loaded_graph(&repo)?;
-        let new = perform(repo, &graph, Kind::Amend, None)?.expect("staged changes amend HEAD");
+        let new = amend_index(repo, &graph)?.expect("staged changes amend HEAD");
         assert_ne!(new, old);
         assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
         assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"staged\n");
@@ -263,6 +278,29 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn index_only_amend_does_not_fall_back_to_worktree_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        git(fixture.path(), &["reset", "-q", "HEAD", "--", "tracked"])?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let graph = super::super::loaded_graph(&repo)?;
+
+        assert!(amend_index(repo, &graph)?.is_none(), "an unchanged index is a no-op");
+        let repo = open(fixture.path())?;
+        assert_eq!(repo.head_id()?.detach(), old, "HEAD remains unchanged");
+        assert!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty(),
+            "the index remains clean"
+        );
+        assert_eq!(
+            git(fixture.path(), &["diff", "--name-only"])?,
+            b"tracked\n",
+            "worktree-only changes remain uncommitted"
+        );
+        Ok(())
+    }
+
     #[test]
     fn amending_one_worktree_path_preserves_unrelated_staging() -> gix_testtools::Result {
         for (group, expected) in [

From 6ff59bd9feea9f0a2f236b3aab6029f661c43bd3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 07:15:53 +0200
Subject: [PATCH 178/282] feat: add non-interactive history display

Add tix show with a mandatory hidden boundary and optional tips. Reuse the TUI history traversal, lanes, decorations, pins, mailmap, and default metadata while emitting complete plain-text output.
---
 gix-tix/spec.md        |   5 ++
 gix-tix/src/command.rs | 166 ++++++++++++++++++++++++++++++++++++++++-
 gix-tix/src/ui.rs      |  31 ++++++++
 3 files changed, 200 insertions(+), 2 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3ee22fc05b1..626bf67b33f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -13,6 +13,11 @@ without trading responsiveness for metadata that is not visible.
 
 - `tix [REVISION]...` shows commits reachable from the supplied revisions, or
   from `HEAD` when none are supplied.
+- `tix show -h HIDDEN... [TIP...]` prints the complete history view without
+  opening a terminal UI. At least one hidden revision is required; tips default
+  to `HEAD`, and applicable pins participate exactly as they do in the history
+  view. Output uses the history view's graph lanes and default metadata, without
+  colors, selection, clipping, or a footer.
 - `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
   checkout, pending-rebase replay, stash handling, and pin reconciliation as
   TUI time travel. Travelling to the current `HEAD` is a no-op. A detached
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index bfb1566d5e5..745d2882751 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -1,4 +1,4 @@
-use std::{collections::HashSet, ffi::OsString};
+use std::{collections::HashSet, ffi::OsString, io::Write, sync::atomic::AtomicBool};
 
 use anyhow::{Context, Result};
 use clap::Parser;
@@ -31,6 +31,9 @@ pub struct Platform {
 enum Command {
     /// Print the complete ref-tree without opening the terminal UI.
     RefTree(RefTree),
+    /// Print the complete history view without opening the terminal UI.
+    #[command(disable_help_flag = true)]
+    Show(Show),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend(Amend),
     /// Move the changes introduced by HEAD into the worktree.
@@ -67,6 +70,19 @@ struct RefTree {
     revisions: Vec<OsString>,
 }
 
+#[derive(Debug, clap::Args)]
+struct Show {
+    /// Print help.
+    #[arg(long, action = clap::ArgAction::HelpLong)]
+    help: Option<bool>,
+    /// Hide this revision and every commit reachable from it.
+    #[arg(short = 'h', long, required = true, value_name = "REVSPEC")]
+    hide: Vec<OsString>,
+    /// Visible traversal tips, or HEAD if omitted.
+    #[arg(value_name = "TIP")]
+    revisions: Vec<OsString>,
+}
+
 #[derive(Debug, clap::Args)]
 struct Amend {
     /// Amend only staged index changes, without falling back to worktree changes.
@@ -115,11 +131,12 @@ impl Platform {
         let repository = repository.to_thread_local();
         let command = match command {
             Command::RefTree(args) => return print_ref_tree(&repository, args),
+            Command::Show(args) => return show(&repository, args),
             command => command,
         };
         let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
         match command {
-            Command::RefTree(_) => unreachable!("ref-tree commands return before logging"),
+            Command::RefTree(_) | Command::Show(_) => unreachable!("display commands return before logging"),
             Command::Amend(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 let amended = if args.index {
@@ -161,6 +178,95 @@ fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
     Ok(())
 }
 
+fn show(repository: &gix::Repository, args: Show) -> Result<()> {
+    let (hide, unavailable) = crate::history::available_hidden_revisions(repository, &args.hide)?;
+    for (revision, err) in unavailable {
+        eprintln!(
+            "warning: ignoring unavailable hidden revision {}: {err}",
+            revision.to_string_lossy()
+        );
+    }
+    write_history(repository, &args.revisions, &hide, std::io::stdout().lock())
+}
+
+fn write_history(
+    repository: &gix::Repository,
+    revisions: &[OsString],
+    hide: &[OsString],
+    mut out: impl Write,
+) -> Result<()> {
+    let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
+        crate::history::Authors::default(),
+    ));
+    let refs = crate::history::snapshot(repository, revisions, hide, false)?;
+    let mut app = crate::app::App::new(usize::MAX);
+    let mut decorations = crate::history::Decorations::default();
+    let mut history_graph = None;
+    crate::history::load(
+        repository,
+        revisions,
+        hide,
+        false,
+        &authors,
+        &AtomicBool::new(false),
+        |event| {
+            match event {
+                crate::history::Event::Decorations(value) => decorations = value,
+                crate::history::Event::Commits(rows) => app.extend_commits(rows),
+                crate::history::Event::HiddenCommits(rows) => app.extend_hidden_commits(rows),
+                crate::history::Event::Complete(graph) => history_graph = Some(graph),
+                crate::history::Event::VisibleComplete | crate::history::Event::Cancelled => {}
+            }
+            true
+        },
+    )?;
+    let graph = history_graph.context("history traversal did not complete")?;
+    let rows = app
+        .start_lane_computation()
+        .context("history rows were unavailable for lane computation")?;
+    let (rows, lanes, elapsed) = crate::app::compute_lanes(rows);
+    app.finish_lane_computation(rows, lanes, elapsed);
+    crate::update_hidden_branch_updates(&mut app, Some(&graph), &refs);
+
+    for index in 0..app.rows.len() {
+        if app.rows[index].metadata_loaded {
+            continue;
+        }
+        let id = app.rows[index].id;
+        let (metadata, attributions) =
+            crate::history::load_metadata(repository, id, &authors).context("could not load displayed commit")?;
+        app.set_metadata(index, metadata, attributions);
+    }
+
+    let mut note_ids = HashSet::new();
+    let mut notes = repository
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes")?;
+    for row in &app.rows {
+        if !notes
+            .get(row.id)
+            .map_err(gix::Exn::into_error)
+            .context("could not load displayed commit notes")?
+            .is_empty()
+        {
+            note_ids.insert(row.id);
+        }
+    }
+
+    let mailmap = repository.open_mailmap();
+    let lanes = app.render_lanes(0..app.rows.len());
+    for (index, row) in app.rows.iter().enumerate() {
+        let metadata = crate::ui::plain_history_metadata(&app, row, &decorations, &mailmap, note_ids.contains(&row.id));
+        write!(out, "{}{}", lanes.lane(index), metadata).context("could not write history row")?;
+        if let Some(behind) = app.hidden_branch_behind(row.id) {
+            write!(out, " ⇣{behind}").context("could not write hidden-branch status")?;
+        }
+        writeln!(out).context("could not finish history row")?;
+    }
+    Ok(())
+}
+
 fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
     for pin in create_pins(repository, &args.revisions)? {
         println!("{}", display_pin(repository, &pin)?);
@@ -298,6 +404,17 @@ mod tests {
         assert!(ref_tree.unicode);
         assert_eq!(ref_tree.revisions, ["main", "topic"]);
 
+        let show = Cli::try_parse_from(["tix", "show", "-h", "main", "--hide", "tag", "topic"])
+            .expect("show options parse")
+            .platform
+            .command;
+        let Some(Command::Show(show)) = show else {
+            panic!("show was expected")
+        };
+        assert!(show.help.is_none());
+        assert_eq!(show.hide, ["main", "tag"]);
+        assert_eq!(show.revisions, ["topic"]);
+
         assert!(
             Cli::try_parse_from(["tix", "--worktrees"]).is_err(),
             "the removed TUI worktree option is rejected"
@@ -469,6 +586,18 @@ mod tests {
                 .kind(),
             ErrorKind::InvalidValue
         );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "show", "topic"])
+                .expect_err("show requires a hidden revision")
+                .kind(),
+            ErrorKind::MissingRequiredArgument
+        );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "show", "--help"])
+                .expect_err("show has long help")
+                .kind(),
+            ErrorKind::DisplayHelp
+        );
         assert_eq!(
             Cli::try_parse_from(["tix", "amend", "topic"])
                 .expect_err("commands reject TUI arguments")
@@ -559,6 +688,39 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn show_prints_the_complete_plain_history_view() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        create_pins(&repository, &[OsString::from("topic")])?;
+
+        let mut output = Vec::new();
+        write_history(&repository, &[], &[OsString::from("v1")], &mut output)?;
+        let output = String::from_utf8(output)?;
+
+        assert_eq!(output.lines().count(), 5, "the complete projected history is printed");
+        assert!(output.contains('●'), "history graph lanes are rendered");
+        assert!(output.contains("📌"), "applicable pins are decorated and traversed");
+        assert!(
+            output.contains("topic"),
+            "a pinned tip outside HEAD history is included"
+        );
+        assert!(
+            output.contains("Mailmapped Author"),
+            "default mailmap formatting is retained"
+        );
+        assert!(
+            output.contains("Co: Human Coauthor"),
+            "default trailer attribution is retained"
+        );
+        assert!(
+            output.contains("v1") && output.contains("root"),
+            "the hidden boundary row is included"
+        );
+        assert!(!output.contains('\u{1b}'), "plain output contains no terminal escapes");
+        Ok(())
+    }
+
     #[test]
     fn split_command_uses_the_index_for_the_new_commit_and_worktree_for_its_parent() -> gix_testtools::Result {
         fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 38255531bd1..b7172704599 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1903,6 +1903,37 @@ fn metadata_line<'a>(
     Line::from(spans)
 }
 
+pub(crate) fn plain_history_metadata(
+    app: &App,
+    row: &CommitRow,
+    decorations: &Decorations,
+    mailmap: &gix::mailmap::Snapshot,
+    has_notes: bool,
+) -> String {
+    metadata_line(
+        row,
+        app.title(row),
+        app.attributions(row),
+        decorations,
+        mailmap,
+        MetadataOptions {
+            date_mode: app.date_mode,
+            show_author_name: app.name_mode != NameMode::None,
+            show_emails: app.show_emails,
+            show_trailers: app.name_mode == NameMode::All && app.show_trailers,
+            has_notes,
+            use_mailmap: app.use_mailmap,
+            ref_mode: app.ref_mode,
+            selected: false,
+            copy_feedback: None,
+        },
+    )
+    .spans
+    .into_iter()
+    .map(|span| span.content.into_owned())
+    .collect()
+}
+
 pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::Snapshot) -> String {
     let title = app.title(row);
     let decorations = Decorations::new();

From b946986a00c5176aa177bbe7f3424c84bba2afc2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 08:05:00 +0200
Subject: [PATCH 179/282] feat: infer hidden branches from remote HEADs

Reverse-map symbolic remote HEAD targets through their fetch refspecs for tix show and tix rebase todo. Add --no-auto-hide while leaving interactive history and ref-tree hiding explicit.
---
 gix-tix/spec.md               |  28 +++++----
 gix-tix/src/command.rs        |  39 +++++++++---
 gix-tix/src/command/rebase.rs |  53 +++++++++++++++-
 gix-tix/src/history.rs        | 110 ++++++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs            |   2 +-
 5 files changed, 206 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 626bf67b33f..848f650aaf5 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -13,11 +13,11 @@ without trading responsiveness for metadata that is not visible.
 
 - `tix [REVISION]...` shows commits reachable from the supplied revisions, or
   from `HEAD` when none are supplied.
-- `tix show -h HIDDEN... [TIP...]` prints the complete history view without
-  opening a terminal UI. At least one hidden revision is required; tips default
-  to `HEAD`, and applicable pins participate exactly as they do in the history
-  view. Output uses the history view's graph lanes and default metadata, without
-  colors, selection, clipping, or a footer.
+- `tix show [-h HIDDEN...] [--no-auto-hide] [TIP...]` prints the complete
+  history view without opening a terminal UI. Tips default to `HEAD`, and
+  applicable pins participate exactly as they do in the history view. Output
+  uses the history view's graph lanes and default metadata, without colors,
+  selection, clipping, or a footer.
 - `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
   checkout, pending-rebase replay, stash handling, and pin reconciliation as
   TUI time travel. Travelling to the current `HEAD` is a no-op. A detached
@@ -45,11 +45,19 @@ without trading responsiveness for metadata that is not visible.
   option may be repeated.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
-- `tix rebase todo -h HIDDEN... [--onto REV] [TIP...]` writes a self-contained
-  Markdown history-rebase plan to stdout. At least one hidden revision must
-  resolve; visible tips default to `HEAD`, and an ambiguous derived fork point is
-  an error. `--edit-and-apply` opens the same plan with Git's configured editor
-  and applies it when the editor exits.
+- `tix rebase todo [-h HIDDEN...] [--no-auto-hide] [--onto REV] [TIP...]`
+  writes a self-contained Markdown history-rebase plan to stdout. Visible tips
+  default to `HEAD`, and an ambiguous derived fork point is an error.
+  `--edit-and-apply` opens the same plan with Git's configured editor and applies
+  it when the editor exits.
+- `tix show` and `tix rebase todo` automatically inspect symbolic
+  `refs/remotes/<remote>/HEAD` references. Their targets are reverse-mapped
+  through each remote's fetch refspec, and existing local commit branches are
+  added to the explicit hidden revisions. Multiple remote defaults are
+  deduplicated; stale, direct, ambiguous, unmappable, missing, and non-commit
+  results are ignored. At least one explicit or inferred hidden revision is
+  required. `--no-auto-hide` disables inference. The interactive history and
+  `ref-tree --hide` retain their explicit-only behavior.
 - `tix rebase apply [FILE]` applies such a plan from a file, or from standard
   input when `FILE` is omitted or `-`. Removing its state comment or emptying the
   document cancels successfully; malformed or unsupported state is an error.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 745d2882751..6cc56c2993f 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -76,8 +76,11 @@ struct Show {
     #[arg(long, action = clap::ArgAction::HelpLong)]
     help: Option<bool>,
     /// Hide this revision and every commit reachable from it.
-    #[arg(short = 'h', long, required = true, value_name = "REVSPEC")]
+    #[arg(short = 'h', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
+    /// Do not infer hidden local branches from remote HEADs.
+    #[arg(long)]
+    no_auto_hide: bool,
     /// Visible traversal tips, or HEAD if omitted.
     #[arg(value_name = "TIP")]
     revisions: Vec<OsString>,
@@ -179,7 +182,10 @@ fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
 }
 
 fn show(repository: &gix::Repository, args: Show) -> Result<()> {
-    let (hide, unavailable) = crate::history::available_hidden_revisions(repository, &args.hide)?;
+    let (hide, unavailable) = crate::history::available_hidden_revisions(repository, &args.hide, !args.no_auto_hide)?;
+    if hide.is_empty() {
+        anyhow::bail!("show requires at least one -h/--hide revision when no remote HEAD maps to a local branch");
+    }
     for (revision, err) in unavailable {
         eprintln!(
             "warning: ignoring unavailable hidden revision {}: {err}",
@@ -413,8 +419,19 @@ mod tests {
         };
         assert!(show.help.is_none());
         assert_eq!(show.hide, ["main", "tag"]);
+        assert!(!show.no_auto_hide);
         assert_eq!(show.revisions, ["topic"]);
 
+        let show = Cli::try_parse_from(["tix", "show", "--no-auto-hide", "topic"])
+            .expect("show can disable automatic hiding")
+            .platform
+            .command;
+        let Some(Command::Show(show)) = show else {
+            panic!("show was expected")
+        };
+        assert!(show.no_auto_hide);
+        assert!(show.hide.is_empty());
+
         assert!(
             Cli::try_parse_from(["tix", "--worktrees"]).is_err(),
             "the removed TUI worktree option is rejected"
@@ -523,6 +540,7 @@ mod tests {
                 "tix",
                 "rebase",
                 "todo",
+                "--no-auto-hide",
                 "-h",
                 "main",
                 "--onto",
@@ -586,12 +604,6 @@ mod tests {
                 .kind(),
             ErrorKind::InvalidValue
         );
-        assert_eq!(
-            Cli::try_parse_from(["tix", "show", "topic"])
-                .expect_err("show requires a hidden revision")
-                .kind(),
-            ErrorKind::MissingRequiredArgument
-        );
         assert_eq!(
             Cli::try_parse_from(["tix", "show", "--help"])
                 .expect_err("show has long help")
@@ -692,6 +704,17 @@ mod tests {
     fn show_prints_the_complete_plain_history_view() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
+        let err = show(
+            &repository,
+            Show {
+                help: None,
+                hide: Vec::new(),
+                no_auto_hide: true,
+                revisions: Vec::new(),
+            },
+        )
+        .expect_err("disabling auto-hide requires an explicit hidden revision");
+        assert!(format!("{err:#}").contains("at least one -h/--hide"));
         create_pins(&repository, &[OsString::from("topic")])?;
 
         let mut output = Vec::new();
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 28621137ca3..6961b4e7eae 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -38,6 +38,9 @@ pub(super) struct Todo {
     /// Hide this revision and derive the editable fork point from it.
     #[arg(short = 'h', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
+    /// Do not infer hidden local branches from remote HEADs.
+    #[arg(long)]
+    no_auto_hide: bool,
     /// Rebase the derived scope onto this commit instead of its fork point.
     #[arg(long, value_name = "REV")]
     onto: Option<OsString>,
@@ -86,10 +89,12 @@ fn todo(repo: gix::Repository, args: Todo) -> Result<()> {
 }
 
 fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
-    if args.hide.is_empty() {
-        anyhow::bail!("rebase todo requires at least one -h/--hide revision");
+    let (hide, unavailable) = history::available_hidden_revisions(repo, &args.hide, !args.no_auto_hide)?;
+    if hide.is_empty() {
+        anyhow::bail!(
+            "rebase todo requires at least one -h/--hide revision when no remote HEAD maps to a local branch"
+        );
     }
-    let (hide, unavailable) = history::available_hidden_revisions(repo, &args.hide)?;
     for (revision, err) in unavailable {
         eprintln!(
             "warning: ignoring unavailable hidden revision {}: {err}",
@@ -330,6 +335,7 @@ mod tests {
             &Todo {
                 help: None,
                 hide: vec!["HEAD~2".into()],
+                no_auto_hide: false,
                 onto: None,
                 edit_and_apply: false,
                 tips: Vec::new(),
@@ -357,6 +363,7 @@ mod tests {
             &Todo {
                 help: None,
                 hide: Vec::new(),
+                no_auto_hide: true,
                 onto: None,
                 edit_and_apply: false,
                 tips: Vec::new(),
@@ -367,6 +374,45 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn infers_the_hidden_base_from_a_remote_head() -> gix_testtools::Result {
+        let (fixture, _repo) = repository()?;
+        for args in [
+            &["branch", "base", "HEAD~2"][..],
+            &["config", "remote.origin.url", "https://example.com/repo"][..],
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"][..],
+            &["update-ref", "refs/remotes/origin/base", "refs/heads/base"][..],
+            &["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/base"][..],
+        ] {
+            let output = Command::new("git").current_dir(fixture.path()).args(args).output()?;
+            assert!(
+                output.status.success(),
+                "git {args:?} prepares the remote default: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["core.abbrev=7", "user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let prepared = prepare(
+            &repo,
+            &Todo {
+                help: None,
+                hide: Vec::new(),
+                no_auto_hide: false,
+                onto: None,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )?;
+        assert!(
+            String::from_utf8(prepared.document)?.contains("# Rebase from"),
+            "the inferred local default branch provides the rebase base"
+        );
+        Ok(())
+    }
+
     #[test]
     fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
@@ -475,6 +521,7 @@ mod tests {
             &Todo {
                 help: None,
                 hide: vec!["HEAD~2".into()],
+                no_auto_hide: false,
                 onto: None,
                 edit_and_apply: false,
                 tips: Vec::new(),
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index f40d9fa664c..c33c69e1833 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1,6 +1,6 @@
 use std::{
     cmp::Ordering as CmpOrdering,
-    collections::{HashMap, HashSet},
+    collections::{BTreeSet, HashMap, HashSet},
     ffi::OsString,
     sync::atomic::{AtomicBool, Ordering},
 };
@@ -1654,11 +1654,16 @@ fn resolve_tips(repo: &gix::Repository, revisions: &[OsString]) -> Result<Option
 pub(crate) fn available_hidden_revisions(
     repo: &gix::Repository,
     revisions: &[OsString],
+    auto_hide: bool,
 ) -> Result<(Vec<OsString>, Vec<(OsString, String)>)> {
+    let mut revisions = revisions.to_vec();
+    if auto_hide {
+        revisions.extend(auto_hidden_revisions(repo)?);
+    }
     let mut available = Vec::new();
     let mut unavailable = Vec::new();
     let mut first_error = None;
-    for revision in revisions {
+    for revision in &revisions {
         match resolve_revisions(repo, std::slice::from_ref(revision), "hidden ") {
             Ok(_) => available.push(revision.clone()),
             Err(err) => {
@@ -1675,6 +1680,40 @@ pub(crate) fn available_hidden_revisions(
     Ok((available, unavailable))
 }
 
+fn auto_hidden_revisions(repo: &gix::Repository) -> Result<Vec<OsString>> {
+    let mut branches = BTreeSet::new();
+    for remote_name in repo.remote_names() {
+        let mut head = BString::from("refs/remotes/");
+        head.extend_from_slice(&remote_name);
+        head.extend_from_slice(b"/HEAD");
+        let Ok(Some(reference)) = repo.try_find_reference(head.as_bstr()) else {
+            continue;
+        };
+        let target = reference.target();
+        let Some(tracking) = target.try_name() else { continue };
+        let Ok(Some((upstream, remote))) = repo.upstream_branch_and_remote_for_tracking_branch(tracking) else {
+            continue;
+        };
+        if remote.name().map(gix::remote::Name::as_bstr) != Some(remote_name.as_bstr()) {
+            continue;
+        }
+        let Ok(Some(mut local)) = repo.try_find_reference(upstream.as_ref()) else {
+            continue;
+        };
+        let Ok(id) = local.peel_to_id() else { continue };
+        if repo
+            .find_header(id)
+            .is_ok_and(|header| header.kind() == gix::object::Kind::Commit)
+        {
+            branches.insert(upstream);
+        }
+    }
+    Ok(branches
+        .into_iter()
+        .map(|name| gix::path::from_bstr(name.as_bstr()).into_owned().into_os_string())
+        .collect())
+}
+
 fn attribution_kind(trailer: &gix::objs::commit::message::body::TrailerRef<'_>) -> Option<AttributionKind> {
     if trailer.is_co_authored_by() {
         Some(AttributionKind::CoAuthor)
@@ -2038,16 +2077,79 @@ mod tests {
         let repo = crate::test_repository::open(&fixture)?;
         let revisions = ["unknown".into(), "main".into()];
 
-        let (available, unavailable) = available_hidden_revisions(&repo, &revisions)?;
+        let (available, unavailable) = available_hidden_revisions(&repo, &revisions, false)?;
         assert_eq!(available, [OsString::from("main")]);
         assert_eq!(unavailable.len(), 1);
         assert!(
-            available_hidden_revisions(&repo, &[OsString::from("unknown")]).is_err(),
+            available_hidden_revisions(&repo, &[OsString::from("unknown")], false).is_err(),
             "all missing hidden revisions retain the previous fatal behavior"
         );
         Ok(())
     }
 
+    #[test]
+    fn remote_heads_infer_existing_local_hidden_branches() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        let git = |args: &[&str]| -> gix_testtools::Result {
+            let output = Command::new("git").current_dir(path).args(args).output()?;
+            assert!(
+                output.status.success(),
+                "git {args:?} prepares remote HEADs: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+            Ok(())
+        };
+        git(&["branch", "trunk", "main"])?;
+        for (remote, fetch, tracking) in [
+            (
+                "origin",
+                "+refs/heads/*:refs/remotes/origin/*",
+                "refs/remotes/origin/main",
+            ),
+            (
+                "backup",
+                "+refs/heads/*:refs/remotes/backup/*",
+                "refs/remotes/backup/main",
+            ),
+            (
+                "team",
+                "+refs/heads/trunk:refs/remotes/team/default",
+                "refs/remotes/team/default",
+            ),
+            (
+                "stale",
+                "+refs/heads/missing:refs/remotes/stale/default",
+                "refs/remotes/stale/default",
+            ),
+        ] {
+            git(&["config", &format!("remote.{remote}.url"), "https://example.com/repo"])?;
+            git(&["config", &format!("remote.{remote}.fetch"), fetch])?;
+            git(&["update-ref", tracking, "main"])?;
+            git(&["symbolic-ref", &format!("refs/remotes/{remote}/HEAD"), tracking])?;
+        }
+        git(&["config", "remote.direct.url", "https://example.com/repo"])?;
+        git(&["config", "remote.direct.fetch", "+refs/heads/*:refs/remotes/direct/*"])?;
+        git(&["update-ref", "refs/remotes/direct/HEAD", "main"])?;
+
+        let repo = crate::test_repository::open(path)?;
+        assert_eq!(
+            auto_hidden_revisions(&repo)?,
+            [OsString::from("refs/heads/main"), OsString::from("refs/heads/trunk")],
+            "remote defaults are reverse-mapped, deduplicated, and limited to existing local branches"
+        );
+        assert_eq!(
+            available_hidden_revisions(&repo, &[OsString::from("topic")], true)?.0,
+            [
+                OsString::from("topic"),
+                OsString::from("refs/heads/main"),
+                OsString::from("refs/heads/trunk")
+            ],
+            "explicit and inferred hidden revisions are combined"
+        );
+        Ok(())
+    }
+
     #[test]
     fn walks_the_same_reachable_set_as_git_for_multiple_tips() -> gix_testtools::Result {
         let fixture = fixture()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 47f4592eb86..c9c4251a80c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -790,7 +790,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (validation_repository, _) = open_history_repository(&mut repository_path, &common_dir)?;
-    let (hide, unavailable) = history::available_hidden_revisions(&validation_repository, &options.hide)?;
+    let (hide, unavailable) = history::available_hidden_revisions(&validation_repository, &options.hide, false)?;
     options.hide = hide;
     for (revision, err) in unavailable {
         eprintln!(

From 10cf2eda2ce6f03429dc0a017f85388ba84c1a04 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 09:55:19 +0200
Subject: [PATCH 180/282] feat: stabilize tix history with change IDs

Hide history IDs by default and add v i to cycle commit IDs, change IDs, and automatic display. Scan complete scenes in the background so duplicate identities use mixed change/commit prefixes without affecting cursor rendering.

Persist canonical change-id headers only when commits are rewritten, preserving identity across descendants, squashes, reviews, and splits. Keep CLI show, rebase todos, and copy operations commit-ID based.
---
 gix-tix/src/app.rs                            |  70 +++++++++
 gix-tix/src/change_id.rs                      | 139 +++++++++++++++++
 gix-tix/src/command.rs                        |   1 +
 gix-tix/src/edit/rebase.rs                    |  38 ++++-
 ..._rebase__tests__reworded-middle-stack.snap |   6 +-
 ...tests__changed-review-with-successors.snap |   9 +-
 ...sts__accepted-pending-rebase-conflict.snap |   6 +-
 gix-tix/src/edit/split.rs                     |  17 ++-
 gix-tix/src/lib.rs                            |  56 +++++++
 gix-tix/src/ui.rs                             | 144 ++++++++++++++++--
 10 files changed, 463 insertions(+), 23 deletions(-)
 create mode 100644 gix-tix/src/change_id.rs

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 357bfef2c06..53a3d0fc719 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -8,6 +8,7 @@ use std::{
 use gix::{
     ObjectId,
     bstr::{BStr, BString, ByteSlice},
+    hash::ChangeId,
     traverse::commit::ParentIds,
 };
 
@@ -267,6 +268,14 @@ pub(crate) enum DateMode {
     None,
 }
 
+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
+pub(crate) enum IdMode {
+    Commit,
+    Change,
+    #[default]
+    Off,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum CopyKind {
     Id,
@@ -289,6 +298,7 @@ pub(crate) enum Action {
     First,
     Last,
     ToggleDate,
+    CycleIds,
     ToggleName,
     ToggleEmail,
     ToggleTrailers,
@@ -407,6 +417,7 @@ pub(crate) struct App {
     pub viewport_rows: usize,
     pub lane_time: Option<Duration>,
     pub date_mode: DateMode,
+    pub id_mode: IdMode,
     pub name_mode: NameMode,
     pub show_emails: bool,
     pub show_trailers: bool,
@@ -474,6 +485,8 @@ pub(crate) struct App {
     signature_verification_running: bool,
     pub(crate) selection_relation: Option<SelectionRelation>,
     hidden_branch_updates: HashMap<ObjectId, (usize, ObjectId)>,
+    change_ids: HashMap<ObjectId, ChangeId>,
+    duplicate_change_ids: HashSet<ObjectId>,
 }
 
 impl App {
@@ -499,6 +512,7 @@ impl App {
             viewport_rows,
             lane_time: None,
             date_mode: DateMode::default(),
+            id_mode: IdMode::default(),
             name_mode: NameMode::All,
             show_emails: false,
             show_trailers: true,
@@ -566,9 +580,36 @@ impl App {
             signature_verification_running: false,
             selection_relation: None,
             hidden_branch_updates: HashMap::new(),
+            change_ids: HashMap::new(),
+            duplicate_change_ids: HashSet::new(),
         }
     }
 
+    pub(crate) fn effective_id_mode(&self) -> IdMode {
+        match self.id_mode {
+            IdMode::Off if !self.duplicate_change_ids.is_empty() => IdMode::Change,
+            mode => mode,
+        }
+    }
+
+    pub(crate) fn change_id(&self, id: ObjectId) -> ChangeId {
+        self.change_ids.get(&id).copied().unwrap_or_else(|| id.into())
+    }
+
+    pub(crate) fn has_duplicate_change_id(&self, id: ObjectId) -> bool {
+        self.duplicate_change_ids.contains(&id)
+    }
+
+    pub(crate) fn set_change_ids(&mut self, change_ids: HashMap<ObjectId, ChangeId>, duplicates: HashSet<ObjectId>) {
+        self.change_ids = change_ids;
+        self.duplicate_change_ids = duplicates;
+    }
+
+    fn clear_change_ids(&mut self) {
+        self.change_ids.clear();
+        self.duplicate_change_ids.clear();
+    }
+
     pub(crate) fn leave_message(&mut self, message: impl Into<String>) {
         self.message = Some(message.into());
     }
@@ -828,6 +869,7 @@ impl App {
             &action,
             Action::ToggleHistoryDisplay
                 | Action::ToggleDate
+                | Action::CycleIds
                 | Action::ToggleEmail
                 | Action::ToggleName
                 | Action::ToggleTrailers
@@ -947,6 +989,13 @@ impl App {
                     DateMode::None => DateMode::Author,
                 };
             }
+            Action::CycleIds => {
+                self.id_mode = match self.id_mode {
+                    IdMode::Commit => IdMode::Change,
+                    IdMode::Change => IdMode::Off,
+                    IdMode::Off => IdMode::Commit,
+                };
+            }
             Action::ToggleEmail => self.show_emails = !self.show_emails,
             Action::ToggleName => {
                 let start = self.offset.min(self.rows.len());
@@ -1351,6 +1400,7 @@ impl App {
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
         self.forget_confirmation = None;
+        self.clear_change_ids();
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -1485,6 +1535,7 @@ impl App {
         self.hidden_branch_targets.clear();
         self.hidden_rebase_bases.clear();
         self.hidden_branch_updates.clear();
+        self.clear_change_ids();
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
@@ -3561,6 +3612,25 @@ mod tests {
         assert_eq!(app.date_mode, DateMode::None);
         app.update(Action::ToggleDate);
         assert_eq!(app.date_mode, DateMode::Author);
+        assert_eq!(app.id_mode, IdMode::Off);
+        app.update(Action::CycleIds);
+        assert_eq!(app.id_mode, IdMode::Commit);
+        app.update(Action::CycleIds);
+        assert_eq!(app.id_mode, IdMode::Change);
+        app.update(Action::CycleIds);
+        assert_eq!(app.id_mode, IdMode::Off);
+        app.set_change_ids(HashMap::new(), HashSet::from([id(1), id(2)]));
+        assert_eq!(
+            app.effective_id_mode(),
+            IdMode::Change,
+            "off automatically reveals duplicate change IDs"
+        );
+        app.update(Action::CycleIds);
+        assert_eq!(
+            app.effective_id_mode(),
+            IdMode::Commit,
+            "an explicit commit-ID mode overrides automatic change IDs"
+        );
         assert!(app.show_emails);
         assert_eq!(app.name_mode, NameMode::None);
         assert!(!app.show_trailers);
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
new file mode 100644
index 00000000000..2c941ca5311
--- /dev/null
+++ b/gix-tix/src/change_id.rs
@@ -0,0 +1,139 @@
+use std::{
+    collections::{HashMap, HashSet},
+    sync::atomic::{AtomicBool, Ordering},
+};
+
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::{BStr, BString},
+    hash::ChangeId,
+};
+
+pub(crate) const HEADER: &str = "change-id";
+
+pub(crate) fn effective<'a>(commit_id: ObjectId, mut values: impl Iterator<Item = &'a BStr>) -> ChangeId {
+    values
+        .find_map(|value| ChangeId::from_reverse_hex(value).ok())
+        .unwrap_or_else(|| commit_id.into())
+}
+
+pub(crate) fn inherit(repo: &gix::Repository, commit: &mut gix::objs::Commit, predecessor: ObjectId) -> Result<()> {
+    let object = repo
+        .find_commit(predecessor)
+        .context("could not read predecessor while preserving its change ID")?;
+    let decoded = object
+        .decode()
+        .context("could not decode predecessor while preserving its change ID")?;
+    let change_id = effective(predecessor, decoded.extra_headers().find_all(HEADER));
+    store(commit, change_id);
+    Ok(())
+}
+
+fn store(commit: &mut gix::objs::Commit, change_id: ChangeId) {
+    commit.extra_headers.retain(|(name, _)| name != HEADER);
+    commit
+        .extra_headers
+        .push((HEADER.into(), BString::from(change_id.to_string())));
+}
+
+pub(crate) struct Scan {
+    pub overrides: HashMap<ObjectId, ChangeId>,
+    pub duplicates: HashSet<ObjectId>,
+}
+
+pub(crate) fn scan(repo: &gix::Repository, ids: &[ObjectId], cancelled: &AtomicBool) -> Result<Option<Scan>> {
+    let mut overrides = HashMap::new();
+    let mut first_by_change = HashMap::new();
+    let mut duplicates = HashSet::new();
+    for &id in ids {
+        if cancelled.load(Ordering::Relaxed) {
+            return Ok(None);
+        }
+        let object = repo
+            .find_commit(id)
+            .context("could not read commit while scanning change IDs")?;
+        let commit = object
+            .decode()
+            .context("could not decode commit while scanning change IDs")?;
+        let change_id = effective(id, commit.extra_headers().find_all(HEADER));
+        if change_id != ChangeId::from(id) {
+            overrides.insert(id, change_id);
+        }
+        if let Some(first) = first_by_change.insert(change_id, id) {
+            duplicates.insert(first);
+            duplicates.insert(id);
+        }
+    }
+    Ok(Some(Scan { overrides, duplicates }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn id(byte: u8) -> ObjectId {
+        ObjectId::Sha1([byte; 20])
+    }
+
+    #[test]
+    fn stores_one_canonical_header() {
+        let predecessor = id(1);
+        let inherited = ChangeId::from(id(2));
+        let mut commit = gix::objs::Commit {
+            tree: id(3),
+            parents: Default::default(),
+            author: Default::default(),
+            committer: Default::default(),
+            encoding: None,
+            message: Default::default(),
+            extra_headers: vec![
+                (HEADER.into(), "invalid".into()),
+                (HEADER.into(), inherited.to_string().into()),
+            ],
+        };
+
+        store(&mut commit, inherited);
+        assert_eq!(commit.extra_headers.len(), 1, "the rewrite stores one canonical header");
+        assert_eq!(
+            effective(predecessor, commit.extra_headers().find_all(HEADER)),
+            inherited,
+            "the first valid inherited identity wins"
+        );
+    }
+
+    #[test]
+    fn scans_the_whole_scene_for_duplicate_identities() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let predecessor = repo.rev_parse_single("HEAD~1")?.detach();
+        let mut duplicate = repo.find_commit(repo.head_id()?)?.decode()?.into_owned()?;
+        duplicate
+            .extra_headers
+            .push((HEADER.into(), ChangeId::from(predecessor).to_string().into()));
+        let duplicate = repo.write_object(&duplicate)?.detach();
+
+        let mut successor = repo.find_commit(duplicate)?.decode()?.into_owned()?;
+        successor.extra_headers.clear();
+        inherit(&repo, &mut successor, duplicate)?;
+        assert_eq!(
+            effective(duplicate, successor.extra_headers().find_all(HEADER)),
+            ChangeId::from(predecessor),
+            "later rewrites inherit the stored identity from their predecessor"
+        );
+
+        let scan =
+            scan(&repo, &[predecessor, duplicate], &AtomicBool::new(false))?.expect("the scan was not cancelled");
+        assert_eq!(
+            scan.duplicates,
+            HashSet::from([predecessor, duplicate]),
+            "both off-screen and visible instances are marked"
+        );
+        assert_eq!(
+            scan.overrides.get(&duplicate),
+            Some(&ChangeId::from(predecessor)),
+            "the header overrides the duplicate commit's trivial identity"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 6cc56c2993f..03996abc49b 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -206,6 +206,7 @@ fn write_history(
     ));
     let refs = crate::history::snapshot(repository, revisions, hide, false)?;
     let mut app = crate::app::App::new(usize::MAX);
+    app.id_mode = crate::app::IdMode::Commit;
     let mut decorations = crate::history::Decorations::default();
     let mut history_graph = None;
     crate::history::load(
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 189d25db84b..ca2a9620757 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -513,6 +513,7 @@ fn perform_inner(
         let id = write_commit(
             &repo,
             commit,
+            None,
             &committer,
             CommitState::Unmarked(signature),
             signing.clone(),
@@ -620,7 +621,7 @@ fn perform_inner(
         } else {
             CommitState::Unmarked(signature)
         };
-        let new_id = write_commit(&repo, commit, &committer, state, signing.clone())?;
+        let new_id = write_commit(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
@@ -631,6 +632,7 @@ fn perform_inner(
                 let upper_id = write_commit(
                     &repo,
                     upper,
+                    None,
                     &committer,
                     CommitState::Unmarked(Signature::RedoIfNeeded),
                     signing.clone(),
@@ -751,6 +753,7 @@ pub(super) fn finish_review(
         let new = write_commit(
             &repo,
             commit,
+            Some(*old),
             &committer,
             CommitState::Unmarked(Signature::RedoIfNeeded),
             signing.clone(),
@@ -795,6 +798,7 @@ pub(super) fn finish_review(
         let new = write_commit(
             &repo,
             commit,
+            Some(old),
             &committer,
             CommitState::Pending {
                 original_parent: old_parents.first().copied(),
@@ -1049,7 +1053,12 @@ pub(crate) fn perform_plan_with_progress(
                 original_parent: recorded_parent.flatten().or_else(|| graph_parents.first().copied()),
             }
         };
-        let (new_id, signing_time) = write_commit_timed(&repo, commit, &committer, state, signing.clone())?;
+        let predecessor = match step.commit {
+            PlanCommit::Pick(id) | PlanCommit::Resolved(id) => Some(id),
+            PlanCommit::Empty(_) => None,
+        };
+        let (new_id, signing_time) =
+            write_commit_timed(&repo, commit, predecessor, &committer, state, signing.clone())?;
         if let Some(elapsed) = signing_time {
             progress.signed += 1;
             progress.signing_time += elapsed;
@@ -1714,20 +1723,25 @@ pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
 fn write_commit(
     repo: &gix::Repository,
     commit: gix::objs::Commit,
+    predecessor: Option<ObjectId>,
     committer: &gix::actor::Signature,
     state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<ObjectId> {
-    Ok(write_commit_timed(repo, commit, committer, state, signing)?.0)
+    Ok(write_commit_timed(repo, commit, predecessor, committer, state, signing)?.0)
 }
 
 fn write_commit_timed(
     repo: &gix::Repository,
     mut commit: gix::objs::Commit,
+    predecessor: Option<ObjectId>,
     committer: &gix::actor::Signature,
     state: CommitState,
     signing: Option<gix::objs::commit::signature::Options>,
 ) -> Result<(ObjectId, Option<Duration>)> {
+    if let Some(predecessor) = predecessor {
+        crate::change_id::inherit(repo, &mut commit, predecessor)?;
+    }
     commit.committer = committer.clone();
     let signature = match state {
         CommitState::Unmarked(signature) => {
@@ -2106,7 +2120,7 @@ mod tests {
             old_tip_tree,
             "a reword preserves descendant trees"
         );
-        for id in [new_middle, new_tip] {
+        for (id, predecessor) in [(new_middle, middle), (new_tip, old_tip)] {
             let commit = repo.find_commit(id)?.decode()?.into_owned()?;
             assert_eq!(commit.committer.name, b"rebasing committer".as_bstr());
             assert_eq!(commit.committer.email, b"rebasing@example.com".as_bstr());
@@ -2114,6 +2128,17 @@ mod tests {
                 commit.committer.time.seconds, 978_307_200,
                 "every rewritten commit receives the operation's current committer date"
             );
+            assert_eq!(
+                crate::change_id::effective(
+                    id,
+                    commit
+                        .extra_headers
+                        .iter()
+                        .filter_map(|(name, value)| (name == crate::change_id::HEADER).then_some(value.as_ref()))
+                ),
+                predecessor.into(),
+                "each rewritten commit retains the identity of its predecessor"
+            );
         }
         insta::assert_snapshot!(
             "reworded-middle-stack",
@@ -2767,6 +2792,11 @@ mod tests {
         assert_eq!(commit.tree, tip_tree, "all source tree changes are present");
         assert_eq!(commit.author.name, b"author".as_bstr());
         assert_eq!(commit.committer.name, b"rebasing committer".as_bstr());
+        assert_eq!(
+            crate::change_id::effective(combined, commit.extra_headers().find_all(crate::change_id::HEADER)),
+            middle.into(),
+            "the primary picked commit supplies the squash identity"
+        );
         assert!(!has_marker(&commit), "squash is eager even without a checkout marker");
         assert_eq!(
             commit.message,
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
index a338b704d01..a2c67cb161a 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
@@ -22,6 +22,7 @@ C1
   parent C0
   author author <author@example.com> 946771200 +0000
   committer rebasing committer <rebasing@example.com> 978307200 +0000
+  change-id wtvpqoumovpvzypqrpsxxlkvxmltvtlxvomlzyxs
   
   rewritten middle
 
@@ -30,6 +31,7 @@ C2
   parent C1
   author author <author@example.com> 946857600 +0000
   committer rebasing committer <rebasing@example.com> 978307200 +0000
+  change-id zvoumlrryyvtnnxxqnmrnlxnvtlmnvwlynmuuvux
   
   tip
 
@@ -45,12 +47,12 @@ tree = T1
 100644 file "tip" = "tip\n"
 
 [objects]
+C1 = 1583a183c3a57fce524e7acdd5a1c007d5f0f9a9
 C0 = 5295d5ce934d18b6a1f48c3b7d836d53b55304e5
 T0 = 559dc660acc84805fedbcb75588371240372c173
 T1 = 569961a34e2a909d8c7a2940ed4ad365504e64ed
-C2 = 5d165c738be9924177bbbcd2e6a6060b488828ca
-C1 = 77dcc6c97954f7c6ffada274193c390913821435
 T2 = 8552142164d268c95f60dabb74465a2f4ffb51b7
+C2 = 91e50045e3c98994aebc74a28953fc04ce49cacf
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
 B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
index fe936a8651e..e73d00cb3c2 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -29,6 +29,7 @@ C2
   parent C1
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
+  change-id oxzuvntpklkyxykvvmmuzqomsnzrrwwvtuoxwttx
   
   review
 
@@ -37,6 +38,7 @@ C3
   parent C2
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
+  change-id tlynrtysuoqktszrqppwrnsxpvokwvoqoqvkvqsv
   
   review successor
 
@@ -45,6 +47,7 @@ C4
   parent C3
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
+  change-id xlpouomvnxrqllnkynsusvqwkkwnlrttmrvxquso
   tix-rebase-parent 2cb49e443aa675eab8add679938ca6cd303ae353
   
   A
@@ -59,14 +62,14 @@ tree = T2
 100644 file "successor" = "A\n"
 
 [objects]
-C2 = 066adf4b205850540218e32e44576bcb33249572
+C2 = 1a13dc5cbbc857de093c9a007e6b104a1a9ffbdb
 B0 = 223b7836fb19fdf64ba2d3cd6173c6a283141f78
 C1 = 2cb49e443aa675eab8add679938ca6cd303ae353
 T0 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
-C4 = 4ec5d7b25bc7415d9243067e231d934cc6952501
 T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T2 = 74c148aa829dcd83ad2608b6d0862ae1e6981501
+C4 = 7b4c1808849fabbe6f5afcd94ff930defbda47f3
 T3 = 93664bfc7cc096fcc0d1ac962596031e10f26906
 C0 = c38a9f7427b84ed8ba5e187ec385489d82d71695
-C3 = e0b1ce8b2ac673ea0cc153ca4b8958a3aa315dd0
+C3 = e028a8e769407c249d118ddc499f0c064685ba16
 B1 = f70f10e4db19068f79bc43844b49f3eece45c4e8
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index d942628c2f1..4c984bb0b88 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -21,6 +21,7 @@ C1
   parent C0
   author author <author@example.com> 946684800 +0000
   committer author <author@example.com> 978307200 +0000
+  change-id stnpqqrsmmvwyprorolxzpuxpllmuzttnmyzurkl
   tix-rebase-parent 48dd951f6d729bd3debd703cc9a8392702bf9124
 
   tip
@@ -30,6 +31,7 @@ C2
   parent C1
   author author <author@example.com> 946944000 +0000
   committer author <author@example.com> 978307200 +0000
+  change-id xuwvvlmlmymmmluzlqpxrrklslwlkmokswwxzool
   tix-rebase-parent 76ca9987dd431a8b8be20a52aeed5066cd1058fe
 
   after
@@ -44,10 +46,10 @@ tree = conflicted
 100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
 
 [objects]
+C2 = 26d78d03083cfe539c4a94c28bd30d9a548a8394
+C1 = 69348f5557de103f6771f9a121ff67f5272ceab5
 T0 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T1 = 6f2762b571ef9a93001cc607058818aa5d0d055c
-C2 = 7dda806fe5de746fe7e14316c0775eb7df6003dc
-C1 = a2ce4f2d51adba4c0e29abc2000475aee3a4e8ae
 B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
 C0 = c0b811a58f27425263a4276fe881de38736a9446
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 2ebee44d3ee..2ec28edf5ac 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -191,8 +191,23 @@ mod tests {
             repository.find_commit(upper)?.message_raw()?,
             b"upper\n\nreason\n".as_bstr()
         );
+        let source_commit = repository.find_commit(source)?.decode()?.into_owned()?;
+        assert_eq!(
+            crate::change_id::effective(source, source_commit.extra_headers().find_all(crate::change_id::HEADER)),
+            old.into(),
+            "the rewritten lower commit inherits the original identity"
+        );
+        assert_eq!(
+            repository
+                .find_commit(upper)?
+                .decode()?
+                .extra_headers()
+                .find(crate::change_id::HEADER),
+            None,
+            "the newly created upper commit remains headerless"
+        );
         assert!(
-            !super::super::rebase::is_pending(&repository.find_commit(source)?.decode()?.into_owned()?),
+            !super::super::rebase::is_pending(&source_commit),
             "the unsigned source already has its final tree and parent"
         );
         assert!(
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c9c4251a80c..2ab90317fe6 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4,6 +4,7 @@
 
 mod animation;
 mod app;
+mod change_id;
 pub mod command;
 mod edit;
 mod history;
@@ -72,6 +73,17 @@ struct FillRepository {
     retain: bool,
 }
 
+struct ChangeIdWorker {
+    cancelled: Arc<AtomicBool>,
+    results: mpsc::Receiver<Result<Option<change_id::Scan>>>,
+}
+
+impl Drop for ChangeIdWorker {
+    fn drop(&mut self) {
+        self.cancelled.store(true, Ordering::Relaxed);
+    }
+}
+
 struct WorktreeWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
@@ -915,6 +927,7 @@ fn event_loop(
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
+    let mut change_id_worker: Option<ChangeIdWorker> = None;
     let mut commit_message = None;
     let mut tree_changes = TreeChangesCache::default();
     let mut worktree_changes = None;
@@ -1221,6 +1234,25 @@ fn event_loop(
                 }
             }
         }
+        if let Some(result) = change_id_worker.as_ref().map(|worker| worker.results.try_recv()) {
+            match result {
+                Ok(Ok(Some(scan))) => {
+                    app.set_change_ids(scan.overrides, scan.duplicates);
+                    change_id_worker = None;
+                    dirty = true;
+                }
+                Ok(Ok(None)) => change_id_worker = None,
+                Ok(Err(err)) => {
+                    tracing::warn!(error = %err, "change ID scan failed");
+                    change_id_worker = None;
+                }
+                Err(mpsc::TryRecvError::Empty) => {}
+                Err(mpsc::TryRecvError::Disconnected) => {
+                    tracing::warn!("change ID scan worker stopped unexpectedly");
+                    change_id_worker = None;
+                }
+            }
+        }
         if let Some(result) = lane_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
                 Ok((rows, graph, lane_time)) => {
@@ -1243,6 +1275,11 @@ fn event_loop(
                     if quit_on_finish {
                         return Ok(app.lane_time);
                     }
+                    change_id_worker = Some(start_change_id_scan(
+                        repository_path.clone(),
+                        repository_is_bare,
+                        app.rows.iter().map(|row| row.id).collect(),
+                    ));
                 }
                 Err(mpsc::TryRecvError::Empty) => {}
                 Err(mpsc::TryRecvError::Disconnected) => {
@@ -1326,6 +1363,7 @@ fn event_loop(
             && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
+            change_id_worker = None;
             ref_tree_refresh_pending = false;
             refresh_receiver = Some(start_history_refresh(
                 repository_path.clone(),
@@ -1349,6 +1387,7 @@ fn event_loop(
             && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
+            change_id_worker = None;
             let refresh_started = Instant::now();
             let response_ids = filesystem_responses.begin_reference_refresh();
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
@@ -2576,6 +2615,20 @@ fn start_lane_worker(rows: Vec<SharedCommitRow>) -> mpsc::Receiver<(Vec<SharedCo
     receiver
 }
 
+fn start_change_id_scan(repository_path: PathBuf, bare: bool, ids: Vec<gix::ObjectId>) -> ChangeIdWorker {
+    let cancelled = Arc::new(AtomicBool::new(false));
+    let worker_cancelled = Arc::clone(&cancelled);
+    let (sender, results) = mpsc::channel();
+    std::thread::spawn(move || {
+        let result = open_repository(&repository_path, bare, false).and_then(|mut repository| {
+            repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
+            change_id::scan(&repository, &ids, &worker_cancelled)
+        });
+        let _ = sender.send(result);
+    });
+    ChangeIdWorker { cancelled, results }
+}
+
 type SignatureVerification = (gix::ObjectId, bool);
 
 fn start_signature_verification(
@@ -4591,6 +4644,7 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
                 | Action::First
                 | Action::Last
                 | Action::ToggleDate
+                | Action::CycleIds
                 | Action::ToggleName
                 | Action::ToggleEmail
                 | Action::ToggleTrailers
@@ -4649,6 +4703,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Home | KeyCode::Char('g') => Some(Action::First),
         KeyCode::End | KeyCode::Char('G') => Some(Action::Last),
         KeyCode::Char('d') if history_display_expanded => Some(Action::ToggleDate),
+        KeyCode::Char('i') if history_display_expanded => Some(Action::CycleIds),
         KeyCode::Char('e') if history_display_expanded => Some(Action::ToggleEmail),
         KeyCode::Char('n') if history_display_expanded => Some(Action::ToggleName),
         KeyCode::Char('t') if history_display_expanded => Some(Action::ToggleTrailers),
@@ -5717,6 +5772,7 @@ mod tests {
         );
         for (key, expected) in [
             ('d', Action::ToggleDate),
+            ('i', Action::CycleIds),
             ('e', Action::ToggleEmail),
             ('n', Action::ToggleName),
             ('t', Action::ToggleTrailers),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index b7172704599..7eeb665035c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -11,7 +11,7 @@ use crate::{
     BuiltInDiff,
     app::{
         App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesLayout, ChangesMode, CommitRow,
-        CopyKind, DateMode, NameMode, RefMode, SelectionRelation, SignatureState, State,
+        CopyKind, DateMode, IdMode, NameMode, RefMode, SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -397,6 +397,7 @@ pub(crate) fn draw_with_worktree(
     let align_width = max_lane_width.min(align_limit);
     let align_metadata = app.align_metadata;
     let date_mode = app.date_mode;
+    let id_mode = app.effective_id_mode();
     let name_mode = app.name_mode;
     let copy_feedback = app.copy_feedback.take();
     let show_author_name = copy_feedback == Some(CopyKind::Author) || name_mode != NameMode::None;
@@ -415,6 +416,9 @@ pub(crate) fn draw_with_worktree(
                 mailmap,
                 MetadataOptions {
                     date_mode,
+                    id_mode,
+                    change_id: app.change_id(row.id),
+                    duplicate_change_id: app.has_duplicate_change_id(row.id),
                     show_author_name,
                     show_emails: app.show_emails,
                     show_trailers,
@@ -912,6 +916,14 @@ pub(crate) fn draw_with_worktree(
         };
         view_prefix_spans.extend(shortcut(date_label, 'd', date_visible));
         view_prefix_spans.push(Span::raw(" · "));
+        let (id_label, ids_visible) = match (app.id_mode, app.effective_id_mode()) {
+            (IdMode::Off, IdMode::Change) => ("auto change ids", true),
+            (IdMode::Commit, _) => ("commit ids", true),
+            (IdMode::Change, _) => ("change ids", true),
+            (IdMode::Off, _) => ("ids", false),
+        };
+        view_prefix_spans.extend(shortcut(id_label, 'i', ids_visible));
+        view_prefix_spans.push(Span::raw(" · "));
         view_prefix_spans.extend(shortcut("emails", 'e', app.show_emails));
         let (name_label, names_visible) = match app.name_mode {
             NameMode::All => ("names", true),
@@ -1682,6 +1694,9 @@ fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
 #[derive(Clone, Copy)]
 struct MetadataOptions {
     date_mode: DateMode,
+    id_mode: IdMode,
+    change_id: gix::hash::ChangeId,
+    duplicate_change_id: bool,
     show_author_name: bool,
     show_emails: bool,
     show_trailers: bool,
@@ -1703,6 +1718,9 @@ fn metadata_line<'a>(
     debug_assert!(row.metadata_loaded, "visible rows have metadata");
     let MetadataOptions {
         date_mode,
+        id_mode,
+        change_id,
+        duplicate_change_id,
         show_author_name,
         show_emails,
         show_trailers,
@@ -1712,20 +1730,41 @@ fn metadata_line<'a>(
         selected,
         copy_feedback,
     } = options;
-    let id = row.id.to_hex().to_string();
-    let id_style = if copy_feedback == Some(CopyKind::Id) {
+    let commit_style = if copy_feedback == Some(CopyKind::Id) {
         Style::default()
     } else {
         color(Color::Magenta).add_modifier(Modifier::BOLD)
     };
-    let mut spans = vec![Span::styled(
-        id[..7].to_owned(),
+    let change_style = color(Color::LightCyan).add_modifier(Modifier::BOLD);
+    let selected_style = |style: Style| {
         if selected {
-            id_style.add_modifier(Modifier::REVERSED)
+            style.add_modifier(Modifier::REVERSED)
         } else {
-            id_style
-        },
-    )];
+            style
+        }
+    };
+    let mut spans = Vec::new();
+    match id_mode {
+        IdMode::Commit => spans.push(Span::styled(
+            row.id.to_hex_with_len(7).to_string(),
+            selected_style(commit_style),
+        )),
+        IdMode::Change if duplicate_change_id => {
+            spans.push(Span::styled(
+                change_id.to_reverse_hex_with_len(4).to_string(),
+                selected_style(change_style),
+            ));
+            spans.push(Span::styled(
+                row.id.to_hex_with_len(3).to_string(),
+                selected_style(commit_style),
+            ));
+        }
+        IdMode::Change => spans.push(Span::styled(
+            change_id.to_reverse_hex_with_len(7).to_string(),
+            selected_style(change_style),
+        )),
+        IdMode::Off => {}
+    }
     let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
     if row.is_review {
         spans.push(Span::styled(" ◆", decoration_style(DecorationKind::Review)));
@@ -1918,6 +1957,9 @@ pub(crate) fn plain_history_metadata(
         mailmap,
         MetadataOptions {
             date_mode: app.date_mode,
+            id_mode: app.effective_id_mode(),
+            change_id: app.change_id(row.id),
+            duplicate_change_id: app.has_duplicate_change_id(row.id),
             show_author_name: app.name_mode != NameMode::None,
             show_emails: app.show_emails,
             show_trailers: app.name_mode == NameMode::All && app.show_trailers,
@@ -1945,6 +1987,9 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
         mailmap,
         MetadataOptions {
             date_mode: app.date_mode,
+            id_mode: IdMode::Off,
+            change_id: row.id.into(),
+            duplicate_change_id: false,
             show_author_name: app.name_mode != crate::app::NameMode::None,
             show_emails: app.show_emails,
             show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
@@ -1958,7 +2003,6 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
     let mut out = line
         .spans
         .into_iter()
-        .skip(1)
         .map(|span| span.content.into_owned())
         .collect::<String>()
         .trim()
@@ -2512,6 +2556,7 @@ mod tests {
     #[test]
     fn renders_grouped_attributions_and_bot_names() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(LoadedCommits {
             rows: vec![Commit {
                 id: gix::ObjectId::Sha1([1; 20]),
@@ -2715,6 +2760,7 @@ mod tests {
     fn renders_rows_decorations_selection_and_footer() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(vec![Commit {
             id,
             parent_ids: Default::default(),
@@ -2962,6 +3008,7 @@ mod tests {
         let selected = gix::ObjectId::Sha1([1; 20]);
         let head = gix::ObjectId::Sha1([2; 20]);
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(vec![Commit {
             id: selected,
             parent_ids: Default::default(),
@@ -3082,7 +3129,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let footer = rendered_line(&terminal, 1);
-        let view = "view (author date · emails · names · mailmap · trailers · refs · show hidden)";
+        let view = "view (author date · ids · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
             footer.starts_with(&format!("0 commits · {view} · copy · refs · ?")),
             "the active view prefix follows the history position"
@@ -3379,6 +3426,7 @@ mod tests {
     fn removes_the_copied_fields_color_from_only_the_selected_row_for_one_frame()
     -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(
             (1..=2)
                 .map(|n| Commit {
@@ -3529,6 +3577,7 @@ mod tests {
             signature: SignatureState::Unsigned,
         };
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.set_worktree_head(Some(head), false);
         app.extend_commits(vec![commit(child, Some(head)), commit(head, None)]);
         complete(&mut app);
@@ -3999,6 +4048,7 @@ mod tests {
     #[test]
     fn changing_the_changes_height_keeps_history_alignment_stable() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(11);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(
             (1..=10)
                 .map(|n| Commit {
@@ -4082,6 +4132,7 @@ mod tests {
     #[test]
     fn shows_changed_paths_in_a_bottom_pane_below_the_summary() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(6);
+        app.id_mode = IdMode::Commit;
         app.commit_pane_background = Some((15, 16, 17));
         app.extend_commits(vec![
             Commit {
@@ -4917,6 +4968,7 @@ mod tests {
     #[test]
     fn renders_only_the_visible_rows() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(
             (1..=3)
                 .map(|n| Commit {
@@ -4998,6 +5050,7 @@ mod tests {
             signature: SignatureState::Unverified,
         };
         let mut app = App::new(2);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(vec![commit(1)]);
         std::sync::Arc::make_mut(&mut app.rows[0]).parent_ids = [gix::ObjectId::Sha1([2; 20])].into_iter().collect();
         app.extend_hidden_commits(vec![commit(2)]);
@@ -5164,6 +5217,9 @@ mod tests {
             &mailmap,
             MetadataOptions {
                 date_mode: DateMode::Committer,
+                id_mode: IdMode::Commit,
+                change_id: row.id.into(),
+                duplicate_change_id: false,
                 show_author_name: true,
                 show_emails: false,
                 show_trailers: true,
@@ -5217,9 +5273,75 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn hides_ids_by_default_and_color_splits_duplicate_change_ids() {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        let row = &app.rows[0];
+        let plain = plain_history_metadata(
+            &app,
+            row,
+            &Decorations::new(),
+            &gix::mailmap::Snapshot::default(),
+            false,
+        );
+        assert!(!plain.contains("0101010"), "history rows hide IDs by default");
+
+        let change_id = gix::hash::ChangeId::from(gix::ObjectId::Sha1([2; 20]));
+        app.set_change_ids(
+            std::collections::HashMap::from([(id, change_id)]),
+            std::collections::HashSet::from([id]),
+        );
+        let row = &app.rows[0];
+        let decorations = Decorations::new();
+        let mailmap = gix::mailmap::Snapshot::default();
+        let line = metadata_line(
+            row,
+            app.title(row),
+            app.attributions(row),
+            &decorations,
+            &mailmap,
+            MetadataOptions {
+                date_mode: DateMode::None,
+                id_mode: app.effective_id_mode(),
+                change_id: app.change_id(id),
+                duplicate_change_id: app.has_duplicate_change_id(id),
+                show_author_name: false,
+                show_emails: false,
+                show_trailers: false,
+                has_notes: false,
+                use_mailmap: false,
+                ref_mode: RefMode::None,
+                selected: false,
+                copy_feedback: None,
+            },
+        );
+        assert_eq!(line.spans[0].content, change_id.to_reverse_hex_with_len(4).to_string());
+        assert_eq!(
+            line.spans[0].style,
+            color(Color::LightCyan).add_modifier(Modifier::BOLD)
+        );
+        assert_eq!(line.spans[1].content, id.to_hex_with_len(3).to_string());
+        assert_eq!(line.spans[1].style, color(Color::Magenta).add_modifier(Modifier::BOLD));
+    }
+
     #[test]
     fn overlays_metadata_on_wide_graphs_and_allows_natural_flow() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
+        app.id_mode = IdMode::Commit;
         app.extend_commits(vec![Commit {
             id: gix::ObjectId::Sha1([1; 20]),
             parent_ids: Default::default(),

From 1241f414506e9e5e1a965960eb0becaac39d63f3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 10:46:34 +0200
Subject: [PATCH 181/282] feat: show application notices above changes

Operation feedback previously replaced the main footer, hiding status and controls while also truncating longer messages. Render shared severity-colored notices in reserved wrapped space aligned with worktree changes, and use the same surface for persistent confirmations in history and ref-tree views.
---
 gix-tix/spec.md         |  20 +++--
 gix-tix/src/app.rs      |  92 ++++++++++++++++---
 gix-tix/src/lib.rs      | 142 ++++++++++++++---------------
 gix-tix/src/ref_tree.rs |  64 +++++++++++---
 gix-tix/src/ui.rs       | 192 ++++++++++++++++++++++++++++------------
 5 files changed, 352 insertions(+), 158 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 848f650aaf5..8464d3000cd 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -641,8 +641,8 @@ space first; changes blocks adapt within the remaining history width.
 - A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
-- A materialized todo conflict keeps a high-contrast `REBASE PAUSED` footer until
-  its in-memory continuation is consumed. The footer changes when the index is
+- A materialized todo conflict keeps a high-contrast `REBASE PAUSED` attention notice until
+  its in-memory continuation is consumed. The notice changes when the index is
   resolved but always advertises `<enter>` to continue and `Esc` to stop. History,
   changes-pane navigation, display toggles, copying, and path-diff inspection stay
   available; repository-changing actions and refresh are blocked. Pane-local
@@ -709,7 +709,7 @@ space first; changes blocks adapt within the remaining history width.
 
 - `e`, then `d`, is available after history completion for a selected non-merge
   commit with no known merge descendant. The first `d` arms a
-  `d again forget` confirmation; the second performs it. Navigation, refresh,
+  yellow notice asking for `d` again; the second performs it. Navigation, refresh,
   cancellation, selection changes, and other commands disarm confirmation.
 - Forgetting does not require a worktree. Linear descendants are reparented with
   unchanged trees and marked for lazy replay; mutable refs throughout the
@@ -943,7 +943,7 @@ space first; changes blocks adapt within the remaining history width.
   working directory may have disappeared. Before processing filesystem events or
   redrawing, it lexically normalizes and enters the common repository, reopens it
   as bare, drops worktree state, keeps tree/history views live, and reports recovery
-  in the status line. If recovery fails, terminal state is restored and the
+  in the attention notice. If recovery fails, terminal state is restored and the
   contextual error is returned.
 
 ## Resource and responsiveness invariants
@@ -966,9 +966,15 @@ space first; changes blocks adapt within the remaining history width.
 - Main status remains readable regardless of pane focus. Errors are surfaced in
   the nearest relevant status line; diagnostics never replace user-visible
   errors.
-- Global command and recovery feedback uses one transient message channel. A
-  message replaces the main status line until the next recognized user action;
-  pane-specific errors remain in their pane status line.
+- Global command and recovery feedback uses one transient notice channel in the
+  history and ref-tree views. It reserves a wrapped, content-height block above
+  worktree changes until the next recognized user action, matching that pane's
+  horizontal bounds when visible and otherwise using the main view. It never
+  covers the main or pane-local status lines. Green indicates success, yellow
+  indicates attention, no-op, recovery, partial success, or an armed prompt, and
+  red indicates failure. Forget, review selection and recovery, suspended
+  conflicts, and paused rebases retain their notice until resolved; pane-specific
+  errors remain in their pane status line.
 - Closing the new-commit editor without changing its prepared buffer leaves the
   repository untouched and reports `no commit created: no input was provided`.
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 53a3d0fc719..9eb67c8df06 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -50,6 +50,19 @@ pub(crate) enum SignatureState {
     PendingRebase,
 }
 
+#[derive(Clone, Copy, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub(crate) enum NoticeKind {
+    Success,
+    Attention,
+    Error,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Notice {
+    pub kind: NoticeKind,
+    pub text: String,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum ChangeKind {
     Added,
@@ -449,7 +462,7 @@ pub(crate) struct App {
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
-    message: Option<String>,
+    notice: Option<Notice>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) edit_expanded: bool,
@@ -544,7 +557,7 @@ impl App {
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
-            message: None,
+            notice: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             edit_expanded: false,
@@ -610,12 +623,54 @@ impl App {
         self.duplicate_change_ids.clear();
     }
 
-    pub(crate) fn leave_message(&mut self, message: impl Into<String>) {
-        self.message = Some(message.into());
+    pub(crate) fn leave_attention(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Attention, message);
+    }
+
+    pub(crate) fn leave_success(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Success, message);
     }
 
-    pub(crate) fn message(&self) -> Option<&str> {
-        self.message.as_deref()
+    pub(crate) fn leave_error(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Error, message);
+    }
+
+    fn leave_notice(&mut self, kind: NoticeKind, message: impl Into<String>) {
+        self.notice = Some(Notice {
+            kind,
+            text: message.into(),
+        });
+    }
+
+    pub(crate) fn notice(&self) -> Option<Notice> {
+        let prompt = if self.rebase_continuation_pending() {
+            Some(if self.rebase_continuation_conflicted() {
+                "REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"
+            } else {
+                "REBASE PAUSED · <enter> continue · Esc stop"
+            })
+        } else if self.pending_rebase_conflict.is_some() {
+            Some("rebase conflict · <enter> checkout for resolution · any other key cancel")
+        } else if self.review_return_selection_active() {
+            Some("review return is missing · j/k select commit · <enter> finish detached · Esc cancel")
+        } else if self.review_selection_active() {
+            Some("review base · j/k select ancestor · <enter> start · Esc cancel")
+        } else if self.forget_confirmation_visible() {
+            Some("forget commit · d again confirm · any other action cancel")
+        } else {
+            None
+        };
+        match (prompt, self.notice.as_ref()) {
+            (Some(prompt), Some(notice)) if notice.text != prompt => Some(Notice {
+                kind: notice.kind.max(NoticeKind::Attention),
+                text: format!("{prompt} · {}", notice.text),
+            }),
+            (Some(prompt), _) => Some(Notice {
+                kind: NoticeKind::Attention,
+                text: prompt.into(),
+            }),
+            (None, notice) => notice.cloned(),
+        }
     }
 
     pub(crate) fn configure_hidden_filter(&mut self, present: bool) {
@@ -645,7 +700,6 @@ impl App {
         );
         self.pending_rebase_conflict = Some(id);
         self.rebase_continuation_pending = false;
-        self.leave_message("rebase conflict · <enter> checkout for resolution · any other key cancel");
     }
 
     pub(crate) fn has_rebase_conflict(&self) -> bool {
@@ -654,7 +708,7 @@ impl App {
 
     pub(crate) fn clear_rebase_conflict(&mut self) {
         self.pending_rebase_conflict = None;
-        self.message = None;
+        self.notice = None;
     }
 
     pub(crate) fn begin_conflict_resolution(&mut self) {
@@ -861,7 +915,7 @@ impl App {
     }
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
-        self.message = None;
+        self.notice = None;
         if !matches!(&action, Action::Forget) {
             self.forget_confirmation = None;
         }
@@ -1202,7 +1256,6 @@ impl App {
                     self.clear_review_selection();
                     return vec![Effect::StartReview { tip, base }];
                 }
-                self.leave_message("review base · j/k select ancestor · <enter> start · Esc cancel");
             }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
@@ -2914,6 +2967,11 @@ mod tests {
         assert!(!app.is_row_reachable(3), "review commits are not return candidates");
         assert!(!app.is_row_reachable(4), "unrelated commits are not return candidates");
         app.update(Action::MoveUp);
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("review return is missing · j/k select commit · <enter> finish detached · Esc cancel".into()),
+            "navigation retains the return-selection prompt"
+        );
         assert_eq!(
             app.selected.map(|index| app.rows[index].id),
             Some(id(5)),
@@ -2945,8 +3003,17 @@ mod tests {
             "the first d only arms confirmation"
         );
         assert!(app.forget_confirmation_visible());
+        assert_eq!(
+            app.notice().map(|notice| (notice.kind, notice.text)),
+            Some((
+                NoticeKind::Attention,
+                "forget commit · d again confirm · any other action cancel".into()
+            )),
+            "the armed confirmation owns a persistent attention notice"
+        );
         app.update(Action::MoveDown);
         assert!(!app.forget_confirmation_visible(), "navigation cancels confirmation");
+        assert!(app.notice().is_none(), "cancelling the confirmation removes its notice");
         assert!(app.can_forget(), "a commit with linear descendants can be forgotten");
         app.update(Action::MoveUp);
         assert!(app.update(Action::Forget).is_empty());
@@ -3236,6 +3303,11 @@ mod tests {
         assert!(app.is_row_reachable(tip_index));
         assert!(!app.is_row_reachable(unrelated));
         app.update(Action::MoveDown);
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("review base · j/k select ancestor · <enter> start · Esc cancel".into()),
+            "navigation retains the review-base prompt"
+        );
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(3)));
         app.update(Action::MoveDown);
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 2ab90317fe6..66c9532ae00 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -916,7 +916,7 @@ fn event_loop(
     app.set_worktree_head_unborn(worktree_head_unborn);
     app.commit_pane_background = commit_pane_background;
     if recovered_at_startup {
-        app.leave_message("worktree removed; using the common repository without worktree changes");
+        app.leave_attention("worktree removed; using the common repository without worktree changes");
     }
     let mut lane_receiver = None;
     let mut refresh_receiver: Option<mpsc::Receiver<(RefreshKind, HistoryGraph, Result<history::Refresh>)>> = None;
@@ -1030,7 +1030,7 @@ fn event_loop(
                 }
             };
             ref_watch_set_changed = false;
-            app.leave_message("worktree removed; using the common repository without worktree changes");
+            app.leave_attention("worktree removed; using the common repository without worktree changes");
             if history_graph.is_some() {
                 refresh_pending = true;
                 refresh_from_filesystem = true;
@@ -1593,7 +1593,7 @@ fn event_loop(
                             Ok(pins) if !pins.is_empty() => {
                                 app.select_commit_after_refresh(pins[0].id);
                                 return_to_history_after_refresh = Some(pins[0].id);
-                                app.leave_message(if pins.len() == 1 {
+                                app.leave_success(if pins.len() == 1 {
                                     "pinned selected reference".into()
                                 } else {
                                     format!("pinned {} selected references", pins.len())
@@ -1601,8 +1601,10 @@ fn event_loop(
                                 refresh_pending = true;
                                 refresh_expand_hidden = true;
                             }
-                            Ok(_) => ref_tree.leave_message("selected references changed before they could be pinned"),
-                            Err(err) => ref_tree.leave_message(format!("pin selected references: {err:#}")),
+                            Ok(_) => {
+                                ref_tree.leave_attention("selected references changed before they could be pinned");
+                            }
+                            Err(err) => ref_tree.leave_error(format!("pin selected references: {err:#}")),
                         }
                         dirty = true;
                         urgent = true;
@@ -1613,7 +1615,7 @@ fn event_loop(
                             Ok(repository) => {
                                 ref_tree.set_remote_deletions(ref_tree::resolve_remote_deletions(&repository, names));
                             }
-                            Err(err) => ref_tree.leave_message(format!("remote edit: {err:#}")),
+                            Err(err) => ref_tree.leave_error(format!("remote edit: {err:#}")),
                         }
                         dirty = true;
                         urgent = true;
@@ -1635,19 +1637,23 @@ fn event_loop(
                         match open_repository(&repository_path, repository_is_bare, false) {
                             Ok(mut repository) => match repository.delete_local_branches(names) {
                                 Ok(()) => {
-                                    ref_tree.leave_message(format!("deleted {label}"));
+                                    ref_tree.leave_success(format!("deleted {label}"));
                                     deleted = true;
                                     refresh_pending = true;
                                 }
                                 Err(err) => {
                                     let changed =
                                         matches!(&err, gix::repository::branch::delete::Error::Cleanup { .. });
-                                    ref_tree.leave_message(format!("delete {label}: {err}"));
+                                    if changed {
+                                        ref_tree.leave_attention(format!("delete {label}: {err}"));
+                                    } else {
+                                        ref_tree.leave_error(format!("delete {label}: {err}"));
+                                    }
                                     deleted = changed;
                                     refresh_pending |= changed;
                                 }
                             },
-                            Err(err) => ref_tree.leave_message(format!("delete {label}: {err:#}")),
+                            Err(err) => ref_tree.leave_error(format!("delete {label}: {err:#}")),
                         }
                         if deleted {
                             ref_tree.select_after_reference_deletion(fallback);
@@ -1670,15 +1676,16 @@ fn event_loop(
                                     outcome.deleted,
                                     if outcome.deleted == 1 { "" } else { "s" }
                                 );
-                                ref_tree.leave_message(if outcome.failures.is_empty() {
-                                    deleted
+                                if outcome.failures.is_empty() {
+                                    ref_tree.leave_success(deleted);
                                 } else if outcome.deleted == 0 {
-                                    format!("delete on remote: {}", outcome.failures.join("; "))
+                                    ref_tree.leave_error(format!("delete on remote: {}", outcome.failures.join("; ")));
                                 } else {
-                                    format!("{deleted}; failed: {}", outcome.failures.join("; "))
-                                });
+                                    ref_tree
+                                        .leave_attention(format!("{deleted}; failed: {}", outcome.failures.join("; ")));
+                                }
                             }
-                            Err(err) => ref_tree.leave_message(format!("delete on remote: {err:#}")),
+                            Err(err) => ref_tree.leave_error(format!("delete on remote: {err:#}")),
                         }
                         dirty = true;
                         urgent = true;
@@ -1815,13 +1822,13 @@ fn event_loop(
                     Ok((notice, id)) => {
                         tracing::info!(commit_id = %original, rewritten_id = %id, "accepted suspended rebase conflict");
                         app.begin_conflict_resolution();
-                        app.leave_message(notice);
+                        app.leave_attention(notice);
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
                         tracing::warn!(commit_id = %original, error = %err, "suspended rebase conflict checkout failed");
                         app.clear_rebase_conflict();
-                        app.leave_message(format!("conflict checkout: {err:#}"));
+                        app.leave_error(format!("conflict checkout: {err:#}"));
                     }
                 }
                 sync_line_diff_pool(
@@ -1872,12 +1879,12 @@ fn event_loop(
                         pending_todo_rebase_plan = Some(plan);
                         app.begin_conflict_resolution();
                         app.arm_rebase_continuation();
-                        app.leave_message(format!("{notice}; resolve the index, then press <enter>"));
+                        app.leave_attention(format!("{notice}; resolve the index, then press <enter>"));
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
                         app.clear_rebase_conflict();
-                        app.leave_message(format!("conflict checkout: {err:#}"));
+                        app.leave_error(format!("conflict checkout: {err:#}"));
                     }
                 }
                 invalidate_worktree_changes(&mut worktree_changes);
@@ -1902,7 +1909,7 @@ fn event_loop(
         {
             drop(pending_todo_rebase_plan.take());
             app.clear_rebase_continuation();
-            app.leave_message("stopped rebase continuation; the partially applied repository remains unchanged");
+            app.leave_attention("stopped rebase continuation; the partially applied repository remains unchanged");
             tracing::info!("stopped materialized rebase continuation without rolling back repository state");
             dirty = true;
             urgent = true;
@@ -1941,11 +1948,10 @@ fn event_loop(
                     app.clear_rebase_conflict();
                     app.clear_rebase_continuation();
                     app.set_worktree_conflicted(false);
-                    app.leave_message(
-                        notice
-                            .unwrap_or_else(|err| Some(format!("rebase applied, checkout failed: {err:#}")))
-                            .unwrap_or_else(|| "rebased history".into()),
-                    );
+                    match notice {
+                        Ok(notice) => app.leave_success(notice.unwrap_or_else(|| "rebased history".into())),
+                        Err(err) => app.leave_attention(format!("rebase applied, checkout failed: {err:#}")),
+                    }
                     refresh_pending = true;
                 }
                 Ok(edit::rebase::PlanPerform::Conflict(conflict)) => {
@@ -1963,7 +1969,7 @@ fn event_loop(
                 }
                 Err(err) => {
                     pending_todo_rebase_plan = Some(plan);
-                    app.leave_message(format!("continue rebase: {err:#}"));
+                    app.leave_error(format!("continue rebase: {err:#}"));
                 }
             }
             invalidate_worktree_changes(&mut worktree_changes);
@@ -2109,7 +2115,7 @@ fn event_loop(
                         .and_then(|diff| show_commit_diff(terminal, diff, enhanced_keyboard));
                     match result {
                         Ok(true) => app.focus_history(),
-                        Err(err) => app.leave_message(format!("diff: {err:#}")),
+                        Err(err) => app.leave_error(format!("diff: {err:#}")),
                         Ok(false) => {}
                     }
                 }
@@ -2129,7 +2135,7 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(new_id)) => {
-                            app.leave_message(format!(
+                            app.leave_success(format!(
                                 "reworded {} as {}",
                                 id.to_hex_with_len(7),
                                 new_id.to_hex_with_len(7)
@@ -2138,7 +2144,7 @@ fn event_loop(
                             refresh_pending = true;
                         }
                         Ok(None) => {}
-                        Err(err) => app.leave_message(format!("reword: {err:#}")),
+                        Err(err) => app.leave_error(format!("reword: {err:#}")),
                     }
                 }
                 Effect::NewCommit { parent, empty } => {
@@ -2162,12 +2168,12 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(new_id)) => {
-                            app.leave_message(format!("created {}", new_id.to_hex_with_len(7)));
+                            app.leave_success(format!("created {}", new_id.to_hex_with_len(7)));
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
-                        Ok(None) => app.leave_message("no commit created: no input was provided"),
-                        Err(err) => app.leave_message(format!("new commit: {err:#}")),
+                        Ok(None) => app.leave_attention("no commit created: no input was provided"),
+                        Err(err) => app.leave_error(format!("new commit: {err:#}")),
                     }
                 }
                 Effect::ForkCommit(parent) => {
@@ -2207,7 +2213,7 @@ fn event_loop(
                                 });
                             match travel {
                                 Ok(edit::time_travel::Perform::Complete(notice)) => {
-                                    app.leave_message(notice.map_or_else(
+                                    app.leave_success(notice.map_or_else(
                                         || format!("created fork {}", new_id.to_hex_with_len(7)),
                                         |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
                                     ));
@@ -2222,7 +2228,7 @@ fn event_loop(
                                     pending_rebase_conflict = Some(conflict);
                                 }
                                 Err(err) => {
-                                    app.leave_message(format!(
+                                    app.leave_attention(format!(
                                         "created fork {}, but checkout failed: {err:#}",
                                         new_id.to_hex_with_len(7)
                                     ));
@@ -2230,8 +2236,8 @@ fn event_loop(
                                 }
                             }
                         }
-                        Ok(None) => app.leave_message("no fork created: no input was provided"),
-                        Err(err) => app.leave_message(format!("fork: {err:#}")),
+                        Ok(None) => app.leave_attention("no fork created: no input was provided"),
+                        Err(err) => app.leave_error(format!("fork: {err:#}")),
                     }
                 }
                 Effect::Split(id) => {
@@ -2245,7 +2251,7 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(new_id)) => {
-                            app.leave_message(format!(
+                            app.leave_success(format!(
                                 "split {} as {}",
                                 id.to_hex_with_len(7),
                                 new_id.to_hex_with_len(7)
@@ -2254,8 +2260,8 @@ fn event_loop(
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
-                        Ok(None) => app.leave_message("no split performed: no input was provided"),
-                        Err(err) => app.leave_message(format!("split: {err:#}")),
+                        Ok(None) => app.leave_attention("no split performed: no input was provided"),
+                        Err(err) => app.leave_error(format!("split: {err:#}")),
                     }
                 }
                 edit @ (Effect::Amend(id) | Effect::Spill(id)) => {
@@ -2312,7 +2318,7 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(new_id)) => {
-                            app.leave_message(format!(
+                            app.leave_success(format!(
                                 "{verb}ed {} as {}",
                                 id.to_hex_with_len(7),
                                 new_id.to_hex_with_len(7)
@@ -2321,8 +2327,8 @@ fn event_loop(
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
-                        Ok(None) => app.leave_message(format!("nothing to {verb}")),
-                        Err(err) => app.leave_message(format!("{verb}: {err:#}")),
+                        Ok(None) => app.leave_attention(format!("nothing to {verb}")),
+                        Err(err) => app.leave_error(format!("{verb}: {err:#}")),
                     }
                 }
                 Effect::Stash(id) => {
@@ -2330,12 +2336,12 @@ fn event_loop(
                     fill_repository.retained = None;
                     match edit::stash::save_manual(&repository_path, repository_is_bare, id) {
                         Ok(notice) => {
-                            app.leave_message(notice);
+                            app.leave_success(notice);
                             app.select_commit_after_refresh(id);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_message(format!("stash: {err:#}")),
+                        Err(err) => app.leave_error(format!("stash: {err:#}")),
                     }
                 }
                 Effect::Unstash(id) => {
@@ -2343,12 +2349,12 @@ fn event_loop(
                     fill_repository.retained = None;
                     match edit::stash::restore_manual(&repository_path, repository_is_bare, id) {
                         Ok(notice) => {
-                            app.leave_message(notice);
+                            app.leave_success(notice);
                             app.select_commit_after_refresh(id);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_message(format!("unstash: {err:#}")),
+                        Err(err) => app.leave_error(format!("unstash: {err:#}")),
                     }
                 }
                 Effect::Forget(id) => {
@@ -2371,14 +2377,14 @@ fn event_loop(
                             });
                             match returned.transpose() {
                                 Ok(Some((selected, _))) => {
-                                    app.leave_message("cancelled review");
+                                    app.leave_attention("cancelled review");
                                     app.select_commit_after_refresh(selected);
                                 }
                                 Err(err) => {
-                                    app.leave_message(format!("review cancelled, return checkout failed: {err:#}"));
+                                    app.leave_attention(format!("review cancelled, return checkout failed: {err:#}"));
                                 }
                                 Ok(None) => {
-                                    app.leave_message(format!("forgot {}", id.to_hex_with_len(7)));
+                                    app.leave_success(format!("forgot {}", id.to_hex_with_len(7)));
                                     if let Some(selected) = outcome.selected {
                                         app.select_commit(selected);
                                     }
@@ -2387,7 +2393,7 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_message(format!("forget: {err:#}")),
+                        Err(err) => app.leave_error(format!("forget: {err:#}")),
                     }
                 }
                 Effect::Rebase { base, onto, commits } => {
@@ -2438,13 +2444,13 @@ fn event_loop(
                             };
                             match notice {
                                 Ok(notice) => {
-                                    app.leave_message(notice.unwrap_or_else(|| "rebased history".to_owned()));
+                                    app.leave_success(notice.unwrap_or_else(|| "rebased history".to_owned()));
                                     app.select_commit_after_refresh(base);
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
                                 Err(err) => {
-                                    app.leave_message(format!("rebase applied, checkout failed: {err:#}"));
+                                    app.leave_attention(format!("rebase applied, checkout failed: {err:#}"));
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
@@ -2463,8 +2469,8 @@ fn event_loop(
                             app.select_commit(id);
                             pending_todo_rebase_conflict = Some(conflict);
                         }
-                        Ok(None) => app.leave_message("no rebase performed: the todo was unchanged"),
-                        Err(err) => app.leave_message(format!("rebase: {err:#}")),
+                        Ok(None) => app.leave_attention("no rebase performed: the todo was unchanged"),
+                        Err(err) => app.leave_error(format!("rebase: {err:#}")),
                     }
                 }
                 Effect::StartReview { tip, base } => {
@@ -2476,7 +2482,7 @@ fn event_loop(
                         .and_then(|graph| edit::review::start(&repository_path, repository_is_bare, graph, tip, base));
                     match result {
                         Ok(started) => {
-                            app.leave_message(format!(
+                            app.leave_success(format!(
                                 "started review {} at {}",
                                 started.reference.shorten(),
                                 started.commit.to_hex_with_len(7)
@@ -2485,7 +2491,7 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_message(format!("review: {err:#}")),
+                        Err(err) => app.leave_error(format!("review: {err:#}")),
                     }
                 }
                 Effect::FinishReview { review: id, return_to } => {
@@ -2510,12 +2516,12 @@ fn event_loop(
                                 false,
                             );
                             match checkout {
-                                Ok(_) => app.leave_message(format!(
+                                Ok(_) => app.leave_success(format!(
                                     "finished review as {}",
                                     finished.commit.to_hex_with_len(7)
                                 )),
                                 Err(err) => {
-                                    app.leave_message(format!("review applied, return checkout failed: {err:#}"));
+                                    app.leave_attention(format!("review applied, return checkout failed: {err:#}"));
                                 }
                             }
                             app.select_commit_after_refresh(finished.outcome.selected.unwrap_or(finished.commit));
@@ -2523,17 +2529,13 @@ fn event_loop(
                             refresh_pending = true;
                         }
                         Ok(edit::review::Finish::SelectReturn { tip }) => {
-                            if app.select_review_return(id, tip) {
-                                app.leave_message(
-                                    "review return is missing · j/k select commit · <enter> finish detached · Esc cancel",
-                                );
-                            } else {
-                                app.leave_message(
+                            if !app.select_review_return(id, tip) {
+                                app.leave_error(
                                     "finish review: no visible return commit descends from the reviewed tip",
                                 );
                             }
                         }
-                        Err(err) => app.leave_message(format!("finish review: {err:#}")),
+                        Err(err) => app.leave_error(format!("finish review: {err:#}")),
                     }
                 }
                 Effect::TimeTravel(id) => {
@@ -2557,7 +2559,7 @@ fn event_loop(
                     match result {
                         Ok(edit::time_travel::Perform::Complete(Some(notice))) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
-                            app.leave_message(notice);
+                            app.leave_success(notice);
                             if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
                                 .and_then(|repo| Ok(repo.head_id()?.detach()))
                             {
@@ -2574,7 +2576,7 @@ fn event_loop(
                             pending_rebase_conflict = Some(conflict);
                         }
                         Err(err) => {
-                            app.leave_message(format!("time-travel: {err:#}"));
+                            app.leave_error(format!("time-travel: {err:#}"));
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
@@ -2584,13 +2586,13 @@ fn event_loop(
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     match edit::time_travel::remove_pins(&repository_path, repository_is_bare, id) {
-                        Ok(0) => app.leave_message("no pins removed"),
+                        Ok(0) => app.leave_attention("no pins removed"),
                         Ok(count) => {
-                            app.leave_message(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
+                            app.leave_success(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
                             app.select_commit_after_refresh(id);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_message(format!("unpin: {err:#}")),
+                        Err(err) => app.leave_error(format!("unpin: {err:#}")),
                     }
                 }
                 Effect::VerifySignatures(ids) => {
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index b20a3844885..d13644f9533 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -16,9 +16,9 @@ use ratatui::{
 };
 
 use crate::{
-    app::LaneState,
+    app::{LaneState, Notice, NoticeKind},
     history::{CommitIndex, Decoration, DecorationKind, Decorations, HistoryGraph, RefSnapshot},
-    ui::decoration_style,
+    ui::{decoration_style, notice_area, render_notice},
 };
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
@@ -165,7 +165,7 @@ pub(crate) struct Tree {
     hide_tags: bool,
     edit_expanded: bool,
     remote_deletions: Vec<RemoteDeletion>,
-    message: Option<String>,
+    notice: Option<Notice>,
     history_commits: HashSet<ObjectId>,
 }
 
@@ -188,8 +188,23 @@ impl Tree {
         self.edit_expanded = false;
     }
 
-    pub(crate) fn leave_message(&mut self, message: impl Into<String>) {
-        self.message = Some(message.into());
+    pub(crate) fn leave_attention(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Attention, message);
+    }
+
+    pub(crate) fn leave_success(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Success, message);
+    }
+
+    pub(crate) fn leave_error(&mut self, message: impl Into<String>) {
+        self.leave_notice(NoticeKind::Error, message);
+    }
+
+    fn leave_notice(&mut self, kind: NoticeKind, message: impl Into<String>) {
+        self.notice = Some(Notice {
+            kind,
+            text: message.into(),
+        });
     }
 
     pub(crate) fn set_history_commits(&mut self, commits: impl IntoIterator<Item = ObjectId>) {
@@ -262,7 +277,7 @@ impl Tree {
     }
 
     pub(crate) fn handle_key(&mut self, key: KeyEvent) -> Input {
-        self.message = None;
+        self.notice = None;
         if key.code == KeyCode::Char('c') && key.modifiers.contains(KeyModifiers::CONTROL)
             || key.code == KeyCode::Char('q')
         {
@@ -282,7 +297,7 @@ impl Tree {
             if key.code == KeyCode::Char('d') && key.modifiers.is_empty() {
                 let branches = self.selected_local_branches();
                 if branches.is_empty() {
-                    self.message = Some("no deletable local branches at the selected node".into());
+                    self.leave_attention("no deletable local branches at the selected node");
                     return Input::Handled;
                 }
                 return Input::DeleteLocalBranches {
@@ -408,8 +423,15 @@ impl Tree {
                 .as_ref()
                 .map(|overview| Overlay::new(graph, overview, selected));
         }
-        let [body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
+        let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
         frame.render_widget(Clear, frame.area());
+        let notice = self.notice.clone();
+        let notice_area = notice
+            .as_ref()
+            .and_then(|notice| notice_area(notice, body, body.y, body.bottom()));
+        if let Some(notice_area) = notice_area {
+            body.height = notice_area.y.saturating_sub(body.y);
+        }
         let Some(overview) = self.overview.as_ref() else {
             frame.render_widget(Paragraph::new("ref-tree overview unavailable"), body);
             return;
@@ -466,9 +488,7 @@ impl Tree {
             &self.choices,
             &self.history_commits,
         );
-        let footer_text = if let Some(message) = &self.message {
-            message.clone()
-        } else if self.edit_expanded {
+        let footer_text = if self.edit_expanded {
             let branches = self.selected_local_branches();
             if branches.is_empty() && self.remote_deletions.is_empty() {
                 "ref-tree · e edit (no actions)".into()
@@ -503,6 +523,9 @@ impl Tree {
             Paragraph::new(footer_text).style(Style::default().add_modifier(Modifier::DIM)),
             footer,
         );
+        if let (Some(area), Some(notice)) = (notice_area, notice.as_ref()) {
+            render_notice(frame, area, notice);
+        }
     }
 
     fn selected_local_branches(&self) -> Vec<gix::refs::FullName> {
@@ -1823,7 +1846,7 @@ mod tests {
             Input::Handled
         );
         assert_eq!(
-            tree.message.as_deref(),
+            tree.notice.as_ref().map(|notice| notice.text.as_str()),
             Some("no deletable local branches at the selected node")
         );
     }
@@ -2425,6 +2448,23 @@ mod tests {
                 .contains(Modifier::REVERSED),
             "a selected synthetic node keeps its disk inverted"
         );
+        tree.leave_error("remote deletion failed");
+        terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
+        assert_eq!(terminal.backend().buffer()[(0, 16)].bg, Color::LightRed);
+        assert!(
+            terminal
+                .backend()
+                .buffer()
+                .content
+                .chunks(100)
+                .last()
+                .expect("the terminal has a footer")
+                .iter()
+                .map(ratatui::buffer::Cell::symbol)
+                .collect::<String>()
+                .contains("ref-tree"),
+            "ref-tree notices leave its footer visible"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7eeb665035c..c9c2ee8ea2e 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -11,7 +11,7 @@ use crate::{
     BuiltInDiff,
     app::{
         App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesLayout, ChangesMode, CommitRow,
-        CopyKind, DateMode, IdMode, NameMode, RefMode, SelectionRelation, SignatureState, State,
+        CopyKind, DateMode, IdMode, NameMode, Notice, NoticeKind, RefMode, SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -22,6 +22,43 @@ const FILESYSTEM_NOTIFICATION_COLOR: Color = Color::Rgb(255, 165, 0);
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
+pub(crate) fn notice_area(notice: &Notice, horizontal: Rect, top: u16, bottom: u16) -> Option<Rect> {
+    if horizontal.width == 0 || top >= bottom {
+        return None;
+    }
+    let height = u16::try_from(
+        Paragraph::new(notice.text.as_str())
+            .wrap(Wrap { trim: false })
+            .line_count(horizontal.width),
+    )
+    .unwrap_or(u16::MAX)
+    .max(1)
+    .min(bottom.saturating_sub(top));
+    Some(Rect::new(
+        horizontal.x,
+        bottom.saturating_sub(height),
+        horizontal.width,
+        height,
+    ))
+}
+
+pub(crate) fn render_notice(frame: &mut Frame<'_>, area: Rect, notice: &Notice) {
+    let background = match notice.kind {
+        NoticeKind::Success => Color::Green,
+        NoticeKind::Attention => Color::Yellow,
+        NoticeKind::Error => Color::LightRed,
+    };
+    frame.render_widget(
+        Paragraph::new(notice.text.as_str()).wrap(Wrap { trim: false }).style(
+            Style::default()
+                .fg(Color::Black)
+                .bg(background)
+                .add_modifier(Modifier::BOLD),
+        ),
+        area,
+    );
+}
+
 pub(crate) fn draw_rebase_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::PlanProgress) {
     let area = frame.area();
     frame.render_widget(Clear, area);
@@ -286,6 +323,25 @@ pub(crate) fn draw_with_worktree(
             )
         }),
     );
+    let notice = app.notice();
+    let worktree_pane = changes_panes.iter().find(|pane| pane.pane == ChangePane::Worktree);
+    let notice_horizontal = worktree_pane.map_or(body, |pane| pane.outer);
+    let notice_bottom = worktree_pane.map_or_else(
+        || {
+            changes_panes
+                .iter()
+                .map(|pane| pane.outer.y)
+                .min()
+                .unwrap_or(body.bottom())
+        },
+        |pane| pane.outer.y,
+    );
+    let notice_area = notice
+        .as_ref()
+        .and_then(|notice| notice_area(notice, notice_horizontal, body.y, notice_bottom));
+    if let Some(notice_area) = notice_area {
+        body.height = notice_area.y.saturating_sub(body.y);
+    }
     let worktree_dirty = worktree_changes.is_some_and(|changes| !changes.paths.is_empty())
         && changes_panes
             .iter()
@@ -360,6 +416,7 @@ pub(crate) fn draw_with_worktree(
     app.viewport_rows = changes_panes
         .iter()
         .map(|pane| pane.outer.y.saturating_sub(body.y))
+        .chain(notice_area.map(|area| area.y.saturating_sub(body.y)))
         .min()
         .unwrap_or(body.height)
         .max(1) as usize;
@@ -772,17 +829,6 @@ pub(crate) fn draw_with_worktree(
         State::Cancelled => " · cancelled",
     };
     let mut footer_spans = vec![Span::raw(status)];
-    if app.review_return_selection_active() {
-        footer_spans.push(Span::styled(
-            " · review return (<enter> finish detached · Esc cancel)",
-            Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
-        ));
-    } else if app.review_selection_active() {
-        footer_spans.push(Span::styled(
-            " · review base (<enter> start · Esc cancel)",
-            Style::default().fg(Color::LightMagenta).add_modifier(Modifier::BOLD),
-        ));
-    }
     let mut time_travel = None;
     let mut edit_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
@@ -854,11 +900,7 @@ pub(crate) fn draw_with_worktree(
                 options.push(("split", 'p'));
             }
             if app.changes_focus.is_none() && app.can_forget() {
-                options.push(if app.forget_confirmation_visible() {
-                    ("d again forget", 'd')
-                } else {
-                    ("d forget", 'd')
-                });
+                options.push(("d forget", 'd'));
             }
             if app.changes_focus.is_none()
                 && app
@@ -1014,37 +1056,20 @@ pub(crate) fn draw_with_worktree(
         footer_spans.push(Span::raw(" · "));
         footer_spans.extend(shortcut("quit", 'q', true));
     }
-    let mut footer_style = Style::default();
-    if app.rebase_continuation_pending() {
-        footer_spans = vec![Span::raw(if app.rebase_continuation_conflicted() {
-            "REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"
-        } else {
-            "REBASE PAUSED · <enter> continue · Esc stop"
-        })];
-        if let Some(message) = app.message() {
-            footer_spans.push(Span::raw(format!(" · {message}")));
-        }
-        footer_style = Style::default()
-            .fg(Color::Black)
-            .bg(if app.rebase_continuation_conflicted() {
-                Color::LightRed
-            } else {
-                Color::Yellow
-            })
-            .add_modifier(Modifier::BOLD);
-    } else if let Some(message) = app.message() {
-        footer_spans = vec![Span::raw(message)];
-    }
-    if app.unseen_filesystem_redraw && !app.rebase_continuation_pending() {
+    if app.unseen_filesystem_redraw {
         footer_spans = notification_discs(footer_spans);
     }
-    frame.render_widget(Paragraph::new(Line::from(footer_spans)).style(footer_style), footer);
+    frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
+    if let (Some(area), Some(notice)) = (notice_area, notice.as_ref()) {
+        render_notice(frame, area, notice);
+    }
     FrameLayout {
         history: body,
         overlays: changes_panes
             .iter()
             .map(|pane| pane.outer)
             .chain(commit_pane.map(|(outer, _)| outer))
+            .chain(notice_area)
             .collect(),
         rows,
     }
@@ -2273,40 +2298,49 @@ mod tests {
     }
 
     #[test]
-    fn materialized_rebase_continuation_replaces_the_footer_until_cleared() -> Result<(), Box<dyn std::error::Error>> {
+    fn materialized_rebase_continuation_uses_a_persistent_notice_above_the_footer()
+    -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
         complete(&mut app);
         app.arm_rebase_continuation();
         app.set_worktree_conflicted(true);
-        app.leave_message("materialized conflict");
-        let mut terminal = Terminal::new(TestBackend::new(120, 1))?;
+        app.leave_attention("materialized conflict");
+        let mut terminal = Terminal::new(TestBackend::new(120, 3))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        let footer = rendered_line(&terminal, 0);
+        let notice = rendered_line(&terminal, 1);
         assert!(
-            footer.starts_with("REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"),
-            "an unresolved continuation owns the footer: {footer:?}"
+            notice.starts_with("REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"),
+            "an unresolved continuation owns the notice: {notice:?}"
         );
         assert!(
-            footer.contains("materialized conflict"),
-            "messages cannot replace the mode"
+            notice.contains("materialized conflict"),
+            "operation context is retained beside the persistent prompt"
+        );
+        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::Yellow);
+        assert!(
+            rendered_line(&terminal, 2).contains("view"),
+            "the ordinary footer remains visible"
         );
-        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::LightRed);
 
         app.update(Action::MoveDown);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("REBASE PAUSED"),
+            rendered_line(&terminal, 1).starts_with("REBASE PAUSED"),
             "navigation cannot dismiss the continuation"
         );
+        app.leave_error("continue failed");
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::LightRed);
+        app.update(Action::MoveDown);
         app.set_worktree_conflicted(false);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::Yellow);
-        assert!(rendered_line(&terminal, 0).starts_with("REBASE PAUSED · <enter> continue · Esc stop"));
+        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::Yellow);
+        assert!(rendered_line(&terminal, 1).starts_with("REBASE PAUSED · <enter> continue · Esc stop"));
 
         app.clear_rebase_continuation();
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(!rendered_line(&terminal, 0).contains("REBASE PAUSED"));
+        assert!(!(0..3).any(|y| rendered_line(&terminal, y).contains("REBASE PAUSED")));
         Ok(())
     }
 
@@ -2890,17 +2924,23 @@ mod tests {
         );
         app.unseen_filesystem_redraw = false;
 
-        app.leave_message("worktree removed; using common repository");
+        app.leave_attention("worktree removed; using common repository");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert_eq!(
-            rendered_line(&terminal, 1).trim(),
+            rendered_line(&terminal, 0).trim(),
             "worktree removed; using common repository",
-            "recovery information replaces the status until the next action"
+            "recovery information uses the body row above the status"
+        );
+        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::Yellow);
+        assert_eq!(
+            rendered_line(&terminal, 1).trim(),
+            footer_text,
+            "the status remains visible"
         );
 
         app.history_display_expanded = true;
         app.update(Action::ToggleMailmap);
-        assert!(app.message().is_none(), "the next action restores the normal status");
+        assert!(app.notice().is_none(), "the next action clears the notice");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains(" author subject"),
@@ -2908,13 +2948,16 @@ mod tests {
         );
         assert!(footer_is_dim(&terminal, "mailmap"), "disabled mailmap is dimmed");
 
-        app.leave_message("no commit created: no input was provided");
+        app.leave_attention("no commit created: no input was provided");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert_eq!(
-            rendered_line(&terminal, 1).trim(),
+            rendered_line(&terminal, 0).trim(),
             "no commit created: no input was provided",
             "an unchanged new-commit editor explains why nothing happened"
         );
+        app.leave_error("operation failed");
+        terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
+        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::LightRed);
         app.update(Action::ToggleMailmap);
 
         app.update(Action::ToggleDate);
@@ -4814,6 +4857,37 @@ mod tests {
         assert_eq!(buffer[(60, 6)].symbol(), "├");
         assert_eq!(buffer[(60, 7)].symbol(), "│");
         assert_eq!(buffer[(60, 8)].symbol(), "│");
+
+        app.leave_success(
+            "success success success success success success success success success success success success",
+        );
+        let mut notice_layout = None;
+        terminal.draw(|frame| {
+            notice_layout = Some(super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&tree),
+                Some(&worktree),
+            ));
+        })?;
+        let notice = Rect::new(60, 4, 60, 2);
+        assert_eq!(terminal.backend().buffer()[(60, 4)].bg, Color::Green);
+        assert_eq!(terminal.backend().buffer()[(59, 4)].bg, Color::Reset);
+        assert_eq!(
+            terminal.backend().buffer()[(60, 9)].bg,
+            Color::Reset,
+            "the footer is never covered"
+        );
+        assert!(
+            notice_layout
+                .expect("drawing returns its layout")
+                .overlays
+                .contains(&notice),
+            "animation treats the wrapped notice as reserved space"
+        );
         Ok(())
     }
 

From f37977f241e86a6bbffd53109301e75959cc6d08 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 11:05:56 +0200
Subject: [PATCH 182/282] fix: keep empty tree changes visible

Tree changes disappeared when their loaded diff had no parent, range, or paths, unlike the clean worktree block. Separate pane rendering from focusability so an available empty Tree block remains visible, reports clean, and stays out of Tab navigation.
---
 gix-tix/spec.md   |  3 ++-
 gix-tix/src/ui.rs | 38 ++++++++++++++++++++++++++++++++------
 2 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8464d3000cd..965bde1c2c5 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -436,7 +436,8 @@ space first; changes blocks adapt within the remaining history width.
 - Each block has a top border carrying its compact summary. Tree summaries show
   the selected short hash; worktree summaries distinguish staged and unstaged
   counts. Kind totals, total files when non-redundant, and non-zero line totals
-  are color-coded. An empty enabled worktree says `Worktree clean` in green.
+  are color-coded. Empty enabled Tree and Worktree blocks remain visible, say
+  `clean` in green, and are not focusable.
 - Tree paths preserve tree-diff order. Worktree paths show staged entries first in
   green and unstaged/untracked/conflicted entries second in bright red, sorted by
   raw path within each group.
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index c9c2ee8ea2e..bbb4eec2b7d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -290,8 +290,8 @@ pub(crate) fn draw_with_worktree(
     } else {
         None
     };
-    let tree_visible = app.changes_visible() && tree_changes.is_some_and(Changes::is_visible);
-    let worktree_visible =
+    let tree_shown = app.changes_visible() && tree_changes.is_some();
+    let worktree_shown =
         app.changes_visible() && app.changes_mode == Some(ChangesMode::Both) && worktree_changes.is_some();
     let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
     let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
@@ -310,13 +310,13 @@ pub(crate) fn draw_with_worktree(
     let (changes_layout, changes_panes, _) = changes_pane_areas(
         body,
         frame.area().height / 2,
-        tree_visible.then(|| {
+        tree_shown.then(|| {
             (
                 pane_height(tree_changes.expect("visible tree changes exist")),
                 tree_summary.as_ref().map_or(0, Line::width),
             )
         }),
-        worktree_visible.then(|| {
+        worktree_shown.then(|| {
             (
                 pane_height(worktree_changes.expect("visible worktree changes exist")),
                 worktree_summary.as_ref().map_or(0, Line::width),
@@ -406,7 +406,8 @@ pub(crate) fn draw_with_worktree(
             changes_layout,
             changes_panes
                 .iter()
-                .any(|pane| pane.pane == ChangePane::Tree && pane.outer.height > 0),
+                .any(|pane| pane.pane == ChangePane::Tree && pane.outer.height > 0)
+                && tree_changes.is_some_and(Changes::is_visible),
             changes_panes
                 .iter()
                 .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0)
@@ -1436,7 +1437,13 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
                 },
                 |range| format!("{}..{}", range.base.to_hex_with_len(7), range.tip.to_hex_with_len(7)),
             );
-            vec![Span::raw(format!("─ Tree {label} ── "))]
+            let mut spans = vec![Span::raw(format!("─ Tree {label} "))];
+            if changes.paths.is_empty() {
+                spans.push(Span::styled("clean", color(Color::Green)));
+                spans.push(Span::raw(" "));
+            }
+            spans.push(Span::raw("── "));
+            spans
         }
         ChangePane::Worktree if changes.paths.is_empty() => vec![
             Span::raw("─ Worktree "),
@@ -4771,6 +4778,25 @@ mod tests {
             "a clean worktree has no empty aggregate"
         );
         assert!(!app.worktree_changes_visible, "an empty block is not focusable");
+
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&Changes::default()),
+                Some(&Changes::default()),
+            );
+        })?;
+        let (clean_y, clean_tree) = (0..8)
+            .map(|y| (y, rendered_line(&terminal, y)))
+            .find(|(_, line)| line.contains("Tree ------- clean"))
+            .expect("an empty tree remains visible and says it is clean");
+        let clean_x = clean_tree.find("clean").expect("clean tree label") as u16;
+        assert_eq!(terminal.backend().buffer()[(clean_x, clean_y)].fg, Color::Green);
+        assert!(!app.tree_changes_visible, "an empty tree block is not focusable");
         Ok(())
     }
 

From 3dfea0e87be7c681453f2d3e4363b94e2282f543 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 11:18:01 +0200
Subject: [PATCH 183/282] feat: show progress while time travel signs commits

Interactive time travel previously blocked the terminal while pending commits were replayed and signed. Reuse the todo-application worker and delayed modal, with shared replay progress that aggregates commit, cherry-pick, signature, and timing counters across discovered batches.
---
 gix-tix/spec.md                 |  17 +++--
 gix-tix/src/edit/rebase.rs      |  55 ++++++++++++---
 gix-tix/src/edit/time_travel.rs | 117 ++++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs              |  45 +++++++-----
 gix-tix/src/ui.rs               |   4 +-
 5 files changed, 198 insertions(+), 40 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 965bde1c2c5..907a7164617 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -855,13 +855,16 @@ space first; changes blocks adapt within the remaining history width.
   requires only that `HEAD` names a commit and the index has no unresolved stages;
   the index tree, including additional staged changes, becomes the resolved tree.
   There is no hidden sequencer state or separate continue/abort command.
-- Interactive todo application runs on a scoped worker so the terminal can
-  remain renderable without cloning the cached history graph. If application is
-  still running after 300 ms, a modal gauge shows processed versus total todo
-  source commits and live cherry-pick and signature counts with their cumulative
-  durations. `pick`, `squash`, and `empty` commands each contribute to the total;
-  squash sources advance separately while their combined commit is signed once.
-  Fast operations and command-line `tix rebase apply` do not show progress.
+- Interactive todo application and time travel run on a scoped worker so the
+  terminal can remain renderable without cloning the cached history graph. If
+  either operation is still running after 300 ms, a modal gauge shows processed
+  versus total source commits and live cherry-pick and signature counts with
+  their cumulative durations. `pick`, `squash`, and `empty` commands each
+  contribute to a todo total; time travel counts every commit in its pending
+  replay and accumulates work when another replay batch is discovered. Squash
+  sources advance separately while their combined commit is signed once. Fast
+  operations and command-line `tix rebase apply` and `tix travel` do not show
+  progress.
 - Displayed mutable refs follow their explicit locations in the edited todo;
   omission deletes them and newly named refs require nonexistence. Refs checked
   out by linked worktrees are displayed normally and may move, with their index
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index ca2a9620757..a547d2bdb85 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -118,7 +118,7 @@ pub(crate) struct Plan {
 }
 
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-pub(crate) struct PlanProgress {
+pub(crate) struct Progress {
     pub total: usize,
     pub processed: usize,
     pub cherry_picked: usize,
@@ -127,11 +127,11 @@ pub(crate) struct PlanProgress {
     pub signing_time: Duration,
 }
 
-impl PlanProgress {
-    fn new(plan: &Plan) -> Self {
-        PlanProgress {
+impl Progress {
+    fn for_plan(plan: &Plan) -> Self {
+        Progress {
             total: plan.steps.len() + plan.steps.iter().map(|step| step.squash.len()).sum::<usize>(),
-            ..PlanProgress::default()
+            ..Progress::default()
         }
     }
 }
@@ -424,7 +424,18 @@ pub(crate) fn perform(
     signature: Signature,
     tree_mode: Tree,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None)
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, |_| {})
+}
+
+pub(crate) fn perform_with_progress(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    report: impl FnMut(Progress),
+) -> Result<Perform> {
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, report)
 }
 
 pub(super) fn perform_resetting_index_paths(
@@ -435,7 +446,7 @@ pub(super) fn perform_resetting_index_paths(
     tree_mode: Tree,
     paths: Vec<BString>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), Some(paths))
+    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), Some(paths), |_| {})
 }
 
 pub(super) fn perform_deleting_refs(
@@ -446,9 +457,13 @@ pub(super) fn perform_deleting_refs(
     tree_mode: Tree,
     deletions: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, deletions, None)
+    perform_inner(repo, graph, edit, signature, tree_mode, deletions, None, |_| {})
 }
 
+#[expect(
+    clippy::too_many_arguments,
+    reason = "shared edit preparation plus progress reporting"
+)]
 fn perform_inner(
     repo: &gix::Repository,
     graph: &HistoryGraph,
@@ -457,6 +472,7 @@ fn perform_inner(
     tree_mode: Tree,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     reset_index_paths: Option<Vec<BString>>,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     let mut repo = repo.clone();
     let repeat_checkout = match &edit {
@@ -491,6 +507,11 @@ fn perform_inner(
             .context("the edited commit is not in the loaded history")?,
         None => Vec::new(),
     };
+    let mut progress = Progress {
+        total: affected.len(),
+        ..Progress::default()
+    };
+    report(progress);
     validate(&repo, graph, &affected, removed, repeat, tree_mode)?;
 
     let signing = repo
@@ -582,6 +603,7 @@ fn perform_inner(
         } else {
             tree_mode
         };
+        let cherry_pick_started = (commit_tree_mode == Tree::CherryPick).then(Instant::now);
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
@@ -601,6 +623,10 @@ fn perform_inner(
                 ours
             }
         };
+        if let Some(started) = cherry_pick_started.filter(|_| new_conflict.is_none()) {
+            progress.cherry_picked += 1;
+            progress.cherry_pick_time += started.elapsed();
+        }
         commit.parents = new_parents.into_iter().collect();
         let pending = commit_tree_mode == Tree::LeaveAsIsAndMark
             || (commit_tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
@@ -621,7 +647,14 @@ fn perform_inner(
         } else {
             CommitState::Unmarked(signature)
         };
-        let new_id = write_commit(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
+        let (new_id, signing_time) =
+            write_commit_timed(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        progress.processed += 1;
+        report(progress);
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
@@ -840,9 +873,9 @@ pub(crate) fn perform_plan_with_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     mut plan: Plan,
-    mut report: impl FnMut(PlanProgress),
+    mut report: impl FnMut(Progress),
 ) -> Result<PlanPerform> {
-    let mut progress = PlanProgress::new(&plan);
+    let mut progress = Progress::for_plan(&plan);
     report(progress);
     let mut repo = repo.clone();
     let signing = repo
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 1b1da7929b8..960d421c541 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -295,8 +295,30 @@ where
     Ok(Some(notice))
 }
 
-#[tracing::instrument(skip_all, fields(commit_id = %selected))]
 pub(crate) fn perform(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    graph: &history::HistoryGraph,
+    review_roots: &[ObjectId],
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<Perform> {
+    perform_with_progress(
+        repository_path,
+        bare,
+        selected,
+        graph,
+        review_roots,
+        revisions,
+        include_worktrees,
+        |_| {},
+    )
+}
+
+#[tracing::instrument(skip_all, fields(commit_id = %selected))]
+#[expect(clippy::too_many_arguments, reason = "time travel context plus progress reporting")]
+pub(crate) fn perform_with_progress(
     repository_path: &Path,
     bare: bool,
     mut selected: ObjectId,
@@ -304,6 +326,7 @@ pub(crate) fn perform(
     review_roots: &[ObjectId],
     revisions: &[OsString],
     include_worktrees: bool,
+    mut report: impl FnMut(super::rebase::Progress),
 ) -> Result<Perform> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
@@ -324,9 +347,12 @@ pub(crate) fn perform(
         anyhow::bail!("cannot time-travel with unresolved index conflicts");
     }
     let mut completed_graph = None;
+    let mut completed_progress = super::rebase::Progress::default();
     let mut review_roots = review_roots.to_vec();
     while let Some(base) = pending_base(&repository, selected)? {
-        let outcome = super::rebase::perform(
+        let previous = completed_progress;
+        let mut latest = previous;
+        let outcome = super::rebase::perform_with_progress(
             &repository,
             completed_graph.as_ref().unwrap_or(graph),
             super::rebase::Edit::Repeat {
@@ -335,7 +361,12 @@ pub(crate) fn perform(
             },
             super::rebase::Signature::RedoIfNeeded,
             super::rebase::Tree::CherryPick,
+            |progress| {
+                latest = append_progress(previous, progress);
+                report(latest);
+            },
         )?;
+        completed_progress = latest;
         let outcome = match outcome {
             super::rebase::Perform::Complete(outcome) => outcome,
             super::rebase::Perform::Conflict(rebase) => {
@@ -423,6 +454,17 @@ pub(crate) fn perform(
     Ok(Perform::Complete(notice))
 }
 
+fn append_progress(previous: super::rebase::Progress, batch: super::rebase::Progress) -> super::rebase::Progress {
+    super::rebase::Progress {
+        total: previous.processed + batch.total,
+        processed: previous.processed + batch.processed,
+        cherry_picked: previous.cherry_picked + batch.cherry_picked,
+        signed: previous.signed + batch.signed,
+        cherry_pick_time: previous.cherry_pick_time + batch.cherry_pick_time,
+        signing_time: previous.signing_time + batch.signing_time,
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct ReviewTree {
     root: ObjectId,
@@ -824,6 +866,35 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn progress_accumulates_when_travel_discovers_another_replay_batch() {
+        let previous = super::super::rebase::Progress {
+            total: 2,
+            processed: 2,
+            cherry_picked: 1,
+            signed: 1,
+            cherry_pick_time: std::time::Duration::from_millis(3),
+            signing_time: std::time::Duration::from_millis(5),
+        };
+        let progress = append_progress(
+            previous,
+            super::super::rebase::Progress {
+                total: 3,
+                processed: 1,
+                cherry_picked: 1,
+                signed: 1,
+                cherry_pick_time: std::time::Duration::from_millis(7),
+                signing_time: std::time::Duration::from_millis(11),
+            },
+        );
+        assert_eq!(progress.total, 5);
+        assert_eq!(progress.processed, 3);
+        assert_eq!(progress.cherry_picked, 2);
+        assert_eq!(progress.signed, 2);
+        assert_eq!(progress.cherry_pick_time, std::time::Duration::from_millis(10));
+        assert_eq!(progress.signing_time, std::time::Duration::from_millis(16));
+    }
+
     fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
         let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
         if !output.status.success() {
@@ -1614,7 +1685,31 @@ mod tests {
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
 
-        perform(&repository_path, false, pending_middle, &graph, &[], &[], false)?.complete()?;
+        let mut middle_progress = Vec::new();
+        perform_with_progress(
+            &repository_path,
+            false,
+            pending_middle,
+            &graph,
+            &[],
+            &[],
+            false,
+            |progress| middle_progress.push(progress),
+        )?
+        .complete()?;
+        let progress = middle_progress.last().context("time-travel progress is reported")?;
+        assert_eq!(
+            progress.total, 2,
+            "the selected commit and its pending descendant are processed"
+        );
+        assert_eq!(progress.processed, 2);
+        assert_eq!(
+            progress.cherry_picked, 1,
+            "only the selected ancestry is replayed eagerly"
+        );
+        assert_eq!(progress.signed, 1, "the selected commit is signed");
+        assert!(progress.cherry_pick_time > std::time::Duration::ZERO);
+        assert!(progress.signing_time > std::time::Duration::ZERO);
 
         let repository = open()?;
         let materialized_middle = repository.head_id()?.detach();
@@ -1645,7 +1740,21 @@ mod tests {
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
 
-        perform(&repository_path, false, still_pending_tip, &graph, &[], &[], false)?.complete()?;
+        let mut tip_progress = Vec::new();
+        perform_with_progress(
+            &repository_path,
+            false,
+            still_pending_tip,
+            &graph,
+            &[],
+            &[],
+            false,
+            |progress| tip_progress.push(progress),
+        )?
+        .complete()?;
+        let progress = tip_progress.last().context("tip time-travel progress is reported")?;
+        assert_eq!((progress.total, progress.processed), (1, 1));
+        assert_eq!((progress.cherry_picked, progress.signed), (1, 1));
         let repository = open()?;
         let tip_commit = repository.find_commit(repository.head_id()?)?;
         assert!(!super::super::rebase::is_pending(&tip_commit.decode()?.into_owned()?));
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 66c9532ae00..b79f7a122a2 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2546,15 +2546,18 @@ fn event_loop(
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            edit::time_travel::perform(
-                                &repository_path,
-                                repository_is_bare,
-                                id,
-                                graph,
-                                &review_roots,
-                                &revisions,
-                                false,
-                            )
+                            run_with_rebase_progress(terminal, |report| {
+                                edit::time_travel::perform_with_progress(
+                                    &repository_path,
+                                    repository_is_bare,
+                                    id,
+                                    graph,
+                                    &review_roots,
+                                    &revisions,
+                                    false,
+                                    report,
+                                )
+                            })
                         });
                     match result {
                         Ok(edit::time_travel::Perform::Complete(Some(notice))) => {
@@ -3730,9 +3733,9 @@ fn preview_todo_rebase_conflict(
     Ok(())
 }
 
-enum RebaseWorkerEvent {
-    Progress(edit::rebase::PlanProgress),
-    Complete(Result<edit::rebase::PlanPerform>),
+enum RebaseWorkerEvent<T> {
+    Progress(edit::rebase::Progress),
+    Complete(Result<T>),
 }
 
 fn run_rebase_plan(
@@ -3741,14 +3744,24 @@ fn run_rebase_plan(
     graph: &HistoryGraph,
     plan: edit::rebase::Plan,
 ) -> Result<edit::rebase::PlanPerform> {
+    run_with_rebase_progress(terminal, move |report| {
+        let mut repository = repository.to_thread_local();
+        repository.object_cache_size(None);
+        edit::rebase::perform_plan_with_progress(&repository, graph, plan, report)
+    })
+}
+
+fn run_with_rebase_progress<T: Send>(
+    terminal: &mut ratatui::DefaultTerminal,
+    operation: impl FnOnce(&mut dyn FnMut(edit::rebase::Progress)) -> Result<T> + Send,
+) -> Result<T> {
     std::thread::scope(|scope| {
         let (sender, receiver) = mpsc::sync_channel(1);
         let worker = scope.spawn(move || {
-            let mut repository = repository.to_thread_local();
-            repository.object_cache_size(None);
-            let result = edit::rebase::perform_plan_with_progress(&repository, graph, plan, |progress| {
+            let mut report = |progress| {
                 let _ = sender.try_send(RebaseWorkerEvent::Progress(progress));
-            });
+            };
+            let result = operation(&mut report);
             let _ = sender.send(RebaseWorkerEvent::Complete(result));
         });
         let started = Instant::now();
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index bbb4eec2b7d..e369486c970 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -59,7 +59,7 @@ pub(crate) fn render_notice(frame: &mut Frame<'_>, area: Rect, notice: &Notice)
     );
 }
 
-pub(crate) fn draw_rebase_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::PlanProgress) {
+pub(crate) fn draw_rebase_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::Progress) {
     let area = frame.area();
     frame.render_widget(Clear, area);
     let width = area.width.min(72);
@@ -2198,7 +2198,7 @@ mod tests {
         terminal.draw(|frame| {
             draw_rebase_progress(
                 frame,
-                crate::edit::rebase::PlanProgress {
+                crate::edit::rebase::Progress {
                     total: 100,
                     processed: 42,
                     cherry_picked: 31,

From cc1625d8f16cab172a01ae87ef06a907ec81f1a2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 12:37:46 +0200
Subject: [PATCH 184/282] feat(gix): add exact note-reference writes

Add Platform::add_to_ref() for callers that already have a fully qualified notes reference and must avoid refs/notes shorthand expansion.
---
 gix/src/note.rs                  | 16 +++++++++++++--
 gix/tests/gix/repository/note.rs | 34 ++++++++++++++++++++++++++++++++
 2 files changed, 48 insertions(+), 2 deletions(-)

diff --git a/gix/src/note.rs b/gix/src/note.rs
index 0d4d36030c7..00c2829f629 100644
--- a/gix/src/note.rs
+++ b/gix/src/note.rs
@@ -127,7 +127,19 @@ impl Platform {
         data: impl AsRef<[u8]>,
     ) -> Result<Option<gix_hash::ObjectId>, Error> {
         let notes_ref = expand_notes_ref(notes_ref.into())?;
-        let (root, parent) = self.edit_root(notes_ref.as_ref())?;
+        self.add_to_ref(notes_ref.as_ref(), object, data)
+    }
+
+    /// Add or replace a note in the fully qualified `notes_ref`, returning the previous note id.
+    ///
+    /// Unlike [`Platform::add()`], this does not apply Git's `refs/notes/` shorthand expansion.
+    pub fn add_to_ref(
+        &mut self,
+        notes_ref: &gix_ref::FullNameRef,
+        object: impl Into<gix_hash::ObjectId>,
+        data: impl AsRef<[u8]>,
+    ) -> Result<Option<gix_hash::ObjectId>, Error> {
+        let (root, parent) = self.edit_root(notes_ref)?;
         let object = object.into();
         let note = self
             .repo
@@ -136,7 +148,7 @@ impl Platform {
             .detach();
         let edit = gix_note::add(root, object, note, &self.repo, &mut self.cache)
             .or_raise(|| message!("Could not add note for {object}"))?;
-        self.commit_edit(notes_ref, parent, edit, "Notes added by gitoxide")?;
+        self.commit_edit(notes_ref.to_owned(), parent, edit, "Notes added by gitoxide")?;
         Ok(edit.previous)
     }
 
diff --git a/gix/tests/gix/repository/note.rs b/gix/tests/gix/repository/note.rs
index 3089f7cb203..6ea2772d878 100644
--- a/gix/tests/gix/repository/note.rs
+++ b/gix/tests/gix/repository/note.rs
@@ -44,3 +44,37 @@ fn query_and_mutate_a_configured_notes_ref() -> crate::Result {
     assert!(notes.get(target).map_err(gix::Exn::into_error)?.is_empty());
     Ok(())
 }
+
+#[test]
+fn add_to_an_exact_fully_qualified_reference() -> crate::Result {
+    let (repo, _tmp) = crate::util::basic_rw_repo()?;
+    let target = repo.write_blob(b"annotated")?.detach();
+    let reference: gix::refs::FullName = "refs/worktree/tix/notes".try_into()?;
+    let mut notes = repo.notes().map_err(gix::Exn::into_error)?;
+
+    assert_eq!(
+        notes
+            .add_to_ref(reference.as_ref(), target, b"[commit]\n\ttodo = true\n")
+            .map_err(gix::Exn::into_error)?,
+        None
+    );
+    let mut exact = repo
+        .notes()
+        .map_err(gix::Exn::into_error)?
+        .with_refs([reference.as_bstr()])
+        .map_err(gix::Exn::into_error)?;
+    assert_eq!(
+        exact
+            .get(target)
+            .map_err(gix::Exn::into_error)?
+            .first()
+            .map(|note| note.blob.data.as_slice()),
+        Some(b"[commit]\n\ttodo = true\n".as_slice()),
+        "the exact worktree-local ref stores the note"
+    );
+    assert!(
+        repo.try_find_reference("refs/notes/refs/worktree/tix/notes")?.is_none(),
+        "exact writes do not apply notes shorthand"
+    );
+    Ok(())
+}

From 0a278d2252c4387578fcc9052a00f1d1b14b2664 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 22:04:06 +0200
Subject: [PATCH 185/282] feat(gix-tix): add per-worktree commit enrichments
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Store human-readable todo and note metadata in refs/worktree/tix/enrich, keyed by effective change IDs so enrichments survive rewrites while remaining private to each worktree.

Expose independent 🚧 todo and 📝 note controls under the enrich prefix. Render history titles, commit messages, enrichment notes, and Git notes as Markdown while keeping trailers structured and the commit-panel background uniform.

Pad the commit view and inset transient notices so enrichment content and application feedback remain readable without reducing the normal content width.
---
 Cargo.lock                 | 123 +++++++++++
 gix-tix/Cargo.toml         |   1 +
 gix-tix/spec.md            |  39 +++-
 gix-tix/src/app.rs         |  81 +++++++
 gix-tix/src/change_id.rs   |  16 +-
 gix-tix/src/command.rs     |  47 ++++
 gix-tix/src/edit/reword.rs |   2 +-
 gix-tix/src/enrich.rs      | 263 ++++++++++++++++++++++
 gix-tix/src/lib.rs         | 202 +++++++++++++++--
 gix-tix/src/ref_tree.rs    |   2 +-
 gix-tix/src/ui.rs          | 442 ++++++++++++++++++++++++++++++-------
 11 files changed, 1115 insertions(+), 103 deletions(-)
 create mode 100644 gix-tix/src/enrich.rs

diff --git a/Cargo.lock b/Cargo.lock
index 91215fd2ac3..0655f0e4873 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1439,6 +1439,12 @@ version = "0.3.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "037711b3d59c33004d3856fbdc83b99d4ff37a24768fa1be9ce3538a1cde4393"
 
+[[package]]
+name = "futures-timer"
+version = "3.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af43fadb8a98512d547e37b4e92e0ced13e205c061b87b4623eff01d918d6968"
+
 [[package]]
 name = "futures-util"
 version = "0.3.32"
@@ -1465,6 +1471,15 @@ dependencies = [
  "version_check",
 ]
 
+[[package]]
+name = "getopts"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
+dependencies = [
+ "unicode-width",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.17"
@@ -2607,6 +2622,7 @@ dependencies = [
  "tracing",
  "tracing-appender",
  "tracing-subscriber",
+ "tui-markdown",
 ]
 
 [[package]]
@@ -3374,6 +3390,15 @@ dependencies = [
  "either",
 ]
 
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "itoa"
 version = "1.0.18"
@@ -4185,6 +4210,15 @@ dependencies = [
  "yansi",
 ]
 
+[[package]]
+name = "proc-macro-crate"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e67ba7e9b2b56446f1d419b1d807906278ffa1a658a8a5d8a39dcb1f5a78614f"
+dependencies = [
+ "toml_edit",
+]
+
 [[package]]
 name = "proc-macro-error-attr2"
 version = "2.0.0"
@@ -4248,6 +4282,25 @@ dependencies = [
  "nix",
 ]
 
+[[package]]
+name = "pulldown-cmark"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e"
+dependencies = [
+ "bitflags 2.13.0",
+ "getopts",
+ "memchr",
+ "pulldown-cmark-escape",
+ "unicase",
+]
+
+[[package]]
+name = "pulldown-cmark-escape"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
+
 [[package]]
 name = "quinn"
 version = "0.11.11"
@@ -4512,6 +4565,12 @@ version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
 
+[[package]]
+name = "relative-path"
+version = "1.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ba39f3699c378cd8970968dcbff9c43159ea4cfbd88d43c00b22f2ef10a435d2"
+
 [[package]]
 name = "reqwest"
 version = "0.13.4"
@@ -4587,6 +4646,35 @@ dependencies = [
  "thiserror 2.0.18",
 ]
 
+[[package]]
+name = "rstest"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5a3193c063baaa2a95a33f03035c8a72b83d97a54916055ba22d35ed3839d49"
+dependencies = [
+ "futures-timer",
+ "futures-util",
+ "rstest_macros",
+]
+
+[[package]]
+name = "rstest_macros"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c845311f0ff7951c5506121a9ad75aec44d083c31583b2ea5a30bcb0b0abba0"
+dependencies = [
+ "cfg-if",
+ "glob",
+ "proc-macro-crate",
+ "proc-macro2",
+ "quote",
+ "regex",
+ "relative-path",
+ "rustc_version",
+ "syn 2.0.118",
+ "unicode-ident",
+]
+
 [[package]]
 name = "rusqlite"
 version = "0.40.1"
@@ -5463,6 +5551,18 @@ dependencies = [
  "serde_core",
 ]
 
+[[package]]
+name = "toml_edit"
+version = "0.25.13+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6975367e4d2ef766d86af01ffad14b622fecc8d4357a998fbc4deb6e9bacaf9b"
+dependencies = [
+ "indexmap",
+ "toml_datetime",
+ "toml_parser",
+ "winnow",
+]
+
 [[package]]
 name = "toml_parser"
 version = "1.1.2+spec-1.1.0"
@@ -5640,6 +5740,20 @@ dependencies = [
  "toml",
 ]
 
+[[package]]
+name = "tui-markdown"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a0c95afc7b66008823dea2614a800d944e18990690db47517efc66cd01ff9cee"
+dependencies = [
+ "itertools 0.15.0",
+ "pretty_assertions",
+ "pulldown-cmark",
+ "ratatui-core",
+ "rstest",
+ "tracing",
+]
+
 [[package]]
 name = "tui-react"
 version = "0.24.0"
@@ -5667,6 +5781,12 @@ dependencies = [
  "arrayvec",
 ]
 
+[[package]]
+name = "unicase"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
+
 [[package]]
 name = "unicode-bom"
 version = "2.0.3"
@@ -6315,6 +6435,9 @@ name = "winnow"
 version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0592e1c9d151f854e6fd382574c3a0855250e1d9b2f99d9281c6e6391af352f1"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
 name = "winreg"
diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index a5a5bd5dff2..ec3a777ff67 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -34,6 +34,7 @@ terminal-colorsaurus = "1.0.3"
 tracing = "0.1.37"
 tracing-appender = "0.2.4"
 tracing-subscriber = "0.3.17"
+tui-markdown = { version = "0.3.9", default-features = false }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 907a7164617..65dc64a01d1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -186,6 +186,24 @@ without trading responsiveness for metadata that is not visible.
   purple `[A]` before its title.
 - A commit with notes in the configured notes ref receives a matching `[N]`.
   Notes are loaded lazily for visible commits.
+- Tix enrichments are stored separately as Git notes headed at the worktree-local
+  `refs/worktree/tix/enrich` ref. Enrichments are keyed by the commit's effective
+  change ID and use human-readable Git config. Independent `[commit]` keys store
+  `todo = true` and an optional multiline `note` value.
+  Consequently, rewritten commits retain their metadata and commits sharing a
+  change ID share it as well. Malformed enrichments are ignored for display and
+  diagnosed, while mutation refuses to overwrite them.
+- Todo and note enrichments receive a leading `🚧` and `📝` respectively before
+  the graph, with no gap between them when both are present. The dedicated field
+  remains visible alongside selection, dirty-worktree, and conflict markers.
+  `tix show` emits the same field and aligns unmarked rows when any displayed
+  commit has either enrichment.
+- Only the selected history row replaces its commit title with its note title,
+  using black text on a yellow background. Unselected rows and `tix show` retain
+  the commit title.
+- Commit and selected-note titles render Markdown styling. Block-shaped title
+  output is flattened onto the single history row; plain command output retains
+  the rendered text without terminal styling.
 
 ### Selection context
 
@@ -423,9 +441,14 @@ space first; changes blocks adapt within the remaining history width.
 - Its history-status action says `message`, avoiding confusion with the edit
   group's commit-creation action.
 - The panel has a minimally shaded background derived from the detected terminal
-  background, with the default background as fallback.
-- The title begins on the first content row and is bold. Body text follows, then
-  each note with a bold purple `Notes` prefix, then aligned trailers.
+  background, with the default background as fallback. Its content has two
+  columns and one row of margin; an overflow status uses the bottom margin.
+- A note renders its bold Markdown title and body first without a separate
+  background, followed by a horizontal rule and the commit's bold Markdown title
+  and body. Standard Git notes retain their bold purple `Notes`
+  prefix and render their content as Markdown. Heading markers and code fences
+  are hidden, fenced code uses generic styling without syntax highlighting, and
+  commit trailers remain plain and aligned last.
 - Overflow is page-scrollable and gets a distinct pane status line only when
   scrolling is possible.
 
@@ -903,6 +926,12 @@ space first; changes blocks adapt within the remaining history width.
   says `no actions`.
 - While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
   meanings for dates, emails, references, and trailers.
+- The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
+  `n t` toggles `[commit] todo`, preserving a saved note, and `n o` opens
+  `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
+  the todo flag, and toggling todo preserves the note. The group is mutually
+  exclusive with the view, edit, and information groups and otherwise follows
+  their closing behavior.
 
 ## Refresh, focus, and diagnostics
 
@@ -972,8 +1001,8 @@ space first; changes blocks adapt within the remaining history width.
   errors.
 - Global command and recovery feedback uses one transient notice channel in the
   history and ref-tree views. It reserves a wrapped, content-height block above
-  worktree changes until the next recognized user action, matching that pane's
-  horizontal bounds when visible and otherwise using the main view. It never
+  worktree changes until the next recognized user action, inset by two columns
+  within that pane when visible and otherwise within the main view. It never
   covers the main or pane-local status lines. Green indicates success, yellow
   indicates attention, no-op, recovery, partial success, or an armed prompt, and
   red indicates failure. Forget, review selection and recovery, suspended
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 9eb67c8df06..c6a4c9599ca 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -323,6 +323,9 @@ pub(crate) enum Action {
     ToggleHistoryDisplay,
     ToggleRefTree,
     ToggleEdit,
+    ToggleEnrich,
+    ToggleTodo,
+    EditNote,
     ToggleInformation,
     ToggleAlign,
     ToggleCommit,
@@ -389,6 +392,8 @@ pub(crate) enum Effect {
     },
     TimeTravel(ObjectId),
     Unpin(ObjectId),
+    ToggleTodo(ObjectId),
+    EditNote(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -419,6 +424,7 @@ pub(crate) struct App {
     pending_hidden_rows: Option<HashSet<ObjectId>>,
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
+    enrichments: HashMap<ObjectId, crate::enrich::Enrichment>,
     graph: Option<Graph>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
@@ -466,6 +472,7 @@ pub(crate) struct App {
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) edit_expanded: bool,
+    pub(crate) enrich_expanded: bool,
     pub(crate) information_expanded: bool,
     forget_confirmation: Option<ObjectId>,
     pub estimated_lane_width: usize,
@@ -514,6 +521,7 @@ impl App {
             pending_hidden_rows: None,
             titles: Vec::new(),
             notes: HashMap::new(),
+            enrichments: HashMap::new(),
             graph: None,
             attributions: Vec::new(),
             #[cfg(test)]
@@ -561,6 +569,7 @@ impl App {
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             edit_expanded: false,
+            enrich_expanded: false,
             information_expanded: false,
             forget_confirmation: None,
             estimated_lane_width: 0,
@@ -896,6 +905,28 @@ impl App {
         self.notes.get(&id).map(Vec::as_slice).unwrap_or_default()
     }
 
+    pub(crate) fn enrichment_loaded(&self, id: ObjectId) -> bool {
+        self.enrichments.contains_key(&id)
+    }
+
+    pub(crate) fn set_enrichment(&mut self, id: ObjectId, enrichment: crate::enrich::Enrichment) {
+        self.enrichments.insert(id, enrichment);
+    }
+
+    pub(crate) fn todo(&self, id: ObjectId) -> bool {
+        self.enrichments.get(&id).is_some_and(|enrichment| enrichment.todo)
+    }
+
+    pub(crate) fn note(&self, id: ObjectId) -> Option<&BStr> {
+        self.enrichments
+            .get(&id)
+            .and_then(|enrichment| enrichment.note.as_ref().map(|note| note.as_bstr()))
+    }
+
+    pub(crate) fn clear_enrichments(&mut self) {
+        self.enrichments.clear();
+    }
+
     pub(crate) fn render_lanes(&self, range: Range<usize>) -> RenderedLanes {
         #[cfg(test)]
         if !self.test_lanes.is_empty() {
@@ -953,6 +984,9 @@ impl App {
         ) {
             self.edit_expanded = false;
         }
+        if !matches!(&action, Action::ToggleEnrich | Action::ToggleTodo | Action::EditNote) {
+            self.enrich_expanded = false;
+        }
         if !matches!(
             &action,
             Action::ToggleInformation
@@ -1068,6 +1102,7 @@ impl App {
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
             Action::ToggleEdit => self.edit_expanded = !self.edit_expanded,
+            Action::ToggleEnrich => self.enrich_expanded = !self.enrich_expanded,
             Action::ToggleInformation => self.information_expanded = !self.information_expanded,
             Action::CycleRefs => {
                 self.ref_mode = match self.ref_mode {
@@ -1267,6 +1302,16 @@ impl App {
                     return vec![Effect::Unpin(id)];
                 }
             }
+            Action::ToggleTodo if self.can_reword() => {
+                return vec![Effect::ToggleTodo(
+                    self.rows[self.selected.expect("todo requires a selection")].id,
+                )];
+            }
+            Action::EditNote if self.can_reword() => {
+                return vec![Effect::EditNote(
+                    self.rows[self.selected.expect("note requires a selection")].id,
+                )];
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -1592,6 +1637,7 @@ impl App {
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
+        self.enrichments.clear();
         self.graph = None;
         self.attributions = Vec::new();
         #[cfg(test)]
@@ -3797,6 +3843,41 @@ mod tests {
         assert!(!app.edit_expanded, "the prefix key toggles the group");
     }
 
+    #[test]
+    fn enrich_group_updates_only_mutable_commits() {
+        let mut app = App::new(1);
+        app.extend_commits(vec![row(1)]);
+        complete(&mut app);
+
+        app.update(Action::ToggleEnrich);
+        assert!(app.enrich_expanded);
+        assert_eq!(
+            app.update(Action::ToggleTodo),
+            vec![Effect::ToggleTodo(id(1))],
+            "todo reuses reword eligibility"
+        );
+        assert_eq!(
+            app.update(Action::EditNote),
+            vec![Effect::EditNote(id(1))],
+            "note uses the same eligibility"
+        );
+        assert!(app.enrich_expanded, "the grouped actions keep enrich open");
+
+        app.update(Action::MoveDown);
+        assert!(!app.enrich_expanded, "navigation closes enrich");
+        app.update(Action::ToggleEnrich);
+        app.update(Action::ToggleEdit);
+        assert!(!app.enrich_expanded, "opening edit closes enrich");
+
+        app.hidden_rows.insert(id(1));
+        app.update(Action::ToggleEnrich);
+        assert!(
+            app.update(Action::ToggleTodo).is_empty(),
+            "hidden boundaries are immutable"
+        );
+        assert!(app.update(Action::EditNote).is_empty());
+    }
+
     #[test]
     fn information_group_keeps_direct_actions_and_excludes_other_prefixes() {
         let mut app = App::new(1);
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index 2c941ca5311..5776d2dc521 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -18,14 +18,16 @@ pub(crate) fn effective<'a>(commit_id: ObjectId, mut values: impl Iterator<Item
         .unwrap_or_else(|| commit_id.into())
 }
 
-pub(crate) fn inherit(repo: &gix::Repository, commit: &mut gix::objs::Commit, predecessor: ObjectId) -> Result<()> {
+pub(crate) fn for_commit(repo: &gix::Repository, id: ObjectId) -> Result<ChangeId> {
     let object = repo
-        .find_commit(predecessor)
-        .context("could not read predecessor while preserving its change ID")?;
-    let decoded = object
-        .decode()
-        .context("could not decode predecessor while preserving its change ID")?;
-    let change_id = effective(predecessor, decoded.extra_headers().find_all(HEADER));
+        .find_commit(id)
+        .context("could not read commit for its change ID")?;
+    let commit = object.decode().context("could not decode commit for its change ID")?;
+    Ok(effective(id, commit.extra_headers().find_all(HEADER)))
+}
+
+pub(crate) fn inherit(repo: &gix::Repository, commit: &mut gix::objs::Commit, predecessor: ObjectId) -> Result<()> {
+    let change_id = for_commit(repo, predecessor).context("could not preserve predecessor change ID")?;
     store(commit, change_id);
     Ok(())
 }
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 03996abc49b..f119408fe17 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -3,6 +3,7 @@ use std::{collections::HashSet, ffi::OsString, io::Write, sync::atomic::AtomicBo
 use anyhow::{Context, Result};
 use clap::Parser;
 use gix::prelude::{ObjectIdExt, ReferenceExt};
+use ratatui::text::Line;
 
 mod rebase;
 mod reword;
@@ -261,10 +262,50 @@ fn write_history(
         }
     }
 
+    let mut todo_ids = HashSet::new();
+    let mut enrichment_note_ids = HashSet::new();
+    let mut enrichments = crate::enrich::open(repository)?;
+    for row in &app.rows {
+        let loaded = crate::change_id::for_commit(repository, row.id)
+            .and_then(|change_id| crate::enrich::load(&mut enrichments, change_id));
+        match loaded {
+            Ok(enrichment) => {
+                if enrichment.todo {
+                    todo_ids.insert(row.id);
+                }
+                if enrichment.note.is_some() {
+                    enrichment_note_ids.insert(row.id);
+                }
+            }
+            Err(err) => tracing::warn!(commit_id = %row.id, error = %err, "ignored malformed tix enrichment"),
+        }
+    }
+
     let mailmap = repository.open_mailmap();
     let lanes = app.render_lanes(0..app.rows.len());
+    let enrichment_gutter = app
+        .rows
+        .iter()
+        .map(|row| {
+            Line::raw(crate::enrich::marker(
+                todo_ids.contains(&row.id),
+                enrichment_note_ids.contains(&row.id),
+            ))
+            .width()
+        })
+        .max()
+        .unwrap_or_default();
     for (index, row) in app.rows.iter().enumerate() {
         let metadata = crate::ui::plain_history_metadata(&app, row, &decorations, &mailmap, note_ids.contains(&row.id));
+        if enrichment_gutter != 0 {
+            let marker = crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
+            write!(
+                out,
+                "{marker}{}",
+                " ".repeat(enrichment_gutter.saturating_sub(Line::raw(marker).width()))
+            )
+            .context("could not write enrichment marker")?;
+        }
         write!(out, "{}{}", lanes.lane(index), metadata).context("could not write history row")?;
         if let Some(behind) = app.hidden_branch_behind(row.id) {
             write!(out, " ⇣{behind}").context("could not write hidden-branch status")?;
@@ -717,6 +758,8 @@ mod tests {
         .expect_err("disabling auto-hide requires an explicit hidden revision");
         assert!(format!("{err:#}").contains("at least one -h/--hide"));
         create_pins(&repository, &[OsString::from("topic")])?;
+        let head = repository.head_id()?.detach();
+        assert!(crate::enrich::toggle(&repository, head)?.todo);
 
         let mut output = Vec::new();
         write_history(&repository, &[], &[OsString::from("v1")], &mut output)?;
@@ -724,6 +767,10 @@ mod tests {
 
         assert_eq!(output.lines().count(), 5, "the complete projected history is printed");
         assert!(output.contains('●'), "history graph lanes are rendered");
+        assert!(
+            output.lines().any(|line| line.starts_with("🚧 ")),
+            "todos lead their rows"
+        );
         assert!(output.contains("📌"), "applicable pins are decorated and traversed");
         assert!(
             output.contains("topic"),
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 288f4ced27c..ddf7bb945eb 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -247,7 +247,7 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
     })
 }
 
-fn cleanup_message(input: &[u8], comment_char: Option<&[u8]>) -> BString {
+pub(crate) fn cleanup_message(input: &[u8], comment_char: Option<&[u8]>) -> BString {
     let mut out = Vec::new();
     let mut empty_lines = 0;
     for line in input.lines_with_terminator() {
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
new file mode 100644
index 00000000000..397aa0c91fe
--- /dev/null
+++ b/gix-tix/src/enrich.rs
@@ -0,0 +1,263 @@
+use anyhow::{Context, Result};
+use gix::{
+    ObjectId,
+    bstr::{BString, ByteSlice},
+    config::File,
+    hash::ChangeId,
+    refs::FullName,
+};
+
+pub(crate) const REF_NAME: &str = "refs/worktree/tix/enrich";
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(crate) struct Enrichment {
+    pub todo: bool,
+    pub note: Option<BString>,
+}
+
+pub(crate) fn marker(todo: bool, note: bool) -> &'static str {
+    match (todo, note) {
+        (true, true) => "🚧📝 ",
+        (true, false) => "🚧 ",
+        (false, true) => "📝 ",
+        (false, false) => "",
+    }
+}
+
+pub(crate) fn open(repo: &gix::Repository) -> Result<gix::note::Platform> {
+    repo.notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open tix enrichments")?
+        .with_refs([REF_NAME])
+        .map_err(gix::Exn::into_error)
+        .context("could not select the tix enrich reference")
+}
+
+pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Enrichment> {
+    let config = load_config(notes, change_id)?;
+    let Some(config) = config else {
+        return Ok(Enrichment::default());
+    };
+    Ok(Enrichment {
+        todo: config
+            .boolean("commit.todo")
+            .context("commit.todo is not a boolean")?
+            .unwrap_or(false),
+        note: config.string("commit.note").filter(|note| !note.is_empty()),
+    })
+}
+
+fn load_config(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Option<File>> {
+    let found = notes
+        .get(ObjectId::from(change_id))
+        .map_err(gix::Exn::into_error)
+        .context("could not load the tix enrichment")?;
+    found
+        .first()
+        .map(|note| {
+            File::try_from(note.blob.data.as_bstr()).context("could not parse the tix enrichment as Git config")
+        })
+        .transpose()
+}
+
+pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enrichment> {
+    update(repo, commit_id, |config| {
+        let enabled = !config
+            .boolean("commit.todo")
+            .context("commit.todo is not a boolean")?
+            .unwrap_or(false);
+        config
+            .section_mut_or_create_new("commit", None)
+            .context("could not create the commit enrichment section")?
+            .set("todo", if enabled { "true" } else { "false" })
+            .context("could not update commit.todo")?;
+        Ok(())
+    })
+}
+
+pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option<&[u8]>) -> Result<Enrichment> {
+    update(repo, commit_id, |config| {
+        let mut section = config
+            .section_mut_or_create_new("commit", None)
+            .context("could not create the commit enrichment section")?;
+        match note {
+            Some(note) => {
+                section.set("note", note).context("could not update commit.note")?;
+            }
+            None => {
+                section.remove("note");
+            }
+        }
+        Ok(())
+    })
+}
+
+fn update(
+    repo: &gix::Repository,
+    commit_id: ObjectId,
+    edit: impl FnOnce(&mut File) -> Result<()>,
+) -> Result<Enrichment> {
+    let change_id = crate::change_id::for_commit(repo, commit_id)?;
+    let mut notes = open(repo)?;
+    let mut config = load_config(&mut notes, change_id)?.unwrap_or_default();
+    edit(&mut config)?;
+    let reference: FullName = REF_NAME.try_into().expect("the tix enrich reference is valid");
+    notes
+        .add_to_ref(reference.as_ref(), ObjectId::from(change_id), config.to_bstring())
+        .map_err(gix::Exn::into_error)
+        .context("could not write the tix enrichment")?;
+    load(&mut notes, change_id)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::process::Command;
+
+    use super::*;
+
+    #[test]
+    fn toggling_preserves_other_fields() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let id = repo.head_id()?.detach();
+        let change_id = crate::change_id::for_commit(&repo, id)?;
+        let reference: FullName = REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(
+                reference.as_ref(),
+                ObjectId::from(change_id),
+                b"[commit]\n\ttodo = true\n\towner = me\n",
+            )
+            .map_err(gix::Exn::into_error)?;
+
+        assert!(!toggle(&repo, id)?.todo);
+        let mut notes = open(&repo)?;
+        let note = notes
+            .get(ObjectId::from(change_id))
+            .map_err(gix::Exn::into_error)?
+            .into_iter()
+            .next()
+            .expect("the toggled note exists");
+        let config = File::try_from(note.blob.data.as_bstr())?;
+        assert_eq!(config.boolean("commit.todo")?, Some(false));
+        assert_eq!(
+            config.string("commit.owner").as_ref().map(|value| value.as_bstr()),
+            Some(b"me".as_bstr())
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn todo_follows_a_rewrite_by_change_id() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let original = repo.head_id()?.detach();
+        assert!(toggle(&repo, original)?.todo);
+
+        let mut commit = repo.find_commit(original)?.decode()?.into_owned()?;
+        commit.message = "rewritten".into();
+        crate::change_id::inherit(&repo, &mut commit, original)?;
+        let rewritten = repo.write_object(&commit)?.detach();
+        let change_id = crate::change_id::for_commit(&repo, rewritten)?;
+        assert!(
+            load(&mut open(&repo)?, change_id)?.todo,
+            "the rewritten commit shares the todo"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn notes_and_todos_are_independent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let id = repo.head_id()?.detach();
+        let message = b"Follow up\n\nExplain *why*.\n";
+
+        let enrichment = set_note(&repo, id, Some(message))?;
+        assert!(!enrichment.todo, "saving a note leaves todo disabled");
+        assert_eq!(
+            enrichment.note.as_ref().map(|note| note.as_bstr()),
+            Some(message.as_bstr())
+        );
+
+        let enrichment = toggle(&repo, id)?;
+        assert!(enrichment.todo, "the ordinary todo action enables todo");
+        assert_eq!(
+            enrichment.note.as_ref().map(|note| note.as_bstr()),
+            Some(message.as_bstr()),
+            "toggling todo preserves its note"
+        );
+
+        let enrichment = set_note(&repo, id, None)?;
+        assert!(enrichment.todo, "emptying the editor preserves todo");
+        assert!(enrichment.note.is_none(), "emptying the editor deletes the note");
+        Ok(())
+    }
+
+    #[test]
+    fn malformed_enrichments_are_not_overwritten() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let id = repo.head_id()?.detach();
+        let change_id = crate::change_id::for_commit(&repo, id)?;
+        let reference: FullName = REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(reference.as_ref(), ObjectId::from(change_id), b"[commit")
+            .map_err(gix::Exn::into_error)?;
+
+        assert!(
+            load(&mut open(&repo)?, change_id).is_err(),
+            "display can diagnose malformed enrichments"
+        );
+        assert!(
+            toggle(&repo, id).is_err(),
+            "mutation does not replace malformed enrichments"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn enrichments_are_private_to_each_worktree() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let linked_path = fixture.path().join("linked");
+        let status = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["worktree", "add", "-q", "--detach"])
+            .arg(&linked_path)
+            .arg("HEAD")
+            .status()?;
+        assert!(status.success(), "git creates the linked worktree");
+        let config = ["user.name=todo author", "user.email=todo@example.com"];
+        let main = crate::test_repository::open_with(fixture.path(), config)?;
+        let linked = crate::test_repository::open_with(&linked_path, config)?;
+        let id = main.head_id()?.detach();
+        let change_id = crate::change_id::for_commit(&main, id)?;
+
+        assert!(toggle(&main, id)?.todo);
+        assert!(
+            !load(&mut open(&linked)?, change_id)?.todo,
+            "main enrichments do not leak to linked worktrees"
+        );
+        assert!(toggle(&linked, id)?.todo);
+        assert!(!toggle(&main, id)?.todo);
+        assert!(
+            load(&mut open(&linked)?, change_id)?.todo,
+            "linked enrichments survive main-worktree changes"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index b79f7a122a2..9a403a42594 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -7,6 +7,7 @@ mod app;
 mod change_id;
 pub mod command;
 mod edit;
+mod enrich;
 mod history;
 mod logging;
 mod ref_tree;
@@ -1138,6 +1139,7 @@ fn event_loop(
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
+            app.clear_enrichments();
             if std::mem::take(&mut ref_watch_set_changed) {
                 match start_ref_watcher(&repository_path, &common_dir) {
                     Ok(watcher) => {
@@ -1704,7 +1706,12 @@ fn event_loop(
         let key_pressed = is_key_press(&terminal_event);
         let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
-                let action = action_with_shortcut_groups(key, app.history_display_expanded, app.edit_expanded);
+                let action = action_with_shortcut_groups(
+                    key,
+                    app.history_display_expanded,
+                    app.edit_expanded,
+                    app.enrich_expanded,
+                );
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
@@ -2598,6 +2605,40 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("unpin: {err:#}")),
                     }
                 }
+                Effect::ToggleTodo(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = open_repository(&repository_path, repository_is_bare, false)
+                        .context("could not open repository to update the enrichment")
+                        .and_then(|repo| enrich::toggle(&repo, id));
+                    match result {
+                        Ok(enrichment) => {
+                            let enabled = enrichment.todo;
+                            app.clear_enrichments();
+                            app.set_enrichment(id, enrichment);
+                            app.leave_success(if enabled {
+                                "marked commit todo"
+                            } else {
+                                "cleared commit todo"
+                            });
+                        }
+                        Err(err) => app.leave_error(format!("todo: {err:#}")),
+                    }
+                }
+                Effect::EditNote(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit_note(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
+                        Ok(Some(enrichment)) => {
+                            let has_note = enrichment.note.is_some();
+                            app.clear_enrichments();
+                            app.set_enrichment(id, enrichment);
+                            app.leave_success(if has_note { "saved note" } else { "cleared note" });
+                        }
+                        Ok(None) => {}
+                        Err(err) => app.leave_error(format!("note: {err:#}")),
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -2967,6 +3008,11 @@ fn draw(
         .map(|row| row.id)
         .filter(|id| repository_fill_allowed && !app.notes_loaded(*id))
         .collect();
+    let enrichments_to_load: Vec<_> = app.rows[start..end]
+        .iter()
+        .map(|row| row.id)
+        .filter(|id| repository_fill_allowed && !app.enrichment_loaded(*id))
+        .collect();
     let changes_visible = app.changes_visible();
     let selected_id = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
     app.selection_relation = selection_cache
@@ -3040,6 +3086,7 @@ fn draw(
         app.selection_relation = relation;
     }
     if !notes_to_load.is_empty()
+        || !enrichments_to_load.is_empty()
         || app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
         || tree_changes_to_load.is_some()
@@ -3073,6 +3120,20 @@ fn draw(
                 app.set_notes(id, loaded);
             }
         }
+        if !enrichments_to_load.is_empty() {
+            let mut notes = enrich::open(repository)?;
+            for id in enrichments_to_load {
+                let loaded = crate::change_id::for_commit(repository, id)
+                    .and_then(|change_id| enrich::load(&mut notes, change_id));
+                match loaded {
+                    Ok(enrichment) => app.set_enrichment(id, enrichment),
+                    Err(err) => {
+                        tracing::warn!(commit_id = %id, error = %err, "ignored malformed tix enrichment");
+                        app.set_enrichment(id, enrich::Enrichment::default());
+                    }
+                }
+            }
+        }
         for index in start..end {
             if app.rows[index].metadata_loaded {
                 continue;
@@ -3600,6 +3661,41 @@ fn show_commit_diff(
     Ok(false)
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
+fn edit_note(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    id: gix::ObjectId,
+    enhanced_keyboard: bool,
+) -> Result<Option<enrich::Enrichment>> {
+    let (editor, enrichment, document) = {
+        let repository =
+            open_repository(repository_path, bare, false).context("could not open repository before editing note")?;
+        let change_id = change_id::for_commit(&repository, id)?;
+        let enrichment = enrich::load(&mut enrich::open(&repository)?, change_id)?;
+        let document = enrichment.note.clone().unwrap_or_default();
+        let editor = repository.editor().context("no Git editor is available")?;
+        (editor, enrichment, document)
+    };
+    let edited = edit::edit_document(
+        terminal,
+        &editor,
+        &document,
+        &format!("tix-note-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?;
+    let cleaned = edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
+    let desired_note = (!cleaned.is_empty()).then_some(cleaned.as_bstr());
+    if enrichment.note.as_ref().map(|note| note.as_bstr()) == desired_note {
+        return Ok(None);
+    }
+
+    let repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing note")?;
+    enrich::set_note(&repository, id, desired_note.map(AsRef::as_ref)).map(Some)
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn reword_commit(
     terminal: &mut ratatui::DefaultTerminal,
@@ -4639,7 +4735,7 @@ fn poll_timeout(
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
-    action_with_shortcut_groups(key, false, false)
+    action_with_shortcut_groups(key, false, false, false)
 }
 
 fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_focused: bool) -> bool {
@@ -4682,7 +4778,12 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
     ) || (changes_focused && matches!(action, Some(Action::OpenDiff | Action::Cancel | Action::Quit)))
 }
 
-fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, edit_expanded: bool) -> Option<Action> {
+fn action_with_shortcut_groups(
+    key: KeyEvent,
+    history_display_expanded: bool,
+    edit_expanded: bool,
+    enrich_expanded: bool,
+) -> Option<Action> {
     if key.kind == KeyEventKind::Release {
         return None;
     }
@@ -4734,6 +4835,8 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
         KeyCode::Char('i') if edit_expanded => Some(Action::Unpin),
         KeyCode::Char('v') if edit_expanded => Some(Action::Review),
+        KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
+        KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
         KeyCode::Char('@') => Some(Action::TimeTravel),
         KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::TimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
@@ -4742,6 +4845,7 @@ fn action_with_shortcut_groups(key: KeyEvent, history_display_expanded: bool, ed
         KeyCode::Char('t') => Some(Action::ToggleRefTree),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
         KeyCode::Char('e') => Some(Action::ToggleEdit),
+        KeyCode::Char('n') => Some(Action::ToggleEnrich),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
         KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
@@ -5726,7 +5830,37 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
             Some(Action::ToggleEdit)
         );
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
+            Some(Action::ToggleEnrich)
+        );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
+                false,
+                false,
+                true
+            ),
+            Some(Action::ToggleTodo)
+        );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE),
+                false,
+                false,
+                true
+            ),
+            Some(Action::EditNote)
+        );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
+                false,
+                false,
+                true
+            ),
+            Some(Action::ToggleEnrich)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('m'), KeyModifiers::NONE)),
             Some(Action::ToggleCommit)
@@ -5796,13 +5930,23 @@ mod tests {
             ('h', Action::ToggleHidden),
         ] {
             assert_eq!(
-                action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), true, false),
+                action_with_shortcut_groups(
+                    KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
+                    true,
+                    false,
+                    false
+                ),
                 Some(expected),
                 "{key} is available after the view prefix"
             );
         }
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE), true, false),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE),
+                true,
+                false,
+                false
+            ),
             Some(Action::ToggleHistoryDisplay),
             "v closes the view shortcut group"
         );
@@ -5821,28 +5965,53 @@ mod tests {
             ('i', Action::Unpin),
         ] {
             assert_eq!(
-                action_with_shortcut_groups(KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE), false, true),
+                action_with_shortcut_groups(
+                    KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
+                    false,
+                    true,
+                    false
+                ),
                 Some(expected),
                 "{key} is available after the edit prefix"
             );
         }
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE), false, true),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
+                false,
+                true,
+                false
+            ),
             Some(Action::ToggleRefTree),
             "the direct ref-tree key remains available while edit is expanded"
         );
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE), false, true),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE),
+                false,
+                true,
+                false
+            ),
             Some(Action::TimeTravel),
             "the direct time-travel key remains available while edit is expanded"
         );
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL), false, true,),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL),
+                false,
+                true,
+                false
+            ),
             Some(Action::PageUp),
             "navigation keeps priority over the edit shortcut"
         );
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE), false, true),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
+                false,
+                true,
+                false
+            ),
             Some(Action::ToggleEdit),
             "e closes the edit shortcut group"
         );
@@ -5860,7 +6029,12 @@ mod tests {
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE)), None);
         assert_eq!(
-            action_with_shortcut_groups(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE), false, true),
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE),
+                false,
+                true,
+                false
+            ),
             Some(Action::ToggleRefs),
             "the old edit shortcut retains its direct reference-toggle behavior"
         );
@@ -5887,12 +6061,12 @@ mod tests {
     fn tree_is_direct_while_trailers_remain_scoped_to_the_view_prefix() {
         let key = KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE);
         assert_eq!(
-            action_with_shortcut_groups(key, true, false),
+            action_with_shortcut_groups(key, true, false, false),
             Some(Action::ToggleTrailers),
             "v t retains its trailer action"
         );
         assert_eq!(
-            action_with_shortcut_groups(key, false, false),
+            action_with_shortcut_groups(key, false, false, false),
             Some(Action::ToggleRefTree),
             "plain t toggles the ref-tree"
         );
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index d13644f9533..8efcd2b67f2 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -2450,7 +2450,7 @@ mod tests {
         );
         tree.leave_error("remote deletion failed");
         terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
-        assert_eq!(terminal.backend().buffer()[(0, 16)].bg, Color::LightRed);
+        assert_eq!(terminal.backend().buffer()[(2, 16)].bg, Color::LightRed);
         assert!(
             terminal
                 .backend()
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index e369486c970..69045cad0aa 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -22,10 +22,34 @@ const FILESYSTEM_NOTIFICATION_COLOR: Color = Color::Rgb(255, 165, 0);
 const NOTE_COLOR: Color = Color::LightMagenta;
 const PANE_STATUS_BACKGROUND: Color = Color::DarkGray;
 
+#[derive(Clone)]
+struct MarkdownStyle;
+
+impl tui_markdown::StyleSheet for MarkdownStyle {
+    fn heading_marker(&self, _level: u8) -> &'static str {
+        ""
+    }
+
+    fn code_block_fence(&self) -> &'static str {
+        ""
+    }
+}
+
+fn note_style() -> Style {
+    Style::default()
+        .fg(Color::Black)
+        .bg(Color::Yellow)
+        .remove_modifier(Modifier::REVERSED)
+}
+
 pub(crate) fn notice_area(notice: &Notice, horizontal: Rect, top: u16, bottom: u16) -> Option<Rect> {
     if horizontal.width == 0 || top >= bottom {
         return None;
     }
+    let horizontal = horizontal.inner(Margin {
+        horizontal: 2.min(horizontal.width.saturating_sub(1) / 2),
+        vertical: 0,
+    });
     let height = u16::try_from(
         Paragraph::new(notice.text.as_str())
             .wrap(Wrap { trim: false })
@@ -299,11 +323,10 @@ pub(crate) fn draw_with_worktree(
         let width = COMMIT_PANE_WIDTH.min(full_body.width / 2);
         let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
         body.width = body.width.min(commits.width);
-        let mut content = message.inner(Margin {
+        let content = message.inner(Margin {
             horizontal: 2,
-            vertical: 0,
+            vertical: 1,
         });
-        content.height = content.height.saturating_sub(1);
         (message, content)
     });
     let pane_height = |changes: &Changes| u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(2);
@@ -431,10 +454,16 @@ pub(crate) fn draw_with_worktree(
             && matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying)
     });
     let lanes = app.render_lanes(start..render_end);
+    let enrichment_gutter = visible_rows
+        .iter()
+        .map(|row| Line::raw(crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some())).width())
+        .max()
+        .unwrap_or_default() as u16;
+    let status_x = body.x.saturating_add(enrichment_gutter);
     let content = Rect::new(
-        body.x.saturating_add(2),
+        status_x.saturating_add(2),
         body.y,
-        body.width.saturating_sub(2),
+        body.width.saturating_sub(enrichment_gutter.saturating_add(2)),
         body.height,
     );
     let rendered_lane_width = lanes
@@ -466,9 +495,14 @@ pub(crate) fn draw_with_worktree(
         .iter()
         .enumerate()
         .map(|(index, row)| {
+            let row_selected = selected == Some(start + index);
+            let title = row_selected.then(|| app.note(row.id)).flatten().map_or_else(
+                || app.title(row),
+                |note| gix::objs::commit::MessageRef::from_bytes(note).title,
+            );
             metadata_line(
                 row,
-                app.title(row),
+                title,
                 app.attributions(row),
                 decorations,
                 mailmap,
@@ -481,15 +515,11 @@ pub(crate) fn draw_with_worktree(
                     show_emails: app.show_emails,
                     show_trailers,
                     has_notes: !app.notes(row.id).is_empty(),
+                    note: row_selected && app.note(row.id).is_some(),
                     use_mailmap: app.use_mailmap && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
-                    selected: (selected == Some(start + index) && app.show_selection_tail)
-                        || compared_parent == Some(row.id),
-                    copy_feedback: if selected == Some(start + index) {
-                        copy_feedback
-                    } else {
-                        None
-                    },
+                    selected: (row_selected && app.show_selection_tail) || compared_parent == Some(row.id),
+                    copy_feedback: if row_selected { copy_feedback } else { None },
                 },
             )
         })
@@ -577,6 +607,16 @@ pub(crate) fn draw_with_worktree(
             color(highlight).add_modifier(Modifier::REVERSED)
         });
         let conflict = app.conflict_marker(visible_rows[index].id, head);
+        let enrichment_marker = crate::enrich::marker(
+            app.todo(visible_rows[index].id),
+            app.note(visible_rows[index].id).is_some(),
+        );
+        if !enrichment_marker.is_empty() {
+            frame.render_widget(
+                Paragraph::new(enrichment_marker),
+                Rect::new(body.x, y, enrichment_gutter, 1),
+            );
+        }
         frame.render_widget(
             Paragraph::new(if conflict {
                 "C "
@@ -594,7 +634,7 @@ pub(crate) fn draw_with_worktree(
             } else {
                 Style::default()
             }),
-            Rect::new(body.x, y, body.width.min(2), 1),
+            Rect::new(status_x, y, body.right().saturating_sub(status_x).min(2), 1),
         );
 
         let row_area = Rect::new(content.x, y, content.width, 1);
@@ -793,12 +833,10 @@ pub(crate) fn draw_with_worktree(
                 .set_style(outer, Style::default().bg(Color::Rgb(red, green, blue)));
         }
         let max_offset = if let Some(message) = commit_message {
-            let notes = app
-                .selected
-                .and_then(|index| app.rows.get(index))
-                .map(|row| app.notes(row.id))
-                .unwrap_or_default();
-            render_commit_message(frame, area, message, notes, app.commit_offset)
+            let selected = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
+            let notes = selected.map(|id| app.notes(id)).unwrap_or_default();
+            let note = selected.and_then(|id| app.note(id));
+            render_commit_message(frame, area, message, note, notes, app.commit_offset)
         } else {
             0
         };
@@ -1004,6 +1042,26 @@ pub(crate) fn draw_with_worktree(
     let mut ordered = vec![Span::raw(history_position(app))];
     ordered.append(&mut view_prefix_spans);
     ordered.append(&mut edit_prefix_spans);
+    ordered.push(Span::raw(" · "));
+    let enrich_prefix_start = ordered.len();
+    ordered.extend(shortcut("enrich", 'n', true));
+    if app.enrich_expanded {
+        ordered.push(Span::raw(" ("));
+        if app.can_reword() {
+            let (todo, note) = app
+                .selected
+                .and_then(|index| app.rows.get(index))
+                .map(|row| (app.todo(row.id), app.note(row.id).is_some()))
+                .unwrap_or_default();
+            ordered.extend(shortcut("todo", 't', todo));
+            ordered.push(Span::raw(" · "));
+            ordered.extend(shortcut("note", 'o', note));
+        } else {
+            ordered.push(Span::raw("no actions"));
+        }
+        ordered.push(Span::raw(")"));
+        emphasize_prefix(&mut ordered[enrich_prefix_start..]);
+    }
     if let Some(label) = time_travel {
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut(label, '@', true));
@@ -1530,7 +1588,14 @@ fn append_change_aggregate(
     }
 }
 
-fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, notes: &[BString], offset: usize) -> usize {
+fn render_commit_message(
+    frame: &mut Frame<'_>,
+    area: Rect,
+    message: &BStr,
+    note: Option<&BStr>,
+    notes: &[BString],
+    offset: usize,
+) -> usize {
     let parsed = gix::objs::commit::MessageRef::from_bytes(message);
     let mut body_message = BString::default();
     let mut trailers = Vec::new();
@@ -1546,7 +1611,7 @@ fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, note
         return render_scrolling_paragraph(
             frame,
             area,
-            Paragraph::new(commit_text(parsed.title, parsed.body, notes)).wrap(Wrap { trim: false }),
+            Paragraph::new(commit_text(note, parsed.title, parsed.body, notes, area.width)).wrap(Wrap { trim: false }),
             offset,
         );
     }
@@ -1560,11 +1625,12 @@ fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, note
             return render_scrolling_paragraph(
                 frame,
                 area,
-                Paragraph::new(commit_text(parsed.title, parsed.body, notes)).wrap(Wrap { trim: false }),
+                Paragraph::new(commit_text(note, parsed.title, parsed.body, notes, area.width))
+                    .wrap(Wrap { trim: false }),
                 offset,
             );
         }
-        let mut text = commit_text(parsed.title, body_message, notes);
+        let mut text = commit_text(note, parsed.title, body_message, notes, area.width);
         text.lines.push(Line::default());
         for trailer in trailers {
             text.lines.extend(
@@ -1580,7 +1646,7 @@ fn render_commit_message(frame: &mut Frame<'_>, area: Rect, message: &BStr, note
     }
     let key_width = key_width as u16;
 
-    let text = commit_text(parsed.title, body_message, notes);
+    let text = commit_text(note, parsed.title, body_message, notes, area.width);
     let paragraph = Paragraph::new(text).wrap(Wrap { trim: false });
     let body_height = paragraph.line_count(area.width);
     let value_x = area.x.saturating_add(key_width).saturating_add(2);
@@ -1651,14 +1717,23 @@ fn render_scrolling_paragraph(frame: &mut Frame<'_>, area: Rect, paragraph: Para
     max_offset
 }
 
-fn commit_text<'a>(title: &'a BStr, body: Option<&'a BStr>, notes: &'a [BString]) -> Text<'a> {
-    let mut text = Text::raw(title.to_str_lossy());
-    for line in &mut text.lines {
-        line.style = Style::default().add_modifier(Modifier::BOLD);
-    }
-    if let Some(body) = body.filter(|body| !body.is_empty()) {
-        text.lines.push(Line::default());
-        text.lines.extend(Text::raw(body.to_str_lossy()).lines);
+fn commit_text<'a>(
+    note: Option<&'a BStr>,
+    title: &'a BStr,
+    body: Option<&'a BStr>,
+    notes: &'a [BString],
+    width: u16,
+) -> Text<'a> {
+    let mut text = message_text(title, body);
+    if let Some(note) = note {
+        let parsed = gix::objs::commit::MessageRef::from_bytes(note);
+        let mut prefixed = message_text(parsed.title, parsed.body);
+        prefixed.lines.push(Line::styled(
+            "─".repeat(width as usize),
+            Style::default().add_modifier(Modifier::DIM),
+        ));
+        prefixed.lines.append(&mut text.lines);
+        text = prefixed;
     }
     for note in notes {
         text.lines.push(Line::default());
@@ -1666,15 +1741,61 @@ fn commit_text<'a>(title: &'a BStr, body: Option<&'a BStr>, notes: &'a [BString]
             Span::styled("Notes", color(NOTE_COLOR).add_modifier(Modifier::BOLD)),
             Span::styled(":", color(NOTE_COLOR)),
         ]));
-        let mut note = Text::raw(note.to_str_lossy());
-        for line in &mut note.lines {
-            line.style = color(NOTE_COLOR);
-        }
-        text.lines.extend(note.lines);
+        text.lines.extend(markdown_text(note.as_bstr()).lines);
+    }
+    text
+}
+
+fn message_text(title: &BStr, body: Option<&BStr>) -> Text<'static> {
+    let mut text = markdown_text(title);
+    for line in &mut text.lines {
+        line.style = line.style.add_modifier(Modifier::BOLD);
+    }
+    if let Some(body) = body.filter(|body| !body.is_empty()) {
+        text.lines.push(Line::default());
+        text.lines.extend(markdown_text(body).lines);
     }
     text
 }
 
+fn markdown_text(input: &BStr) -> Text<'static> {
+    let input = input.to_str_lossy();
+    let rendered = tui_markdown::from_str_with_options(&input, &tui_markdown::Options::new(MarkdownStyle));
+    Text {
+        alignment: rendered.alignment,
+        style: rendered.style,
+        lines: rendered
+            .lines
+            .into_iter()
+            .map(|line| Line {
+                style: line.style,
+                alignment: line.alignment,
+                spans: line
+                    .spans
+                    .into_iter()
+                    .map(|span| Span::styled(span.content.into_owned(), span.style))
+                    .collect(),
+            })
+            .collect(),
+    }
+}
+
+fn markdown_title_spans(title: &BStr) -> Vec<Span<'static>> {
+    let text = markdown_text(title);
+    let text_style = text.style;
+    let mut out = Vec::new();
+    for line in text.lines.into_iter().filter(|line| !line.spans.is_empty()) {
+        if !out.is_empty() {
+            out.push(Span::raw(" "));
+        }
+        out.extend(line.spans.into_iter().map(|mut span| {
+            span.style = text_style.patch(line.style).patch(span.style);
+            span
+        }));
+    }
+    out
+}
+
 fn toggle(label: &'static str, enabled: bool) -> Span<'static> {
     Span::styled(
         label,
@@ -1733,6 +1854,7 @@ struct MetadataOptions {
     show_emails: bool,
     show_trailers: bool,
     has_notes: bool,
+    note: bool,
     use_mailmap: bool,
     ref_mode: RefMode,
     selected: bool,
@@ -1757,6 +1879,7 @@ fn metadata_line<'a>(
         show_emails,
         show_trailers,
         has_notes,
+        note,
         use_mailmap,
         ref_mode,
         selected,
@@ -1969,7 +2092,13 @@ fn metadata_line<'a>(
         spans.push(Span::styled("[N] ", color(NOTE_COLOR)));
     }
     if !show_emails {
-        spans.push(Span::raw(title.to_str_lossy()));
+        let mut title = markdown_title_spans(title);
+        if note {
+            for span in &mut title {
+                span.style = span.style.patch(note_style());
+            }
+        }
+        spans.extend(title);
     }
     Line::from(spans)
 }
@@ -1996,6 +2125,7 @@ pub(crate) fn plain_history_metadata(
             show_emails: app.show_emails,
             show_trailers: app.name_mode == NameMode::All && app.show_trailers,
             has_notes,
+            note: false,
             use_mailmap: app.use_mailmap,
             ref_mode: app.ref_mode,
             selected: false,
@@ -2026,6 +2156,7 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
             show_emails: app.show_emails,
             show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
             has_notes: !app.notes(row.id).is_empty(),
+            note: false,
             use_mailmap: app.use_mailmap,
             ref_mode: app.ref_mode,
             selected: false,
@@ -2043,7 +2174,11 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
         if !out.is_empty() {
             out.push(' ');
         }
-        out.push_str(&title.to_str_lossy());
+        let rendered = markdown_title_spans(title)
+            .into_iter()
+            .map(|span| span.content.into_owned())
+            .collect::<String>();
+        out.push_str(&rendered);
     }
     out
 }
@@ -2254,6 +2389,85 @@ mod tests {
         assert_eq!(history_position(&app), "#1");
     }
 
+    #[test]
+    fn enrichments_have_a_gutter_beside_selection_and_the_graph() -> Result<(), Box<dyn std::error::Error>> {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        complete(&mut app);
+        app.set_enrichment(
+            id,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("follow-up *title*\n\nwhy it matters\n".into()),
+            },
+        );
+        let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let row = terminal.backend().buffer();
+        assert_eq!(row[(0, 0)].symbol(), "🚧", "todo leads the row");
+        assert_eq!(row[(2, 0)].symbol(), "📝", "note directly follows todo");
+        assert_eq!(row[(5, 0)].symbol(), ">", "selection retains its own field");
+        assert_eq!(row[(7, 0)].symbol(), "●", "the graph remains separate");
+        assert!(
+            rendered_line(&terminal, 0).contains("follow-up title"),
+            "the selected todo displays its note title"
+        );
+        let title_x = (0..80)
+            .find(|x| row[(*x, 0)].symbol() == "f")
+            .expect("the note title is visible");
+        assert_eq!(row[(title_x, 0)].fg, Color::Black);
+        assert_eq!(row[(title_x, 0)].bg, Color::Yellow);
+        assert!(
+            (0..80).any(|x| row[(x, 0)].symbol() == "t" && row[(x, 0)].modifier.contains(Modifier::ITALIC)),
+            "the Markdown title is italicized"
+        );
+        app.enrich_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 1).contains("enrich (todo · note)"),
+            "the enrich group advertises both actions"
+        );
+        app.enrich_expanded = false;
+
+        app.selected = None;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 0).contains("subject"),
+            "unselected rows retain their commit title"
+        );
+        app.selected = Some(0);
+        app.set_enrichment(
+            id,
+            crate::enrich::Enrichment {
+                todo: false,
+                note: Some("follow-up *title*\n\nwhy it matters\n".into()),
+            },
+        );
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 0).contains("follow-up title"),
+            "a note replaces the selected title independently of todo"
+        );
+        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "📝");
+        assert_eq!(terminal.backend().buffer()[(3, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(5, 0)].symbol(), "●");
+        Ok(())
+    }
+
     #[test]
     fn keeps_the_completed_footer_while_background_progress_is_deferred() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
@@ -2288,7 +2502,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · view · edit · copy") && computing.contains("computing"),
+            computing.contains("1 commits · view · edit · enrich · copy") && computing.contains("computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -2317,14 +2531,16 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let notice = rendered_line(&terminal, 1);
         assert!(
-            notice.starts_with("REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"),
+            notice
+                .trim_start()
+                .starts_with("REBASE PAUSED · resolve conflicts, then <enter> continue · Esc stop"),
             "an unresolved continuation owns the notice: {notice:?}"
         );
         assert!(
             notice.contains("materialized conflict"),
             "operation context is retained beside the persistent prompt"
         );
-        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::Yellow);
+        assert_eq!(terminal.backend().buffer()[(2, 1)].bg, Color::Yellow);
         assert!(
             rendered_line(&terminal, 2).contains("view"),
             "the ordinary footer remains visible"
@@ -2333,17 +2549,21 @@ mod tests {
         app.update(Action::MoveDown);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("REBASE PAUSED"),
+            rendered_line(&terminal, 1).trim_start().starts_with("REBASE PAUSED"),
             "navigation cannot dismiss the continuation"
         );
         app.leave_error("continue failed");
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::LightRed);
+        assert_eq!(terminal.backend().buffer()[(2, 1)].bg, Color::LightRed);
         app.update(Action::MoveDown);
         app.set_worktree_conflicted(false);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(terminal.backend().buffer()[(0, 1)].bg, Color::Yellow);
-        assert!(rendered_line(&terminal, 1).starts_with("REBASE PAUSED · <enter> continue · Esc stop"));
+        assert_eq!(terminal.backend().buffer()[(2, 1)].bg, Color::Yellow);
+        assert!(
+            rendered_line(&terminal, 1)
+                .trim_start()
+                .starts_with("REBASE PAUSED · <enter> continue · Esc stop")
+        );
 
         app.clear_rebase_continuation();
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
@@ -2841,7 +3061,7 @@ mod tests {
             "todo commit metadata uses the author date and excludes separately represented refs"
         );
 
-        let footer_text = "#1 · view · edit · copy · refs · ? · quit";
+        let footer_text = "#1 · view · edit · enrich · copy · refs · ? · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -2868,6 +3088,7 @@ mod tests {
         for (label, key) in [
             ("view", 'v'),
             ("edit", 'e'),
+            ("enrich", 'n'),
             ("copy", 'y'),
             ("refs", 'r'),
             ("quit", 'q'),
@@ -2938,7 +3159,7 @@ mod tests {
             "worktree removed; using common repository",
             "recovery information uses the body row above the status"
         );
-        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::Yellow);
+        assert_eq!(terminal.backend().buffer()[(2, 0)].bg, Color::Yellow);
         assert_eq!(
             rendered_line(&terminal, 1).trim(),
             footer_text,
@@ -2964,7 +3185,7 @@ mod tests {
         );
         app.leave_error("operation failed");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::LightRed);
+        assert_eq!(terminal.backend().buffer()[(2, 0)].bg, Color::LightRed);
         app.update(Action::ToggleMailmap);
 
         app.update(Action::ToggleDate);
@@ -3138,7 +3359,7 @@ mod tests {
         );
         assert!(
             rendered_line(&terminal, 1)
-                .contains("edit (reword · new · new-empty · fork · d forget · unpin) · @ return · copy"),
+                .contains("edit (reword · new · new-empty · fork · d forget · unpin) · enrich · @ return · copy"),
             "time travel stays outside the active edit prefix"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
@@ -3181,7 +3402,7 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "view (author date · ids · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · copy · refs · ?")),
+            footer.starts_with(&format!("0 commits · {view} · enrich · copy · refs · ?")),
             "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
@@ -3199,18 +3420,27 @@ mod tests {
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · copy · refs · ?"),
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · enrich · copy · refs · ?"),
             "the edit prefix follows the view prefix even when no action is available"
         );
         assert_reversed_group(&terminal, 1, "edit (no actions)");
 
         app.edit_expanded = false;
+        app.enrich_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 1).starts_with("0 commits · view · edit · enrich (no actions) · copy · refs · ?"),
+            "the enrich prefix follows the edit prefix"
+        );
+        assert_reversed_group(&terminal, 1, "enrich (no actions)");
+
+        app.enrich_expanded = false;
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let footer = rendered_line(&terminal, 1);
         assert!(
             footer.starts_with(
-                    "0 commits · view · edit · copy · refs · ? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                    "0 commits · view · edit · enrich · copy · refs · ? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
@@ -3929,9 +4159,9 @@ mod tests {
             );
         })?;
         assert_eq!(
-            terminal.backend().buffer()[(62, 0)].symbol(),
+            terminal.backend().buffer()[(62, 1)].symbol(),
             "s",
-            "the title starts on the first pane row after two columns of horizontal margin"
+            "the title starts after horizontal and vertical margins"
         );
         assert_eq!(
             terminal.backend().buffer()[(60, 0)].symbol(),
@@ -3944,7 +4174,7 @@ mod tests {
             "the commit pane has the derived terminal-background shade"
         );
         assert_eq!(
-            terminal.backend().buffer()[(62, 0)].bg,
+            terminal.backend().buffer()[(62, 1)].bg,
             Color::Rgb(15, 16, 17),
             "the shade extends behind the commit message"
         );
@@ -3954,7 +4184,7 @@ mod tests {
             "the history background is unchanged"
         );
         assert_eq!(
-            terminal.backend().buffer()[(62, 2)].symbol(),
+            terminal.backend().buffer()[(62, 3)].symbol(),
             "b",
             "the commit body remains separated from its title"
         );
@@ -3990,18 +4220,18 @@ mod tests {
             );
         })?;
         assert_eq!(
-            wide_terminal.backend().buffer()[(118, 0)].symbol(),
+            wide_terminal.backend().buffer()[(118, 1)].symbol(),
             "x",
             "the pane reserves eighty content columns on a wide screen"
         );
         assert!(
-            rendered_line(&wide_terminal, 0)
+            rendered_line(&wide_terminal, 1)
                 .chars()
                 .skip(118)
                 .take(80)
                 .collect::<String>()
                 .ends_with(" word")
-                && rendered_line(&wide_terminal, 1)
+                && rendered_line(&wide_terminal, 2)
                     .chars()
                     .skip(118)
                     .take(80)
@@ -4899,9 +5129,13 @@ mod tests {
                 Some(&worktree),
             ));
         })?;
-        let notice = Rect::new(60, 4, 60, 2);
-        assert_eq!(terminal.backend().buffer()[(60, 4)].bg, Color::Green);
-        assert_eq!(terminal.backend().buffer()[(59, 4)].bg, Color::Reset);
+        let notice = Rect::new(62, 4, 56, 2);
+        assert_eq!(terminal.backend().buffer()[(62, 4)].bg, Color::Green);
+        assert_eq!(
+            terminal.backend().buffer()[(60, 4)].bg,
+            Color::Reset,
+            "the notice has horizontal margin within the worktree pane"
+        );
         assert_eq!(
             terminal.backend().buffer()[(60, 9)].bg,
             Color::Reset,
@@ -4923,7 +5157,7 @@ mod tests {
         let message = b"subject\n\nbody\n\nShort: one two three four five six seven\nCo-authored-by: Alice".as_bstr();
 
         terminal.draw(|frame| {
-            render_commit_message(frame, frame.area(), message, &[], 0);
+            render_commit_message(frame, frame.area(), message, None, &[], 0);
         })?;
 
         assert_eq!(
@@ -4965,7 +5199,14 @@ mod tests {
 
         let mut plain_terminal = Terminal::new(TestBackend::new(40, 4))?;
         plain_terminal.draw(|frame| {
-            render_commit_message(frame, frame.area(), b"plain subject\n\nplain body".as_bstr(), &[], 0);
+            render_commit_message(
+                frame,
+                frame.area(),
+                b"plain subject\n\nplain body".as_bstr(),
+                None,
+                &[],
+                0,
+            );
         })?;
         assert!(
             plain_terminal.backend().buffer()[(0, 0)]
@@ -4983,30 +5224,77 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(60, 8))?;
         let message = b"subject\n\nnot a trailer\nSigned-off-by: Alice\nanother note\nSigned-off-by: Bob".as_bstr();
         terminal.draw(|frame| {
-            render_commit_message(frame, frame.area(), message, &[], 0);
+            render_commit_message(frame, frame.area(), message, None, &[], 0);
         })?;
         assert!(
-            rendered_line(&terminal, 2).contains("not a trailer")
-                && rendered_line(&terminal, 3).contains("another note"),
-            "mixed message parts are combined ahead of the trailers"
+            rendered_line(&terminal, 2).contains("not a trailer another note"),
+            "Markdown soft breaks combine message lines ahead of the trailers"
         );
         assert!(
-            rendered_line(&terminal, 4).trim().is_empty(),
+            rendered_line(&terminal, 3).trim().is_empty(),
             "the combined message remains separated from its trailers"
         );
         assert_eq!(
-            rendered_line(&terminal, 5).find("Alice"),
+            rendered_line(&terminal, 4).find("Alice"),
             Some(15),
             "the first trailer moves below all message parts"
         );
         assert_eq!(
-            rendered_line(&terminal, 6).find("Bob"),
+            rendered_line(&terminal, 5).find("Bob"),
             Some(15),
             "later trailer runs share the aligned value column"
         );
         Ok(())
     }
 
+    #[test]
+    fn note_precedes_the_commit_message_and_its_trailers() -> Result<(), Box<dyn std::error::Error>> {
+        let mut terminal = Terminal::new(TestBackend::new(40, 10))?;
+        terminal.draw(|frame| {
+            render_commit_message(
+                frame,
+                frame.area(),
+                b"commit *subject*\n\ncommit ~~body~~\n\nSigned-off-by: Alice".as_bstr(),
+                Some(b"todo *subject*\n\ntodo **body**".as_bstr()),
+                &[],
+                0,
+            );
+        })?;
+
+        assert_eq!(rendered_line(&terminal, 0).trim(), "todo subject");
+        assert_eq!(rendered_line(&terminal, 2).trim(), "todo body");
+        assert_eq!(terminal.backend().buffer()[(0, 0)].bg, Color::Reset);
+        assert_eq!(terminal.backend().buffer()[(0, 2)].bg, Color::Reset);
+        assert!(terminal.backend().buffer()[(5, 0)].modifier.contains(Modifier::ITALIC));
+        assert!(terminal.backend().buffer()[(5, 2)].modifier.contains(Modifier::BOLD));
+        assert!(
+            rendered_line(&terminal, 3).chars().all(|char| char == '─'),
+            "a horizontal rule separates note from the commit"
+        );
+        assert_eq!(rendered_line(&terminal, 4).trim(), "commit subject");
+        assert_eq!(rendered_line(&terminal, 6).trim(), "commit body");
+        assert!(terminal.backend().buffer()[(7, 4)].modifier.contains(Modifier::ITALIC));
+        assert!(
+            terminal.backend().buffer()[(7, 6)]
+                .modifier
+                .contains(Modifier::CROSSED_OUT)
+        );
+        assert!(
+            rendered_line(&terminal, 8).contains("Alice"),
+            "commit trailers retain their layout"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn markdown_hides_structural_delimiters() {
+        let text = markdown_text(b"# Heading\n\n```rust\nlet value = 1;\n```".as_bstr());
+        let rendered = text.to_string();
+        assert!(rendered.contains("Heading") && rendered.contains("let value = 1;"));
+        assert!(!rendered.contains('#') && !rendered.contains("```"));
+        assert!(text.lines[0].style.add_modifier.contains(Modifier::BOLD));
+    }
+
     #[test]
     fn renders_note_markers_and_notes_before_trailers() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
@@ -5024,7 +5312,7 @@ mod tests {
             is_review: false,
             signature: SignatureState::Unsigned,
         }]);
-        app.set_notes(id, vec!["review note".into()]);
+        app.set_notes(id, vec!["review *note*".into()]);
         app.selected = None;
         let mut history = Terminal::new(TestBackend::new(100, 2))?;
         history.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
@@ -5044,12 +5332,14 @@ mod tests {
                 frame,
                 frame.area(),
                 b"subject\n\nbody\n\nSigned-off-by: Alice".as_bstr(),
-                &["review note".into()],
+                None,
+                &["review *note*".into()],
                 0,
             );
         })?;
         assert_eq!(rendered_line(&message, 4).trim(), "Notes:");
         assert_eq!(rendered_line(&message, 5).trim(), "review note");
+        assert!(message.backend().buffer()[(7, 5)].modifier.contains(Modifier::ITALIC));
         assert!(rendered_line(&message, 7).contains("Alice"), "trailers follow notes");
         let notes_label = &message.backend().buffer()[(0, 4)];
         assert_eq!(notes_label.fg, NOTE_COLOR);
@@ -5324,6 +5614,7 @@ mod tests {
                 show_emails: false,
                 show_trailers: true,
                 has_notes: false,
+                note: false,
                 use_mailmap: false,
                 ref_mode: RefMode::All,
                 selected: false,
@@ -5423,6 +5714,7 @@ mod tests {
                 show_emails: false,
                 show_trailers: false,
                 has_notes: false,
+                note: false,
                 use_mailmap: false,
                 ref_mode: RefMode::None,
                 selected: false,

From ce69bfeaa54fa05e2a3271e341ca330a5d7dc690 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 15:27:38 +0200
Subject: [PATCH 186/282] change(gix-tix)!: restore standard help flags

Tix previously reserved -h for --hide and manually restored only long help on selected parsers. Leaf commands such as reword consequently treated --help as their required revision instead of displaying usage.

Let Clap provide -h/--help for every standalone command, and move the repeatable hide option to -x/--hide consistently. Remove the custom help fields and cover every command path with parser tests.
---
 gix-tix/spec.md               | 12 +++---
 gix-tix/src/command.rs        | 72 +++++++++++++++++------------------
 gix-tix/src/command/rebase.rs | 16 ++------
 3 files changed, 46 insertions(+), 54 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 65dc64a01d1..a9bcfcbf0e1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -13,7 +13,7 @@ without trading responsiveness for metadata that is not visible.
 
 - `tix [REVISION]...` shows commits reachable from the supplied revisions, or
   from `HEAD` when none are supplied.
-- `tix show [-h HIDDEN...] [--no-auto-hide] [TIP...]` prints the complete
+- `tix show [-x HIDDEN...] [--no-auto-hide] [TIP...]` prints the complete
   history view without opening a terminal UI. Tips default to `HEAD`, and
   applicable pins participate exactly as they do in the history view. Output
   uses the history view's graph lanes and default metadata, without colors,
@@ -41,11 +41,12 @@ without trading responsiveness for metadata that is not visible.
   every such covering pin participates so retained forks are rewritten together.
   Eligibility is checked before the editor opens, and an unchanged document is
   an explicit no-op.
-- `-h/--hide REVSPEC` excludes the revision and its reachable ancestry. The
+- `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
+- `-h/--help` prints Clap's standard help for `tix` and every subcommand.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
-- `tix rebase todo [-h HIDDEN...] [--no-auto-hide] [--onto REV] [TIP...]`
+- `tix rebase todo [-x HIDDEN...] [--no-auto-hide] [--onto REV] [TIP...]`
   writes a self-contained Markdown history-rebase plan to stdout. Visible tips
   default to `HEAD`, and an ambiguous derived fork point is an error.
   `--edit-and-apply` opens the same plan with Git's configured editor and applies
@@ -288,8 +289,9 @@ without trading responsiveness for metadata that is not visible.
   It traverses
   all normal references by default; positional revisions scope traversal.
 - Worktree traversal is always enabled. `--no-tags` and repeatable
-  `--hide <revision>` match the corresponding ref-tree inputs. Output uses ASCII lines and `o` nodes by default;
-  `--unicode` uses the interactive ref-tree's rounded line and node glyphs.
+  `-x/--hide <revision>` match the corresponding ref-tree inputs. Output uses
+  ASCII lines and `o` nodes by default; `--unicode` uses the interactive
+  ref-tree's rounded line and node glyphs.
 
 ## Interaction
 
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index f119408fe17..bd015f70bda 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -13,14 +13,11 @@ mod travel;
 #[derive(Debug, clap::Args)]
 #[command(args_conflicts_with_subcommands = true)]
 pub struct Platform {
-    /// Print help.
-    #[arg(long, action = clap::ArgAction::HelpLong)]
-    help: Option<bool>,
     /// Exit once all commits and graph lanes have been computed.
     #[arg(long)]
     quit_on_finish: bool,
     /// Hide this revision and every commit reachable from it.
-    #[arg(short = 'h', long, value_name = "REVSPEC")]
+    #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
     #[command(subcommand)]
     command: Option<Command>,
@@ -33,7 +30,6 @@ enum Command {
     /// Print the complete ref-tree without opening the terminal UI.
     RefTree(RefTree),
     /// Print the complete history view without opening the terminal UI.
-    #[command(disable_help_flag = true)]
     Show(Show),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend(Amend),
@@ -54,14 +50,11 @@ enum Command {
 
 #[derive(Debug, clap::Args)]
 struct RefTree {
-    /// Print help.
-    #[arg(long, action = clap::ArgAction::HelpLong)]
-    help: Option<bool>,
     /// Omit tags as labels, traversal tips, and topology anchors.
     #[arg(long)]
     no_tags: bool,
     /// Hide this revision and every commit reachable from it.
-    #[arg(long, value_name = "REVSPEC")]
+    #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
     /// Use the ref-tree view's Unicode line and node glyphs instead of ASCII.
     #[arg(long)]
@@ -73,11 +66,8 @@ struct RefTree {
 
 #[derive(Debug, clap::Args)]
 struct Show {
-    /// Print help.
-    #[arg(long, action = clap::ArgAction::HelpLong)]
-    help: Option<bool>,
     /// Hide this revision and every commit reachable from it.
-    #[arg(short = 'h', long, value_name = "REVSPEC")]
+    #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
     /// Do not infer hidden local branches from remote HEADs.
     #[arg(long)]
@@ -105,7 +95,6 @@ struct Pin {
 #[command(
     name = "tix",
     about = "Browse or edit commit history",
-    disable_help_flag = true,
     after_long_help = "Commands which open an editor use Git's normal editor selection. Set GIT_EDITOR=<command> to override it."
 )]
 struct Cli {
@@ -122,7 +111,6 @@ impl Platform {
     /// Run this command against `repository`.
     pub fn run(self, repository: gix::ThreadSafeRepository) -> Result<()> {
         let Platform {
-            help: _,
             quit_on_finish,
             hide,
             command,
@@ -185,7 +173,7 @@ fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
 fn show(repository: &gix::Repository, args: Show) -> Result<()> {
     let (hide, unavailable) = crate::history::available_hidden_revisions(repository, &args.hide, !args.no_auto_hide)?;
     if hide.is_empty() {
-        anyhow::bail!("show requires at least one -h/--hide revision when no remote HEAD maps to a local branch");
+        anyhow::bail!("show requires at least one -x/--hide revision when no remote HEAD maps to a local branch");
     }
     for (revision, err) in unavailable {
         eprintln!(
@@ -419,7 +407,7 @@ mod tests {
 
     #[test]
     fn parses_tui_options_and_top_level_commands() {
-        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-h", "main", "--hide", "tag", "topic"])
+        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-x", "main", "--hide", "tag", "topic"])
             .expect("TUI arguments parse");
         assert!(cli.platform.quit_on_finish);
         assert_eq!(cli.platform.hide, ["main", "tag"], "hide options append");
@@ -434,7 +422,7 @@ mod tests {
             "tix",
             "ref-tree",
             "--no-tags",
-            "--hide",
+            "-x",
             "private",
             "--unicode",
             "main",
@@ -446,20 +434,18 @@ mod tests {
         let Some(Command::RefTree(ref_tree)) = ref_tree else {
             panic!("ref-tree was expected")
         };
-        assert!(ref_tree.help.is_none());
         assert!(ref_tree.no_tags);
         assert_eq!(ref_tree.hide, ["private"]);
         assert!(ref_tree.unicode);
         assert_eq!(ref_tree.revisions, ["main", "topic"]);
 
-        let show = Cli::try_parse_from(["tix", "show", "-h", "main", "--hide", "tag", "topic"])
+        let show = Cli::try_parse_from(["tix", "show", "-x", "main", "--hide", "tag", "topic"])
             .expect("show options parse")
             .platform
             .command;
         let Some(Command::Show(show)) = show else {
             panic!("show was expected")
         };
-        assert!(show.help.is_none());
         assert_eq!(show.hide, ["main", "tag"]);
         assert!(!show.no_auto_hide);
         assert_eq!(show.revisions, ["topic"]);
@@ -583,7 +569,7 @@ mod tests {
                 "rebase",
                 "todo",
                 "--no-auto-hide",
-                "-h",
+                "-x",
                 "main",
                 "--onto",
                 "next",
@@ -634,24 +620,37 @@ mod tests {
 
     #[test]
     fn preserves_hide_and_help_semantics() {
+        for command in [
+            &[][..],
+            &["ref-tree"],
+            &["show"],
+            &["amend"],
+            &["spill"],
+            &["split"],
+            &["pin"],
+            &["travel"],
+            &["reword"],
+            &["rebase"],
+            &["rebase", "todo"],
+            &["rebase", "apply"],
+        ] {
+            for help in ["-h", "--help"] {
+                let arguments = std::iter::once("tix").chain(command.iter().copied()).chain([help]);
+                assert_eq!(
+                    Cli::try_parse_from(arguments)
+                        .expect_err("help exits through clap")
+                        .kind(),
+                    ErrorKind::DisplayHelp,
+                    "{command:?} supports {help}"
+                );
+            }
+        }
         assert_eq!(
-            Cli::try_parse_from(["tix", "--help"])
-                .expect_err("long help exits through clap")
-                .kind(),
-            ErrorKind::DisplayHelp
-        );
-        assert_eq!(
-            Cli::try_parse_from(["tix", "-h"])
+            Cli::try_parse_from(["tix", "-x"])
                 .expect_err("hide requires a value")
                 .kind(),
             ErrorKind::InvalidValue
         );
-        assert_eq!(
-            Cli::try_parse_from(["tix", "show", "--help"])
-                .expect_err("show has long help")
-                .kind(),
-            ErrorKind::DisplayHelp
-        );
         assert_eq!(
             Cli::try_parse_from(["tix", "amend", "topic"])
                 .expect_err("commands reject TUI arguments")
@@ -749,14 +748,13 @@ mod tests {
         let err = show(
             &repository,
             Show {
-                help: None,
                 hide: Vec::new(),
                 no_auto_hide: true,
                 revisions: Vec::new(),
             },
         )
         .expect_err("disabling auto-hide requires an explicit hidden revision");
-        assert!(format!("{err:#}").contains("at least one -h/--hide"));
+        assert!(format!("{err:#}").contains("at least one -x/--hide"));
         create_pins(&repository, &[OsString::from("topic")])?;
         let head = repository.head_id()?.detach();
         assert!(crate::enrich::toggle(&repository, head)?.todo);
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 6961b4e7eae..df66003dd47 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -18,7 +18,6 @@ use crate::{
 #[derive(Debug, clap::Subcommand)]
 pub(super) enum Command {
     /// Produce a self-contained rebase todo, or edit and apply it immediately.
-    #[command(disable_help_flag = true)]
     Todo(Todo),
     /// Apply a self-contained rebase todo from FILE or standard input.
     #[command(
@@ -29,14 +28,11 @@ pub(super) enum Command {
 
 #[derive(Debug, clap::Args)]
 #[command(
-    after_long_help = "Without --edit-and-apply, the todo is written to stdout. With it, Git's normal editor selection is used; GIT_EDITOR=<command> overrides it.\n\nExamples:\n  tix rebase todo -h main topic >todo.md\n  ${GIT_EDITOR:-editor} todo.md\n  tix rebase apply todo.md\n  tix rebase todo --edit-and-apply -h main topic"
+    after_long_help = "Without --edit-and-apply, the todo is written to stdout. With it, Git's normal editor selection is used; GIT_EDITOR=<command> overrides it.\n\nExamples:\n  tix rebase todo -x main topic >todo.md\n  ${GIT_EDITOR:-editor} todo.md\n  tix rebase apply todo.md\n  tix rebase todo --edit-and-apply -x main topic"
 )]
 pub(super) struct Todo {
-    /// Print help.
-    #[arg(long, action = clap::ArgAction::HelpLong)]
-    help: Option<bool>,
     /// Hide this revision and derive the editable fork point from it.
-    #[arg(short = 'h', long, value_name = "REVSPEC")]
+    #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
     /// Do not infer hidden local branches from remote HEADs.
     #[arg(long)]
@@ -92,7 +88,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
     let (hide, unavailable) = history::available_hidden_revisions(repo, &args.hide, !args.no_auto_hide)?;
     if hide.is_empty() {
         anyhow::bail!(
-            "rebase todo requires at least one -h/--hide revision when no remote HEAD maps to a local branch"
+            "rebase todo requires at least one -x/--hide revision when no remote HEAD maps to a local branch"
         );
     }
     for (revision, err) in unavailable {
@@ -333,7 +329,6 @@ mod tests {
         let prepared = prepare(
             &repo,
             &Todo {
-                help: None,
                 hide: vec!["HEAD~2".into()],
                 no_auto_hide: false,
                 onto: None,
@@ -361,7 +356,6 @@ mod tests {
         let err = prepare(
             &repo,
             &Todo {
-                help: None,
                 hide: Vec::new(),
                 no_auto_hide: true,
                 onto: None,
@@ -370,7 +364,7 @@ mod tests {
             },
         )
         .expect_err("a hidden revision is required");
-        assert!(format!("{err:#}").contains("at least one -h/--hide"));
+        assert!(format!("{err:#}").contains("at least one -x/--hide"));
         Ok(())
     }
 
@@ -398,7 +392,6 @@ mod tests {
         let prepared = prepare(
             &repo,
             &Todo {
-                help: None,
                 hide: Vec::new(),
                 no_auto_hide: false,
                 onto: None,
@@ -519,7 +512,6 @@ mod tests {
         let prepared = prepare(
             &repo,
             &Todo {
-                help: None,
                 hide: vec!["HEAD~2".into()],
                 no_auto_hide: false,
                 onto: None,

From 2f3a885b7ff814110bd9b59f37123201c25e6ec8 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 22:02:51 +0200
Subject: [PATCH 187/282] Adapt plumbing to standard tix help flags

Let the embedded tix parser provide -h/--help and adapt its plumbing coverage to the new -x/--hide spelling.
---
 src/plumbing/main.rs        | 18 ++++++++++--------
 src/plumbing/options/mod.rs |  7 +------
 2 files changed, 11 insertions(+), 14 deletions(-)

diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index 5b83fb7e4cf..91052bd2706 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -1852,7 +1852,7 @@ mod tests {
         }
 
         for arguments in [
-            vec!["gix", "tix", "-h", "main", "--hide", "tag", "-w", "topic"],
+            vec!["gix", "tix", "-x", "main", "--hide", "tag", "topic"],
             vec!["gix", "tix", "amend"],
             vec!["gix", "tix", "spill"],
         ] {
@@ -1871,12 +1871,14 @@ mod tests {
             clap::error::ErrorKind::UnknownArgument,
             "alternate-screen operation has no command-line mode"
         );
-        assert_eq!(
-            Args::try_parse_from(["gix", "tix", "--help"])
-                .expect_err("help exits through clap")
-                .kind(),
-            clap::error::ErrorKind::DisplayHelp,
-            "long help remains available while -h belongs to hide"
-        );
+        for help in ["-h", "--help"] {
+            assert_eq!(
+                Args::try_parse_from(["gix", "tix", help])
+                    .expect_err("help exits through clap")
+                    .kind(),
+                clap::error::ErrorKind::DisplayHelp,
+                "embedded tix supports {help}"
+            );
+        }
     }
 }
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
index d860b2cd1d0..6c82f91fde0 100644
--- a/src/plumbing/options/mod.rs
+++ b/src/plumbing/options/mod.rs
@@ -165,12 +165,7 @@ pub enum Subcommands {
     Log(log::Platform),
     /// Interactively browse commits and their graph.
     #[cfg(feature = "tix")]
-    #[clap(
-        visible_alias = "tui",
-        visible_alias = "interactive",
-        visible_alias = "i",
-        disable_help_flag = true
-    )]
+    #[clap(visible_alias = "tui", visible_alias = "interactive", visible_alias = "i")]
     Tix(gix_tix::command::Platform),
     Worktree(worktree::Platform),
     /// Subcommands that need no Git repository to run.

From 213d33169de41fc4610b030dd7cb4c0649d3b8cc Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 15:35:26 +0200
Subject: [PATCH 188/282] fix: remove the tix enrichment gutter margin

Enrichment markers included a trailing space in their shared text representation, separating them from the selection status in the TUI and from graph lanes in plain history output.

Remove that embedded margin while retaining fixed-width gutter alignment for rows without markers, and assert direct adjacency for combined, note-only, and plain-output cases.
---
 gix-tix/spec.md        | 4 ++--
 gix-tix/src/command.rs | 4 ++--
 gix-tix/src/enrich.rs  | 6 +++---
 gix-tix/src/ui.rs      | 8 ++++----
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a9bcfcbf0e1..e0034b2bc01 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -195,8 +195,8 @@ without trading responsiveness for metadata that is not visible.
   change ID share it as well. Malformed enrichments are ignored for display and
   diagnosed, while mutation refuses to overwrite them.
 - Todo and note enrichments receive a leading `🚧` and `📝` respectively before
-  the graph, with no gap between them when both are present. The dedicated field
-  remains visible alongside selection, dirty-worktree, and conflict markers.
+  the graph, with no gap between them or the following status field. The dedicated
+  field remains visible alongside selection, dirty-worktree, and conflict markers.
   `tix show` emits the same field and aligns unmarked rows when any displayed
   commit has either enrichment.
 - Only the selected history row replaces its commit title with its note title,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index bd015f70bda..2137e8a1ef0 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -766,8 +766,8 @@ mod tests {
         assert_eq!(output.lines().count(), 5, "the complete projected history is printed");
         assert!(output.contains('●'), "history graph lanes are rendered");
         assert!(
-            output.lines().any(|line| line.starts_with("🚧 ")),
-            "todos lead their rows"
+            output.lines().any(|line| line.starts_with("🚧├")),
+            "todos directly lead their rows: {output:?}"
         );
         assert!(output.contains("📌"), "applicable pins are decorated and traversed");
         assert!(
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index 397aa0c91fe..ac35ce1d776 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -17,9 +17,9 @@ pub(crate) struct Enrichment {
 
 pub(crate) fn marker(todo: bool, note: bool) -> &'static str {
     match (todo, note) {
-        (true, true) => "🚧📝 ",
-        (true, false) => "🚧 ",
-        (false, true) => "📝 ",
+        (true, true) => "🚧📝",
+        (true, false) => "🚧",
+        (false, true) => "📝",
         (false, false) => "",
     }
 }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 69045cad0aa..8c1b525142d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -2420,8 +2420,8 @@ mod tests {
         let row = terminal.backend().buffer();
         assert_eq!(row[(0, 0)].symbol(), "🚧", "todo leads the row");
         assert_eq!(row[(2, 0)].symbol(), "📝", "note directly follows todo");
-        assert_eq!(row[(5, 0)].symbol(), ">", "selection retains its own field");
-        assert_eq!(row[(7, 0)].symbol(), "●", "the graph remains separate");
+        assert_eq!(row[(4, 0)].symbol(), ">", "selection directly follows enrichments");
+        assert_eq!(row[(6, 0)].symbol(), "●", "the graph remains separate");
         assert!(
             rendered_line(&terminal, 0).contains("follow-up title"),
             "the selected todo displays its note title"
@@ -2463,8 +2463,8 @@ mod tests {
             "a note replaces the selected title independently of todo"
         );
         assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "📝");
-        assert_eq!(terminal.backend().buffer()[(3, 0)].symbol(), ">");
-        assert_eq!(terminal.backend().buffer()[(5, 0)].symbol(), "●");
+        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "●");
         Ok(())
     }
 

From 47b550460c13642dcc919f77a0c6b852ae4bbe3a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 16:35:15 +0200
Subject: [PATCH 189/282] feat: separate staged and unstaged tix changes

Worktree paths previously relied on color and summary counts to distinguish index entries from unstaged changes, leaving the boundary unclear when both groups were visible.

Insert a centered, scrolling index divider between the groups. Treat it as a non-selectable display row so cursor actions retain path indices, page movement skips the divider, and overflow counts include only hidden paths.
---
 gix-tix/spec.md    |   4 +-
 gix-tix/src/app.rs |  99 ++++++++++++++------
 gix-tix/src/lib.rs |   2 +-
 gix-tix/src/ui.rs  | 223 +++++++++++++++++++++++++++++++++++++++------
 4 files changed, 270 insertions(+), 58 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e0034b2bc01..7c1728c3412 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -465,7 +465,9 @@ space first; changes blocks adapt within the remaining history width.
   `clean` in green, and are not focusable.
 - Tree paths preserve tree-diff order. Worktree paths show staged entries first in
   green and unstaged/untracked/conflicted entries second in bright red, sorted by
-  raw path within each group.
+  raw path within each group. When both groups exist, a non-selectable `↑ index ↑`
+  divider scrolls between them; its green horizontal rails span the inset content
+  width while its centered label uses dimmed normal text.
 - Path kinds are `A`, `M`, `D`, `R`, `C`, `T`, and `U`. The selected path is
   subtly inverted and appends its already-computed non-zero line counts.
 - Blocks are side by side when both condensed titles fit, otherwise Worktree is
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index c6a4c9599ca..b3b78b245b5 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -115,7 +115,9 @@ pub(crate) struct ChangesView {
     pub horizontal_offset: usize,
     pub error: Option<String>,
     page: usize,
+    len: usize,
     max: usize,
+    separator: Option<usize>,
     horizontal_page: usize,
     horizontal_max: usize,
 }
@@ -128,13 +130,40 @@ impl Default for ChangesView {
             horizontal_offset: 0,
             error: None,
             page: 1,
+            len: 0,
             max: 0,
+            separator: None,
             horizontal_page: 1,
             horizontal_max: 0,
         }
     }
 }
 
+impl ChangesView {
+    fn display_index(&self, path_index: usize) -> usize {
+        path_index + usize::from(self.separator.is_some_and(|separator| path_index >= separator))
+    }
+
+    fn ensure_visible(&mut self) {
+        let selected = self.display_index(self.selected);
+        if selected < self.offset {
+            self.offset = selected;
+        } else if selected >= self.offset.saturating_add(self.page) {
+            self.offset = selected + 1 - self.page;
+        }
+        let display_len = self.len + usize::from(self.separator.is_some());
+        self.offset = self.offset.min(display_len.saturating_sub(self.page));
+    }
+
+    fn visible_paths(&self) -> usize {
+        let end = self.offset.saturating_add(self.page);
+        self.page.saturating_sub(usize::from(
+            self.separator
+                .is_some_and(|separator| separator >= self.offset && separator < end),
+        ))
+    }
+}
+
 #[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
 pub(crate) enum ChangeGroup {
     #[default]
@@ -1026,13 +1055,17 @@ impl App {
                 }
             }
             Action::HalfPageUp if self.changes_focus.is_some() => {
-                self.move_changes((self.focused_changes().page / 2).max(1), false);
+                self.move_changes((self.focused_changes().visible_paths() / 2).max(1), false);
             }
             Action::HalfPageDown if self.changes_focus.is_some() => {
-                self.move_changes((self.focused_changes().page / 2).max(1), true);
+                self.move_changes((self.focused_changes().visible_paths() / 2).max(1), true);
+            }
+            Action::PageUp if self.changes_focus.is_some() => {
+                self.move_changes(self.focused_changes().visible_paths().max(1), false);
+            }
+            Action::PageDown if self.changes_focus.is_some() => {
+                self.move_changes(self.focused_changes().visible_paths().max(1), true);
             }
-            Action::PageUp if self.changes_focus.is_some() => self.move_changes(self.focused_changes().page, false),
-            Action::PageDown if self.changes_focus.is_some() => self.move_changes(self.focused_changes().page, true),
             Action::PageUp if self.show_commit && self.commit_max > 0 => {
                 self.commit_offset = self.commit_offset.saturating_sub(self.commit_page);
             }
@@ -1750,15 +1783,7 @@ impl App {
     }
 
     fn ensure_changes_visible(&mut self) {
-        let changes = self.focused_changes_mut();
-        if changes.selected < changes.offset {
-            changes.offset = changes.selected;
-        } else if changes.selected >= changes.offset.saturating_add(changes.page) {
-            changes.offset = changes.selected + 1 - changes.page;
-        }
-        changes.offset = changes
-            .offset
-            .min(changes.max.saturating_add(1).saturating_sub(changes.page));
+        self.focused_changes_mut().ensure_visible();
     }
 
     fn pan_changes(&mut self, right: bool) {
@@ -2181,25 +2206,21 @@ impl App {
         pane: ChangePane,
         page: usize,
         len: usize,
+        separator: Option<usize>,
         horizontal_page: usize,
         horizontal_max: usize,
     ) {
         let changes = self.changes_mut(pane);
         changes.page = page.max(1);
+        changes.len = len;
         changes.max = len.saturating_sub(1);
+        changes.separator = separator.filter(|separator| *separator > 0 && *separator < len);
         if len == 0 {
             changes.selected = 0;
             changes.offset = 0;
         } else {
             changes.selected = changes.selected.min(changes.max);
-            if changes.selected < changes.offset {
-                changes.offset = changes.selected;
-            } else if changes.selected >= changes.offset.saturating_add(changes.page) {
-                changes.offset = changes.selected + 1 - changes.page;
-            }
-            changes.offset = changes
-                .offset
-                .min(changes.max.saturating_add(1).saturating_sub(changes.page));
+            changes.ensure_visible();
         }
         changes.horizontal_page = horizontal_page.max(1);
         changes.horizontal_max = horizontal_max;
@@ -3611,7 +3632,7 @@ mod tests {
         assert_eq!(app.commit_offset, 6);
 
         app.changes_focus = Some(ChangePane::Tree);
-        app.set_changes_bounds(ChangePane::Tree, 2, 5, 1, 0);
+        app.set_changes_bounds(ChangePane::Tree, 2, 5, None, 1, 0);
         app.update(Action::PageDown);
         assert_eq!(app.tree_changes.selected, 2, "focused changes retain paging priority");
         assert_eq!(app.commit_offset, 6);
@@ -3654,7 +3675,7 @@ mod tests {
     fn focused_changes_redirect_navigation_to_the_path_viewport() {
         let mut app = App::new(2);
         app.extend_commits((1..=3).map(row).collect::<Vec<_>>());
-        app.set_changes_bounds(ChangePane::Tree, 4, 10, 20, 45);
+        app.set_changes_bounds(ChangePane::Tree, 4, 10, None, 20, 45);
         show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
         assert_eq!(app.changes_focus, Some(ChangePane::Tree));
@@ -3943,8 +3964,8 @@ mod tests {
     fn cycles_changes_focus_in_visual_order_and_keeps_navigation_independent() {
         let mut app = App::new(1);
         app.changes_mode = Some(ChangesMode::Both);
-        app.set_changes_bounds(ChangePane::Tree, 2, 4, 10, 20);
-        app.set_changes_bounds(ChangePane::Worktree, 2, 4, 10, 20);
+        app.set_changes_bounds(ChangePane::Tree, 2, 4, None, 10, 20);
+        app.set_changes_bounds(ChangePane::Worktree, 2, 4, None, 10, 20);
         app.set_changes_layout(ChangesLayout::SideBySide, true, true);
 
         app.update(Action::ToggleChangesFocus);
@@ -3974,6 +3995,32 @@ mod tests {
         assert_eq!(app.changes_focus, None);
     }
 
+    #[test]
+    fn changes_navigation_skips_display_separators() {
+        let mut app = App::new(1);
+        app.changes_focus = Some(ChangePane::Worktree);
+        app.set_changes_bounds(ChangePane::Worktree, 3, 5, Some(2), 10, 0);
+
+        app.update(Action::PageDown);
+        assert_eq!(app.worktree_changes.selected, 2, "page movement counts only paths");
+        assert_eq!(
+            app.worktree_changes.offset, 1,
+            "the divider remains in the display viewport"
+        );
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::OpenDiff(ChangePane::Worktree, 2)],
+            "actions retain path indices"
+        );
+
+        app.update(Action::Last);
+        assert_eq!(app.worktree_changes.selected, 4);
+        assert_eq!(
+            app.worktree_changes.offset, 3,
+            "the display offset includes the divider row"
+        );
+    }
+
     #[test]
     fn cycles_author_names_without_inert_states() {
         let mut app = App::new(1);
@@ -4065,7 +4112,7 @@ mod tests {
         complete(&mut app);
         app.update(Action::MoveDown);
         let selected = app.rows[app.selected.expect("a row is selected")].id;
-        app.set_changes_bounds(ChangePane::Tree, 1, 3, 1, 2);
+        app.set_changes_bounds(ChangePane::Tree, 1, 3, None, 1, 2);
         show_tree_changes(&mut app);
         app.update(Action::ToggleChangesFocus);
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 9a403a42594..13cde311871 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -5055,7 +5055,7 @@ mod tests {
     fn copies_the_selected_path_from_the_focused_changes_block() {
         let mut app = App::new(1);
         app.changes_focus = Some(ChangePane::Tree);
-        app.set_changes_bounds(ChangePane::Tree, 2, 2, 80, 0);
+        app.set_changes_bounds(ChangePane::Tree, 2, 2, None, 80, 0);
         drop(app.update(Action::MoveDown));
         let changes = Changes {
             paths: ["first", "dir/second"]
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8c1b525142d..c72f77fbee4 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -136,6 +136,20 @@ struct ChangesPaneArea {
     outer: Rect,
 }
 
+fn index_separator(pane: ChangePane, changes: &Changes) -> Option<usize> {
+    if pane != ChangePane::Worktree {
+        return None;
+    }
+    let index = changes
+        .paths
+        .iter()
+        .position(|change| change.group == ChangeGroup::Unstaged)?;
+    changes.paths[..index]
+        .iter()
+        .any(|change| change.group == ChangeGroup::Staged)
+        .then_some(index)
+}
+
 #[derive(Clone, Debug, Default)]
 pub(crate) struct FrameLayout {
     pub history: Rect,
@@ -329,19 +343,27 @@ pub(crate) fn draw_with_worktree(
         });
         (message, content)
     });
-    let pane_height = |changes: &Changes| u16::try_from(changes.paths.len()).unwrap_or(u16::MAX).saturating_add(2);
+    let pane_height = |pane, changes: &Changes| {
+        u16::try_from(changes.paths.len())
+            .unwrap_or(u16::MAX)
+            .saturating_add(u16::from(index_separator(pane, changes).is_some()))
+            .saturating_add(2)
+    };
     let (changes_layout, changes_panes, _) = changes_pane_areas(
         body,
         frame.area().height / 2,
         tree_shown.then(|| {
             (
-                pane_height(tree_changes.expect("visible tree changes exist")),
+                pane_height(ChangePane::Tree, tree_changes.expect("visible tree changes exist")),
                 tree_summary.as_ref().map_or(0, Line::width),
             )
         }),
         worktree_shown.then(|| {
             (
-                pane_height(worktree_changes.expect("visible worktree changes exist")),
+                pane_height(
+                    ChangePane::Worktree,
+                    worktree_changes.expect("visible worktree changes exist"),
+                ),
                 worktree_summary.as_ref().map_or(0, Line::width),
             )
         }),
@@ -1227,21 +1249,38 @@ fn push_selection_span(spans: &mut Vec<Span<'static>>, span: Span<'static>) {
     spans.push(span);
 }
 
+fn index_divider(width: u16) -> Line<'static> {
+    const LABEL: &str = " ↑ index ↑ ";
+    let width = usize::from(width);
+    if width < LABEL.chars().count() {
+        return Line::styled("─".repeat(width), color(Color::Green));
+    }
+    let rails = width - LABEL.chars().count();
+    let left = rails / 2;
+    Line::from(vec![
+        Span::styled("─".repeat(left), color(Color::Green)),
+        Span::styled(LABEL, Style::default().add_modifier(Modifier::DIM)),
+        Span::styled("─".repeat(rails - left), color(Color::Green)),
+    ])
+}
+
 fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, pane: ChangePane, app: &mut App) {
     if area.height == 0 {
-        app.set_changes_bounds(pane, 0, 0, area.width as usize, 0);
+        app.set_changes_bounds(pane, 0, 0, None, area.width as usize, 0);
         return;
     }
     let focused = app.changes_focus == Some(pane);
     let selected_index = app.changes(pane).selected.min(changes.paths.len().saturating_sub(1));
+    let separator = index_separator(pane, changes);
+    let display_len = changes.paths.len() + usize::from(separator.is_some());
     let path_capacity = usize::from(area.height);
-    let overflow = changes.paths.len() > 1 && changes.paths.len() > path_capacity;
-    let visible_paths = if overflow {
+    let overflow = display_len > 1 && display_len > path_capacity;
+    let visible_rows = if overflow {
         path_capacity.saturating_sub(1)
     } else {
-        path_capacity.min(changes.paths.len())
+        path_capacity.min(display_len)
     };
-    let lines: Vec<_> = changes
+    let mut lines: Vec<_> = changes
         .paths
         .iter()
         .enumerate()
@@ -1282,6 +1321,9 @@ fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, pane: Ch
             Line::from(spans)
         })
         .collect();
+    if let Some(separator) = separator {
+        lines.insert(separator, index_divider(area.width));
+    }
     let horizontal_max = lines
         .iter()
         .map(Line::width)
@@ -1290,27 +1332,35 @@ fn render_changes(frame: &mut Frame<'_>, area: Rect, changes: &Changes, pane: Ch
         .saturating_sub(area.width as usize);
     app.set_changes_bounds(
         pane,
-        visible_paths,
+        visible_rows,
         changes.paths.len(),
+        separator,
         area.width as usize,
         horizontal_max,
     );
     let offset = app.changes(pane).offset;
     let horizontal_offset = app.changes(pane).horizontal_offset;
-    let path_area = Rect::new(
-        area.x,
-        area.y,
-        area.width,
-        u16::try_from(visible_paths).unwrap_or(u16::MAX),
-    );
-    frame.render_widget(
-        Paragraph::new(Text::from(
-            lines.into_iter().skip(offset).take(visible_paths).collect::<Vec<_>>(),
-        ))
-        .scroll((0, u16::try_from(horizontal_offset).unwrap_or(u16::MAX))),
-        path_area,
-    );
-    let hidden = changes.paths.len().saturating_sub(offset.saturating_add(visible_paths));
+    for (row, line) in lines.into_iter().skip(offset).take(visible_rows).enumerate() {
+        let display_index = offset + row;
+        let horizontal_offset = if separator == Some(display_index) {
+            0
+        } else {
+            horizontal_offset
+        };
+        frame.render_widget(
+            Paragraph::new(line).scroll((0, u16::try_from(horizontal_offset).unwrap_or(u16::MAX))),
+            Rect::new(
+                area.x,
+                area.y.saturating_add(u16::try_from(row).unwrap_or(u16::MAX)),
+                area.width,
+                1,
+            ),
+        );
+    }
+    let visible_end = offset.saturating_add(visible_rows);
+    let hidden = (0..changes.paths.len())
+        .filter(|index| *index + usize::from(separator.is_some_and(|separator| *index >= separator)) >= visible_end)
+        .count();
     if overflow && hidden > 0 {
         frame.render_widget(
             Paragraph::new(Line::styled(
@@ -4906,6 +4956,7 @@ mod tests {
     fn summarizes_staged_and_unstaged_changes_in_the_top_border() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
         app.changes_mode = Some(ChangesMode::Both);
+        app.changes_focus = Some(ChangePane::Worktree);
         let changes = Changes {
             paths: vec![
                 crate::app::PathChange {
@@ -4927,7 +4978,7 @@ mod tests {
             lines_removed: 1,
             ..Changes::default()
         };
-        let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
+        let mut terminal = Terminal::new(TestBackend::new(80, 12))?;
         terminal.draw(|frame| {
             super::draw_with_worktree(
                 frame,
@@ -4940,7 +4991,7 @@ mod tests {
             );
         })?;
 
-        let (header_y, header) = (0..8)
+        let (header_y, header) = (0..12)
             .map(|y| (y, rendered_line(&terminal, y)))
             .find(|(_, line)| line.contains("Worktree"))
             .expect("the worktree border is visible");
@@ -4949,7 +5000,27 @@ mod tests {
             "the border distinguishes staged and unstaged rows: {header:?}"
         );
         let staged_y = header_y + 1;
-        let unstaged_y = header_y + 2;
+        let divider_y = header_y + 2;
+        let unstaged_y = header_y + 3;
+        let divider = rendered_line(&terminal, divider_y);
+        let label_x = divider[..divider.find("↑ index ↑").expect("the index label is visible")]
+            .chars()
+            .count() as u16;
+        assert_eq!(label_x, (80 - 9) / 2, "the index label is centered");
+        assert_eq!(terminal.backend().buffer()[(2, divider_y)].fg, Color::Green);
+        assert!(
+            !terminal.backend().buffer()[(2, divider_y)]
+                .modifier
+                .contains(Modifier::DIM),
+            "the colored divider rail is not dimmed"
+        );
+        assert_eq!(terminal.backend().buffer()[(label_x, divider_y)].fg, Color::Reset);
+        assert!(
+            terminal.backend().buffer()[(label_x, divider_y)]
+                .modifier
+                .contains(Modifier::DIM),
+            "the centered label uses dimmed normal text"
+        );
         let staged_x = rendered_line(&terminal, staged_y).find('A').expect("staged letter") as u16;
         let unstaged_x = rendered_line(&terminal, unstaged_y).find('M').expect("unstaged letter") as u16;
         assert_eq!(terminal.backend().buffer()[(staged_x, staged_y)].fg, Color::Green);
@@ -4958,6 +5029,31 @@ mod tests {
             Color::LightRed
         );
 
+        let staged_only = Changes {
+            paths: vec![changes.paths[0].clone()],
+            ..Changes::default()
+        };
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&staged_only),
+            );
+        })?;
+        assert!(
+            !(0..12).any(|y| rendered_line(&terminal, y).contains("index")),
+            "a single change group has no divider"
+        );
+        assert_eq!(
+            index_divider(5).to_string(),
+            "─────",
+            "narrow panes retain only the rail"
+        );
+
         let modified = Changes {
             paths: (0..12)
                 .map(|index| crate::app::PathChange {
@@ -4993,18 +5089,18 @@ mod tests {
                 Some(&Changes::default()),
             );
         })?;
-        let (clean_y, clean_header) = (0..8)
+        let (clean_y, clean_header) = (0..12)
             .map(|y| (y, rendered_line(&terminal, y)))
             .find(|(_, line)| line.contains("Worktree clean"))
             .expect("an enabled clean worktree remains visible as an empty block");
         let clean_x = clean_header.find("clean").expect("clean label") as u16;
         assert_eq!(terminal.backend().buffer()[(clean_x, clean_y)].fg, Color::Green);
         assert!(
-            !(0..8).any(|y| rendered_line(&terminal, y).contains("+0") || rendered_line(&terminal, y).contains("-0")),
+            !(0..12).any(|y| rendered_line(&terminal, y).contains("+0") || rendered_line(&terminal, y).contains("-0")),
             "a clean worktree omits empty diff counts"
         );
         assert!(
-            !(0..8).any(|y| rendered_line(&terminal, y).contains("= 0")),
+            !(0..12).any(|y| rendered_line(&terminal, y).contains("= 0")),
             "a clean worktree has no empty aggregate"
         );
         assert!(!app.worktree_changes_visible, "an empty block is not focusable");
@@ -5020,7 +5116,7 @@ mod tests {
                 Some(&Changes::default()),
             );
         })?;
-        let (clean_y, clean_tree) = (0..8)
+        let (clean_y, clean_tree) = (0..12)
             .map(|y| (y, rendered_line(&terminal, y)))
             .find(|(_, line)| line.contains("Tree ------- clean"))
             .expect("an empty tree remains visible and says it is clean");
@@ -5030,6 +5126,73 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn worktree_index_divider_scrolls_with_paths() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.changes_mode = Some(ChangesMode::Both);
+        app.changes_focus = Some(ChangePane::Worktree);
+        let changes = Changes {
+            paths: [
+                ChangeGroup::Staged,
+                ChangeGroup::Staged,
+                ChangeGroup::Unstaged,
+                ChangeGroup::Unstaged,
+            ]
+            .into_iter()
+            .enumerate()
+            .map(|(index, group)| crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group,
+                source: None,
+                path: format!("file-{index}").into(),
+                lines: None,
+            })
+            .collect(),
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(80, 10))?;
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&changes),
+            );
+        })?;
+
+        app.update(Action::MoveDown);
+        app.update(Action::MoveDown);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&changes),
+            );
+        })?;
+
+        let divider_y = (0..10)
+            .find(|y| rendered_line(&terminal, *y).contains("↑ index ↑"))
+            .expect("the boundary scrolls into view");
+        assert!(rendered_line(&terminal, divider_y + 1).contains("M file-2"));
+        assert!(
+            rendered_line(&terminal, divider_y + 2).contains("… 1 line not shown"),
+            "the overflow count excludes the divider"
+        );
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![crate::app::Effect::OpenDiff(ChangePane::Worktree, 2)],
+            "the selected row after the divider retains its path index"
+        );
+        Ok(())
+    }
+
     #[test]
     fn lays_out_tree_and_worktree_changes_by_available_width() -> Result<(), Box<dyn std::error::Error>> {
         let (layout, panes, height) = changes_pane_areas(Rect::new(0, 0, 120, 20), 10, Some((5, 30)), Some((3, 25)));

From 3ada6160e7f7c579d00f3ef316bfef45fa218c6a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 16:48:58 +0200
Subject: [PATCH 190/282] fix: align tix index divider with change kinds

The staged-content divider was centered across the changes pane, which disconnected its index marker from the file-status rows it separates.

Start the dimmed index label in the same column as path-kind letters and fill only the remaining width with the green rail. Clip the label in panes too narrow to show it completely.
---
 gix-tix/spec.md   |  4 ++--
 gix-tix/src/ui.rs | 37 +++++++++++++++----------------------
 2 files changed, 17 insertions(+), 24 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7c1728c3412..3382fd87bee 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -466,8 +466,8 @@ space first; changes blocks adapt within the remaining history width.
 - Tree paths preserve tree-diff order. Worktree paths show staged entries first in
   green and unstaged/untracked/conflicted entries second in bright red, sorted by
   raw path within each group. When both groups exist, a non-selectable `↑ index ↑`
-  divider scrolls between them; its green horizontal rails span the inset content
-  width while its centered label uses dimmed normal text.
+  divider scrolls between them; its dimmed label aligns with the path-kind letters
+  and a green horizontal rail fills the inset content width to its right.
 - Path kinds are `A`, `M`, `D`, `R`, `C`, `T`, and `U`. The selected path is
   subtly inverted and appends its already-computed non-zero line counts.
 - Blocks are side by side when both condensed titles fit, otherwise Worktree is
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index c72f77fbee4..4e5d1816ceb 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1250,17 +1250,13 @@ fn push_selection_span(spans: &mut Vec<Span<'static>>, span: Span<'static>) {
 }
 
 fn index_divider(width: u16) -> Line<'static> {
-    const LABEL: &str = " ↑ index ↑ ";
+    const LABEL: &str = "↑ index ↑ ";
     let width = usize::from(width);
-    if width < LABEL.chars().count() {
-        return Line::styled("─".repeat(width), color(Color::Green));
-    }
-    let rails = width - LABEL.chars().count();
-    let left = rails / 2;
+    let label: String = LABEL.chars().take(width).collect();
+    let rail_width = width - label.chars().count();
     Line::from(vec![
-        Span::styled("─".repeat(left), color(Color::Green)),
-        Span::styled(LABEL, Style::default().add_modifier(Modifier::DIM)),
-        Span::styled("─".repeat(rails - left), color(Color::Green)),
+        Span::styled(label, Style::default().add_modifier(Modifier::DIM)),
+        Span::styled("─".repeat(rail_width), color(Color::Green)),
     ])
 }
 
@@ -5006,22 +5002,23 @@ mod tests {
         let label_x = divider[..divider.find("↑ index ↑").expect("the index label is visible")]
             .chars()
             .count() as u16;
-        assert_eq!(label_x, (80 - 9) / 2, "the index label is centered");
-        assert_eq!(terminal.backend().buffer()[(2, divider_y)].fg, Color::Green);
+        let staged_x = rendered_line(&terminal, staged_y).find('A').expect("staged letter") as u16;
+        assert_eq!(label_x, staged_x, "the index label aligns with path kinds");
+        assert_eq!(terminal.backend().buffer()[(label_x, divider_y)].fg, Color::Reset);
         assert!(
-            !terminal.backend().buffer()[(2, divider_y)]
+            terminal.backend().buffer()[(label_x, divider_y)]
                 .modifier
                 .contains(Modifier::DIM),
-            "the colored divider rail is not dimmed"
+            "the label uses dimmed normal text"
         );
-        assert_eq!(terminal.backend().buffer()[(label_x, divider_y)].fg, Color::Reset);
+        let rail_x = label_x + "↑ index ↑ ".chars().count() as u16;
+        assert_eq!(terminal.backend().buffer()[(rail_x, divider_y)].fg, Color::Green);
         assert!(
-            terminal.backend().buffer()[(label_x, divider_y)]
+            !terminal.backend().buffer()[(rail_x, divider_y)]
                 .modifier
                 .contains(Modifier::DIM),
-            "the centered label uses dimmed normal text"
+            "the colored divider rail is not dimmed"
         );
-        let staged_x = rendered_line(&terminal, staged_y).find('A').expect("staged letter") as u16;
         let unstaged_x = rendered_line(&terminal, unstaged_y).find('M').expect("unstaged letter") as u16;
         assert_eq!(terminal.backend().buffer()[(staged_x, staged_y)].fg, Color::Green);
         assert_eq!(
@@ -5048,11 +5045,7 @@ mod tests {
             !(0..12).any(|y| rendered_line(&terminal, y).contains("index")),
             "a single change group has no divider"
         );
-        assert_eq!(
-            index_divider(5).to_string(),
-            "─────",
-            "narrow panes retain only the rail"
-        );
+        assert_eq!(index_divider(5).to_string(), "↑ ind", "narrow panes clip the label");
 
         let modified = Changes {
             paths: (0..12)

From f7637a4d2ba0c47da45a59a21404f177c6d8d2d6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 17:41:57 +0200
Subject: [PATCH 191/282] feat: align visible tix history columns

History alignment previously fixed the entire metadata stream after the graph, making dates and authors align even when only commit messages needed a stable starting point.

Make the bracket shortcut cycle title, full-column, and unaligned modes using widths from the current viewport. Full-column rows scroll as one padded line so clipped metadata remains reachable, while flat command and todo output stays unchanged.
---
 gix-tix/spec.md    |   7 +-
 gix-tix/src/app.rs |  25 ++-
 gix-tix/src/lib.rs |   1 +
 gix-tix/src/ui.rs  | 391 +++++++++++++++++++++++++++++++--------------
 4 files changed, 296 insertions(+), 128 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3382fd87bee..87a5a6262f2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -307,7 +307,7 @@ without trading responsiveness for metadata that is not visible.
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. Its actions remain direct shortcuts. |
 | `t` | Toggle the rounded ref-tree overview. |
-| `[` | Toggle graph/metadata alignment. |
+| `[` | Cycle viewport-local title alignment, full-column alignment, and no alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Cycle author dates, committer dates, and no dates. |
 | `v e` | Toggle full actors/emails and titles. |
@@ -325,6 +325,11 @@ without trading responsiveness for metadata that is not visible.
 | `s` | Verify signed, unverified commits currently visible on screen. |
 | `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
 
+Alignment uses only rows in the current viewport to determine widths and starts
+in title mode. Title alignment keeps titles fixed while horizontal navigation
+pans graph overflow. Full-column alignment pans the complete padded row so
+clipped fields can be reached.
+
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
 for signature verification, alignment, message, and changes actions, but these
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index b3b78b245b5..fdab25bb1a0 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -427,6 +427,13 @@ pub(crate) enum Effect {
     Quit,
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum Alignment {
+    None,
+    Title,
+    Columns,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum TreeDiffTarget {
     Commit { id: ObjectId, parent: usize },
@@ -474,7 +481,7 @@ pub(crate) struct App {
     visible_ref_mode: RefMode,
     pub has_hidden_filter: bool,
     pub show_hidden: bool,
-    pub align_metadata: bool,
+    pub(crate) alignment: Alignment,
     pub show_commit: bool,
     pub changes_mode: Option<ChangesMode>,
     worktree_changes_available: bool,
@@ -571,7 +578,7 @@ impl App {
             visible_ref_mode: RefMode::Default,
             has_hidden_filter: false,
             show_hidden: false,
-            align_metadata: true,
+            alignment: Alignment::Title,
             show_commit: false,
             changes_mode: Some(ChangesMode::Both),
             worktree_changes_available: true,
@@ -1159,7 +1166,13 @@ impl App {
             {
                 return vec![Effect::Reload(!self.show_hidden)];
             }
-            Action::ToggleAlign => self.align_metadata = !self.align_metadata,
+            Action::ToggleAlign => {
+                self.alignment = match self.alignment {
+                    Alignment::Title => Alignment::Columns,
+                    Alignment::Columns => Alignment::None,
+                    Alignment::None => Alignment::Title,
+                };
+            }
             Action::ToggleCommit => {
                 self.show_commit = !self.show_commit;
                 self.reset_commit_view();
@@ -3779,12 +3792,14 @@ mod tests {
         assert_eq!(app.ref_mode, RefMode::All);
         app.update(Action::CycleRefs);
         assert_eq!(app.ref_mode, RefMode::Default);
-        assert!(!app.align_metadata);
+        assert_eq!(app.alignment, Alignment::Columns);
         assert!(app.show_commit);
         assert_eq!(app.changes_mode, Some(ChangesMode::Tree));
         assert_eq!(app.changes_parent, 0);
         app.update(Action::ToggleAlign);
-        assert!(app.align_metadata);
+        assert_eq!(app.alignment, Alignment::None);
+        app.update(Action::ToggleAlign);
+        assert_eq!(app.alignment, Alignment::Title);
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 13cde311871..acccf6b2082 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -6023,6 +6023,7 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('['), KeyModifiers::NONE)),
             Some(Action::ToggleAlign)
         );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('\\'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char(']'), KeyModifiers::NONE)),
             Some(Action::ToggleCommit)
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4e5d1816ceb..4be509a5368 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -10,8 +10,9 @@ use ratatui::{
 use crate::{
     BuiltInDiff,
     app::{
-        App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes, ChangesLayout, ChangesMode, CommitRow,
-        CopyKind, DateMode, IdMode, NameMode, Notice, NoticeKind, RefMode, SelectionRelation, SignatureState, State,
+        Alignment as HistoryAlignment, App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes,
+        ChangesLayout, ChangesMode, CommitRow, CopyKind, DateMode, IdMode, NameMode, Notice, NoticeKind, RefMode,
+        SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -499,12 +500,7 @@ pub(crate) fn draw_with_worktree(
     } else {
         rendered_lane_width
     };
-    let align_limit = ((body.width as usize) / 3)
-        .saturating_sub(2)
-        .max(1)
-        .min(content.width as usize);
-    let align_width = max_lane_width.min(align_limit);
-    let align_metadata = app.align_metadata;
+    let alignment = app.alignment;
     let date_mode = app.date_mode;
     let id_mode = app.effective_id_mode();
     let name_mode = app.name_mode;
@@ -513,7 +509,7 @@ pub(crate) fn draw_with_worktree(
     let show_trailers = name_mode == NameMode::All && app.show_trailers;
     let ref_mode = app.ref_mode;
     let selected = app.selected;
-    let metadata: Vec<_> = visible_rows
+    let metadata_columns: Vec<_> = visible_rows
         .iter()
         .enumerate()
         .map(|(index, row)| {
@@ -522,7 +518,7 @@ pub(crate) fn draw_with_worktree(
                 || app.title(row),
                 |note| gix::objs::commit::MessageRef::from_bytes(note).title,
             );
-            metadata_line(
+            metadata_columns(
                 row,
                 title,
                 app.attributions(row),
@@ -546,21 +542,57 @@ pub(crate) fn draw_with_worktree(
             )
         })
         .collect();
-    let graph_max_offset = max_lane_width.saturating_sub(align_width);
-    let max_offset = if align_metadata {
-        graph_max_offset
-    } else {
-        lanes
+    let title_column = lanes
+        .iter()
+        .zip(&metadata_columns)
+        .map(|(lane, metadata)| lane.chars().count().saturating_add(metadata.prefix_width()))
+        .max()
+        .unwrap_or_default();
+    let column_widths = metadata_columns.iter().fold([0; 5], |mut widths, metadata| {
+        for (width, field) in widths.iter_mut().zip(&metadata.fields[..5]) {
+            *width = (*width).max(field.width());
+        }
+        widths
+    });
+    let metadata: Vec<_> = metadata_columns
+        .into_iter()
+        .enumerate()
+        .map(|(index, metadata)| match alignment {
+            HistoryAlignment::None => (metadata.into_line(), 0),
+            HistoryAlignment::Title => {
+                let lane_width = lanes.lane(index).chars().count();
+                (
+                    metadata.align_title(title_column.saturating_sub(lane_width)),
+                    lane_width,
+                )
+            }
+            HistoryAlignment::Columns => (metadata.align_columns(column_widths), max_lane_width),
+        })
+        .collect();
+    let graph_max_offset = max_lane_width.saturating_sub(content.width as usize);
+    let max_offset = match alignment {
+        HistoryAlignment::None => lanes
             .iter()
             .zip(&metadata)
-            .map(|(lane, metadata)| lane.chars().count().saturating_add(metadata.width()))
+            .map(|(lane, (metadata, _))| lane.chars().count().saturating_add(metadata.width()))
             .max()
             .unwrap_or_default()
-            .saturating_sub(content.width as usize)
+            .saturating_sub(content.width as usize),
+        HistoryAlignment::Title => graph_max_offset,
+        HistoryAlignment::Columns => metadata
+            .iter()
+            .map(|(metadata, metadata_x)| metadata_x.saturating_add(metadata.width()))
+            .max()
+            .unwrap_or_default()
+            .saturating_sub(content.width as usize),
     }
     .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
-    let graph_offset = horizontal_offset.min(graph_max_offset);
+    let graph_offset = if alignment == HistoryAlignment::Title {
+        horizontal_offset.min(graph_max_offset)
+    } else {
+        horizontal_offset
+    };
     let selection_info = selection_info_line(
         app.changes_visible()
             .then_some(tree_changes)
@@ -576,7 +608,7 @@ pub(crate) fn draw_with_worktree(
         .enumerate()
         .map(|(index, row)| (row.id, body.y.saturating_add(index as u16)))
         .collect();
-    for (index, metadata) in metadata.into_iter().enumerate() {
+    for (index, (metadata, metadata_x)) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
         let y = body.y.saturating_add(index as u16);
         let selected = app.selected == Some(start + index);
@@ -590,13 +622,16 @@ pub(crate) fn draw_with_worktree(
         let head_state = head.then_some(head_has_descendants);
         let metadata_width = metadata.width();
         let hidden_branch_behind = app.hidden_branch_behind(visible_rows[index].id);
-        let line_width = if align_metadata {
-            align_width.saturating_add(metadata_width)
-        } else {
-            lane.chars()
+        let line_width = match alignment {
+            HistoryAlignment::None => lane
+                .chars()
                 .count()
                 .saturating_add(metadata_width)
-                .saturating_sub(horizontal_offset)
+                .saturating_sub(horizontal_offset),
+            HistoryAlignment::Title => metadata_x.saturating_add(metadata_width),
+            HistoryAlignment::Columns => metadata_x
+                .saturating_add(metadata_width)
+                .saturating_sub(horizontal_offset),
         };
         let hidden_branch_marker = hidden_branch_behind.and_then(|behind| {
             let marker = format!("⇣{behind}");
@@ -660,7 +695,7 @@ pub(crate) fn draw_with_worktree(
         );
 
         let row_area = Rect::new(content.x, y, content.width, 1);
-        if align_metadata {
+        if alignment == HistoryAlignment::Title {
             frame.render_widget(
                 Paragraph::new(lane).style(style).scroll((0, graph_offset as u16)),
                 row_area,
@@ -675,16 +710,21 @@ pub(crate) fn draw_with_worktree(
                 head_state,
             );
             let aligned = Rect::new(
-                content.x.saturating_add(align_width as u16),
+                content.x.saturating_add(u16::try_from(metadata_x).unwrap_or(u16::MAX)),
                 y,
-                content.width.saturating_sub(align_width as u16),
+                content
+                    .width
+                    .saturating_sub(u16::try_from(metadata_x).unwrap_or(u16::MAX)),
                 1,
             );
             frame.render_widget(Clear, aligned);
             frame.render_widget(Paragraph::new(metadata), aligned);
         } else {
-            let mut spans = Vec::with_capacity(metadata.spans.len() + 1);
+            let mut spans = Vec::with_capacity(metadata.spans.len() + 2);
             spans.push(Span::styled(lane, style));
+            if alignment == HistoryAlignment::Columns {
+                spans.push(Span::raw(" ".repeat(metadata_x.saturating_sub(lane.chars().count()))));
+            }
             spans.extend(metadata.spans);
             frame.render_widget(
                 Paragraph::new(Line::from(spans)).scroll((0, horizontal_offset as u16)),
@@ -1112,7 +1152,12 @@ pub(crate) fn draw_with_worktree(
                 Span::raw(" · "),
             ]);
         }
-        ordered.push(toggle("[ align", app.align_metadata));
+        let (alignment, enabled) = match app.alignment {
+            HistoryAlignment::Title => ("[ title", true),
+            HistoryAlignment::Columns => ("[ columns", true),
+            HistoryAlignment::None => ("[ align", false),
+        };
+        ordered.push(toggle(alignment, enabled));
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("ref-tree", 't', false));
         ordered.push(Span::raw(" · "));
@@ -1907,14 +1952,48 @@ struct MetadataOptions {
     copy_feedback: Option<CopyKind>,
 }
 
-fn metadata_line<'a>(
+struct MetadataColumns<'a> {
+    fields: [Line<'a>; 6],
+}
+
+impl<'a> MetadataColumns<'a> {
+    fn prefix_width(&self) -> usize {
+        self.fields[..5].iter().map(Line::width).sum()
+    }
+
+    fn into_line(self) -> Line<'a> {
+        Line::from(
+            self.fields
+                .into_iter()
+                .flat_map(|field| field.spans)
+                .collect::<Vec<_>>(),
+        )
+    }
+
+    fn align_title(mut self, width: usize) -> Line<'a> {
+        let padding = width.saturating_sub(self.prefix_width());
+        self.fields[4].spans.push(Span::raw(" ".repeat(padding)));
+        self.into_line()
+    }
+
+    fn align_columns(mut self, widths: [usize; 5]) -> Line<'a> {
+        for (field, width) in self.fields[..5].iter_mut().zip(widths) {
+            field
+                .spans
+                .push(Span::raw(" ".repeat(width.saturating_sub(field.width()))));
+        }
+        self.into_line()
+    }
+}
+
+fn metadata_columns<'a>(
     row: &'a CommitRow,
     title: &'a BStr,
     attributions: &'a [crate::app::Attribution],
     decorations: &'a Decorations,
     mailmap: &'a gix::mailmap::Snapshot,
     options: MetadataOptions,
-) -> Line<'a> {
+) -> MetadataColumns<'a> {
     debug_assert!(row.metadata_loaded, "visible rows have metadata");
     let MetadataOptions {
         date_mode,
@@ -1944,37 +2023,38 @@ fn metadata_line<'a>(
             style
         }
     };
-    let mut spans = Vec::new();
+    let mut id = Vec::new();
     match id_mode {
-        IdMode::Commit => spans.push(Span::styled(
+        IdMode::Commit => id.push(Span::styled(
             row.id.to_hex_with_len(7).to_string(),
             selected_style(commit_style),
         )),
         IdMode::Change if duplicate_change_id => {
-            spans.push(Span::styled(
+            id.push(Span::styled(
                 change_id.to_reverse_hex_with_len(4).to_string(),
                 selected_style(change_style),
             ));
-            spans.push(Span::styled(
+            id.push(Span::styled(
                 row.id.to_hex_with_len(3).to_string(),
                 selected_style(commit_style),
             ));
         }
-        IdMode::Change => spans.push(Span::styled(
+        IdMode::Change => id.push(Span::styled(
             change_id.to_reverse_hex_with_len(7).to_string(),
             selected_style(change_style),
         )),
         IdMode::Off => {}
     }
+    let mut refs = Vec::new();
     let row_decorations = decorations.get(&row.id).map(Vec::as_slice).unwrap_or_default();
     if row.is_review {
-        spans.push(Span::styled(" ◆", decoration_style(DecorationKind::Review)));
+        refs.push(Span::styled(" ◆", decoration_style(DecorationKind::Review)));
     }
     if row_decorations
         .iter()
         .any(|decoration| decoration.kind == DecorationKind::Pin)
     {
-        spans.push(Span::styled(" 📌", decoration_style(DecorationKind::Pin)));
+        refs.push(Span::styled(" 📌", decoration_style(DecorationKind::Pin)));
     }
     if row_decorations
         .iter()
@@ -1989,7 +2069,7 @@ fn metadata_line<'a>(
         } else {
             " 🎁"
         };
-        spans.push(Span::styled(marker, decoration_style(DecorationKind::Stash)));
+        refs.push(Span::styled(marker, decoration_style(DecorationKind::Stash)));
     }
     let mut labels = row_decorations
         .iter()
@@ -2012,13 +2092,13 @@ fn metadata_line<'a>(
         })
         .peekable();
     if labels.peek().is_some() {
-        spans.push(Span::raw(" ("));
+        refs.push(Span::raw(" ("));
         for (index, decoration) in labels.enumerate() {
             if index != 0 {
-                spans.push(Span::raw(", "));
+                refs.push(Span::raw(", "));
             }
             let name = decoration.name.to_str_lossy();
-            spans.push(Span::styled(
+            refs.push(Span::styled(
                 if matches!(
                     decoration.kind,
                     DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
@@ -2037,21 +2117,24 @@ fn metadata_line<'a>(
                 decoration_style(decoration.kind),
             ));
         }
-        spans.push(Span::raw(") "));
+        refs.push(Span::raw(") "));
     } else {
-        spans.push(Span::raw(" "));
+        refs.push(Span::raw(" "));
     }
+    let mut date_spans = Vec::new();
     let date = match date_mode {
         DateMode::Author => Some(row.author_time),
         DateMode::Committer => Some(row.committer_time),
         DateMode::None => None,
     };
     if let Some(date) = date {
-        spans.push(Span::styled(
+        date_spans.push(Span::styled(
             format!("{} ", date.format_or_unix(gix::date::time::format::SHORT)),
             color(Color::Blue),
         ));
     }
+    let mut author_spans = Vec::new();
+    let mut attribution_spans = Vec::new();
     if show_author_name {
         let author = author_label(row.author, mailmap, use_mailmap, show_emails && !row.author.is_bot());
         let mut author_style = if copy_feedback == Some(CopyKind::Author) {
@@ -2062,7 +2145,7 @@ fn metadata_line<'a>(
         if row.author.is_github_noreply() {
             author_style = author_style.add_modifier(Modifier::ITALIC);
         }
-        spans.push(Span::styled(
+        author_spans.push(Span::styled(
             if row.author.is_bot() {
                 format!("[{author}] ")
             } else {
@@ -2113,7 +2196,7 @@ fn metadata_line<'a>(
                 }
             }
             for (marker, markers, actors) in groups {
-                spans.push(Span::styled(
+                attribution_spans.push(Span::styled(
                     if markers.len() == 1 {
                         marker.to_owned()
                     } else {
@@ -2123,20 +2206,21 @@ fn metadata_line<'a>(
                 ));
                 for (index, (name, style)) in actors.into_iter().enumerate() {
                     if index != 0 {
-                        spans.push(Span::raw(", "));
+                        attribution_spans.push(Span::raw(", "));
                     }
-                    spans.push(Span::styled(name, style));
+                    attribution_spans.push(Span::styled(name, style));
                 }
-                spans.push(Span::raw(" "));
+                attribution_spans.push(Span::raw(" "));
             }
         }
     }
     if row.has_agent_marker {
-        spans.push(Span::styled("[A] ", color(NOTE_COLOR)));
+        attribution_spans.push(Span::styled("[A] ", color(NOTE_COLOR)));
     }
     if has_notes {
-        spans.push(Span::styled("[N] ", color(NOTE_COLOR)));
+        attribution_spans.push(Span::styled("[N] ", color(NOTE_COLOR)));
     }
+    let mut title_spans = Vec::new();
     if !show_emails {
         let mut title = markdown_title_spans(title);
         if note {
@@ -2144,9 +2228,29 @@ fn metadata_line<'a>(
                 span.style = span.style.patch(note_style());
             }
         }
-        spans.extend(title);
+        title_spans.extend(title);
+    }
+    MetadataColumns {
+        fields: [
+            Line::from(id),
+            Line::from(refs),
+            Line::from(date_spans),
+            Line::from(author_spans),
+            Line::from(attribution_spans),
+            Line::from(title_spans),
+        ],
     }
-    Line::from(spans)
+}
+
+fn metadata_line<'a>(
+    row: &'a CommitRow,
+    title: &'a BStr,
+    attributions: &'a [crate::app::Attribution],
+    decorations: &'a Decorations,
+    mailmap: &'a gix::mailmap::Snapshot,
+    options: MetadataOptions,
+) -> Line<'a> {
+    metadata_columns(row, title, attributions, decorations, mailmap, options).into_line()
 }
 
 pub(crate) fn plain_history_metadata(
@@ -3486,14 +3590,14 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         assert!(
             footer.starts_with(
-                    "0 commits · view · edit · enrich · copy · refs · ? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                    "0 commits · view · edit · enrich · copy · refs · ? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
         assert_reversed_group(
             &terminal,
             1,
-            "? ([ align · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
+            "? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
         );
         Ok(())
     }
@@ -4144,11 +4248,11 @@ mod tests {
 
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("copy · refs · ? (s ● -> ● · [ align"));
+        assert!(rendered_line(&terminal, 1).contains("copy · refs · ? (s ● -> ● · [ title"));
 
         app.finish_signature_verification(vec![(id, false)]);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("? (s 1 ● · [ align"));
+        assert!(rendered_line(&terminal, 1).contains("? (s 1 ● · [ title"));
         Ok(())
     }
 
@@ -4590,7 +4694,7 @@ mod tests {
         })?;
         assert!(
             rendered_line(&footer_terminal, 15).contains(
-                "? ([ align · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                "? ([ title · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
             ),
             "the expanded information prefix contains every following action except quit"
         );
@@ -5887,85 +5991,128 @@ mod tests {
     }
 
     #[test]
-    fn overlays_metadata_on_wide_graphs_and_allows_natural_flow() -> Result<(), Box<dyn std::error::Error>> {
-        let mut app = App::new(1);
-        app.id_mode = IdMode::Commit;
-        app.extend_commits(vec![Commit {
-            id: gix::ObjectId::Sha1([1; 20]),
-            parent_ids: Default::default(),
-            author_time: gix::date::Time::default(),
-            committer_time: gix::date::Time::default(),
-            author: author(b"author", b"author@example.com"),
-            attributions: 0..0,
-            title: format!("{} subject-tail", "a".repeat(50)).into(),
-            metadata_loaded: true,
-            has_agent_marker: false,
-            is_review: false,
-            signature: SignatureState::Unsigned,
-        }]);
-        complete(&mut app);
-        app.set_lane(0, &format!("{}{}", "A".repeat(40), "B".repeat(40)));
-        let mut terminal = Terminal::new(TestBackend::new(60, 2))?;
+    fn aligns_titles_or_all_columns_from_only_visible_rows() -> Result<(), Box<dyn std::error::Error>> {
+        fn column(line: &str, needle: &str) -> usize {
+            line[..line.find(needle).expect("field is visible")].chars().count()
+        }
 
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        let aligned_column = rendered_row(&terminal)
-            .find("0101010")
-            .expect("alignment keeps metadata visible beside wide graphs");
-        assert!(aligned_column < 60, "alignment keeps metadata within the viewport");
+        let ids = [1, 2, 3].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let mut app = App::new(2);
+        app.extend_commits(LoadedCommits {
+            rows: vec![
+                Commit {
+                    id: ids[0],
+                    parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"Byron", b"byron@example.com"),
+                    attributions: 0..0,
+                    title: "first-title".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                },
+                Commit {
+                    id: ids[1],
+                    parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"Byron", b"byron@example.com"),
+                    attributions: 0..1,
+                    title: "second-title".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: true,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                },
+                Commit {
+                    id: ids[2],
+                    parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"An extraordinarily long author", b"long@example.com"),
+                    attributions: 1..1,
+                    title: "third-title".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                },
+            ],
+            attributions: vec![Attribution {
+                kind: AttributionKind::CoAuthor,
+                author: author(b"GPT", b"gpt@example.com"),
+            }],
+        });
+        complete(&mut app);
+        app.selected = None;
+        app.set_lane(0, "● ");
+        app.set_lane(1, "●─┐ ");
+        app.set_lane(2, "● ");
+        let decorations = Decorations::from([(
+            ids[0],
+            vec![Decoration {
+                name: "various-improvements".into(),
+                kind: DecorationKind::Local,
+            }],
+        )]);
+        let mut terminal = Terminal::new(TestBackend::new(120, 3))?;
 
-        app.update(Action::ScrollRight);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "B");
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let first_title = column(&rendered_line(&terminal, 0), "first-title");
+        let second_title = column(&rendered_line(&terminal, 1), "second-title");
         assert_eq!(
-            rendered_row(&terminal).find("0101010"),
-            Some(aligned_column),
-            "horizontal graph scrolling leaves aligned metadata fixed"
+            first_title,
+            second_title,
+            "[ aligns only the visible titles: {:?} / {:?}",
+            rendered_line(&terminal, 0),
+            rendered_line(&terminal, 1)
+        );
+        assert_ne!(
+            column(&rendered_line(&terminal, 0), "1970-01-01"),
+            column(&rendered_line(&terminal, 1), "1970-01-01"),
+            "title mode leaves earlier fields at natural positions"
         );
 
-        app.update(Action::ScrollLeft);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         app.update(Action::ToggleAlign);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(
-            !rendered_row(&terminal).contains("0101010"),
-            "[ restores natural post-graph placement"
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let first = rendered_line(&terminal, 0);
+        let second = rendered_line(&terminal, 1);
+        assert_eq!(
+            column(&first, "1970-01-01"),
+            column(&second, "1970-01-01"),
+            "dates align"
+        );
+        assert_eq!(column(&first, "Byron"), column(&second, "Byron"), "authors align");
+        assert_eq!(
+            column(&first, "first-title"),
+            column(&second, "second-title"),
+            "titles align"
         );
         assert!(
-            !app.align_metadata,
-            "alignment is disabled even when its later footer hint is clipped"
+            second.contains("Co: GPT [A] second-title"),
+            "attribution and markers share one column"
         );
 
+        let mut narrow = Terminal::new(TestBackend::new(40, 3))?;
+        narrow.draw(|frame| draw(frame, &mut app, &decorations))?;
         app.update(Action::ScrollRight);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(app.horizontal_offset > 0, "wide aligned columns create a scroll range");
+        narrow.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
-            rendered_row(&terminal).contains("0101010"),
-            "l pages far enough right to reveal natural metadata"
+            rendered_line(&narrow, 0).contains("first-title"),
+            "l reveals the clipped aligned title"
         );
-
         app.update(Action::ScrollLeft);
-        app.set_lane(0, "● ");
-        app.update(Action::ToggleAlign);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(
-            terminal.backend().buffer()[(4, 0)].symbol(),
-            "0",
-            "aligned metadata starts immediately after the widest visible lane"
-        );
-        assert!(
-            !rendered_row(&terminal).contains("subject-tail"),
-            "long aligned metadata starts clipped"
-        );
+        assert_eq!(app.horizontal_offset, 0, "h returns to the aligned row start");
 
-        app.update(Action::ScrollRight);
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(
-            terminal.backend().buffer()[(4, 0)].symbol(),
-            "0",
-            "l leaves aligned metadata fixed when there is no graph left to pan"
-        );
+        let visible_title = column(&first, "first-title");
+        app.offset = 1;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
-            !rendered_row(&terminal).contains("subject-tail"),
-            "aligned metadata remains clipped instead of becoming horizontal-scroll content"
+            column(&rendered_line(&terminal, 0), "second-title") > visible_title,
+            "an off-screen wide author affects alignment only after entering the viewport"
         );
         Ok(())
     }

From f0ad19a875fbb0527a65743146475e4d5c06de64 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 17:50:42 +0200
Subject: [PATCH 192/282] feat: italicize attached tix HEAD markers

Attached and detached HEAD rows previously used the same graph marker styling, leaving attachment visible only through reference labels.

Use the existing current-worktree branch decoration to italicize only an attached graph @. Preserve signature colors, selection reversal, descendant emphasis, and upright detached markers.
---
 gix-tix/spec.md   |  4 +--
 gix-tix/src/ui.rs | 91 ++++++++++++++++++++++++++++++++++++++++++++---
 2 files changed, 88 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 87a5a6262f2..8c00e04f30b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -138,8 +138,8 @@ without trading responsiveness for metadata that is not visible.
 - The commit marker is blue when unsigned, orange when signed but unverified or
   being verified, green when verified, and bright red when verification fails.
 - The current `HEAD` commit, including a review commit, uses `@` instead of the
-  normal commit disc and keeps
-  the same signature and selection coloring. It remains visible when textual
+  normal commit disc. The marker is italic when HEAD is attached to a branch and
+  keeps the same signature and selection coloring. It remains visible when textual
   reference labels are hidden, and textual `HEAD` is never rendered alongside it.
 - At startup, the current worktree's `@` row becomes selected as soon as it is
   loaded, unless the user navigates first. Once the viewport is known, the row
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 4be509a5368..7319c2026a0 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -617,9 +617,17 @@ pub(crate) fn draw_with_worktree(
                 .iter()
                 .any(|decoration| decoration.kind == DecorationKind::Head)
         });
+        let attached_head = decorations.get(&visible_rows[index].id).is_some_and(|decorations| {
+            decorations
+                .iter()
+                .any(|decoration| decoration.kind == DecorationKind::CurrentWorktreeBranch)
+        });
         let head_has_descendants = app.worktree_head_has_descendants(visible_rows[index].id);
         let underline = head_has_descendants && !selected;
-        let head_state = head.then_some(head_has_descendants);
+        let head_state = head.then_some(HeadState {
+            has_descendants: head_has_descendants,
+            attached: attached_head,
+        });
         let metadata_width = metadata.width();
         let hidden_branch_behind = app.hidden_branch_behind(visible_rows[index].id);
         let line_width = match alignment {
@@ -2380,6 +2388,12 @@ fn color(color: Color) -> Style {
     Style::default().fg(color)
 }
 
+#[derive(Clone, Copy)]
+struct HeadState {
+    has_descendants: bool,
+    attached: bool,
+}
+
 fn color_graph(
     frame: &mut Frame<'_>,
     area: Rect,
@@ -2387,7 +2401,7 @@ fn color_graph(
     offset: usize,
     highlight: Option<Color>,
     signature: SignatureState,
-    head: Option<bool>,
+    head: Option<HeadState>,
 ) {
     for (x, symbol) in graph.chars().skip(offset).take(area.width as usize).enumerate() {
         if symbol.is_whitespace() {
@@ -2400,12 +2414,15 @@ fn color_graph(
         } else {
             graph_style(offset.saturating_add(x) / 2)
         };
-        if head == Some(true) && symbol == '●' {
+        if head.is_some_and(|head| head.has_descendants) && symbol == '●' {
             style = style.add_modifier(Modifier::BOLD);
         }
         let cell = &mut frame.buffer_mut()[(area.x + x as u16, area.y)];
         if head.is_some() && symbol == '●' {
             cell.set_symbol("@");
+            if head.is_some_and(|head| head.attached) {
+                style = style.add_modifier(Modifier::ITALIC);
+            }
         }
         cell.set_style(style);
     }
@@ -3951,7 +3968,10 @@ mod tests {
                         0,
                         Some(signature_color(*state)),
                         *state,
-                        head.then_some(false),
+                        head.then_some(HeadState {
+                            has_descendants: false,
+                            attached: false,
+                        }),
                     );
                 }
             }
@@ -3981,7 +4001,10 @@ mod tests {
                 0,
                 None,
                 SignatureState::Unsigned,
-                Some(true),
+                Some(HeadState {
+                    has_descendants: true,
+                    attached: false,
+                }),
             );
         })?;
         assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "@");
@@ -3989,6 +4012,64 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn italicizes_only_an_attached_head_marker() -> Result<(), Box<dyn std::error::Error>> {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut app = App::new(1);
+        app.extend_commits(vec![Commit {
+            id,
+            parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        }]);
+        complete(&mut app);
+        app.selected = None;
+        app.set_lane(0, "● ");
+        let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
+        let head = Decoration {
+            name: "HEAD".into(),
+            kind: DecorationKind::Head,
+        };
+
+        let attached = Decorations::from([(
+            id,
+            vec![
+                head.clone(),
+                Decoration {
+                    name: "main".into(),
+                    kind: DecorationKind::CurrentWorktreeBranch,
+                },
+            ],
+        )]);
+        terminal.draw(|frame| draw(frame, &mut app, &attached))?;
+        let marker = &terminal.backend().buffer()[(2, 0)];
+        assert_eq!(marker.symbol(), "@");
+        assert!(marker.modifier.contains(Modifier::ITALIC), "attached HEAD is italic");
+
+        let detached = Decorations::from([(
+            id,
+            vec![
+                head,
+                Decoration {
+                    name: "worktree".into(),
+                    kind: DecorationKind::CurrentWorktreeDetached,
+                },
+            ],
+        )]);
+        terminal.draw(|frame| draw(frame, &mut app, &detached))?;
+        let marker = &terminal.backend().buffer()[(2, 0)];
+        assert_eq!(marker.symbol(), "@");
+        assert!(!marker.modifier.contains(Modifier::ITALIC), "detached HEAD is upright");
+        Ok(())
+    }
+
     #[test]
     fn underlines_an_unselected_non_tip_head_and_bolds_its_marker() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);

From de22dcbfaa9830886132a9c557f6bdbcc2a4125d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 19:09:06 +0200
Subject: [PATCH 193/282] feat: improve tix travel, stash, and scrolling

Animate TUI time-travel by following rebased commits at up to 60 fps, add the command-line stash operation, and make title-aligned history rows horizontally scrollable.
---
 gix-tix/spec.md                 |  23 ++--
 gix-tix/src/command.rs          |  20 ++++
 gix-tix/src/edit/rebase.rs      |  28 +----
 gix-tix/src/edit/time_travel.rs | 111 +++++-------------
 gix-tix/src/lib.rs              | 199 ++++++++++++++++++++++++++++----
 gix-tix/src/ui.rs               |  93 ++++++---------
 6 files changed, 279 insertions(+), 195 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8c00e04f30b..788bc78588c 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -27,6 +27,8 @@ without trading responsiveness for metadata that is not visible.
   rules. Replay conflicts change nothing unless explicitly materialized; an
   accepted conflict writes the checkout and unmerged index, then exits with an
   error so resolution cannot be mistaken for completion.
+- `tix stash` saves the index and worktree state at `HEAD` through the same
+  commit-stash operation as the TUI.
 - `tix reword REVSPEC [--author "Name <email>"] [-m MESSAGE ... | -f FILE]`
   applies the same signing,
   lazy-rebase, mutable-ref, and worktree-safety rules as the TUI. Without either
@@ -326,9 +328,8 @@ without trading responsiveness for metadata that is not visible.
 | `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
 
 Alignment uses only rows in the current viewport to determine widths and starts
-in title mode. Title alignment keeps titles fixed while horizontal navigation
-pans graph overflow. Full-column alignment pans the complete padded row so
-clipped fields can be reached.
+in title mode. Horizontal navigation pans the complete padded row in title and
+full-column alignment so clipped fields can be reached.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
@@ -418,6 +419,7 @@ The Enter key is written as `<enter>` throughout.
   query. Saving uses Git with `--include-untracked`, leaves ignored files alone,
   preserves the ordinary stash stack, and records the stash commit at
   `refs/tix/stash/<full-commit-id>`. A commit can retain only one such stash.
+  `tix stash` performs this operation directly at `HEAD` with the same checks.
 - A commit stash is shown as a bright `🎁` beside any `📌`, directly after the
   hash and outside reference visibility. Time travel back to that exact commit
   restores it with `git stash apply --index` and consumes its companion ref after
@@ -888,15 +890,12 @@ space first; changes blocks adapt within the remaining history width.
   the index tree, including additional staged changes, becomes the resolved tree.
   There is no hidden sequencer state or separate continue/abort command.
 - Interactive todo application and time travel run on a scoped worker so the
-  terminal can remain renderable without cloning the cached history graph. If
-  either operation is still running after 300 ms, a modal gauge shows processed
-  versus total source commits and live cherry-pick and signature counts with
-  their cumulative durations. `pick`, `squash`, and `empty` commands each
-  contribute to a todo total; time travel counts every commit in its pending
-  replay and accumulates work when another replay batch is discovered. Squash
-  sources advance separately while their combined commit is signed once. Fast
-  operations and command-line `tix rebase apply` and `tix travel` do not show
-  progress.
+  terminal can remain renderable without cloning the cached history graph.
+  Todo application shows its modal gauge after 300 ms. During TUI time travel,
+  the history selection instead follows each pending commit after it is rebased.
+  The first and latest rows are drawn even for fast multi-commit operations;
+  intermediate rows may be coalesced to keep drawing at or below 60 fps.
+  Command-line `tix rebase apply` and `tix travel` do not animate.
 - Displayed mutable refs follow their explicit locations in the edited todo;
   omission deletes them and newly named refs require nonexistence. Refs checked
   out by linked worktrees are displayed normally and may move, with their index
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 2137e8a1ef0..748128717d5 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -37,6 +37,8 @@ enum Command {
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
     Split,
+    /// Save index and worktree changes at HEAD.
+    Stash,
     /// Pin one or more commits as persistent history tips.
     Pin(Pin),
     /// Travel to a commit while preserving reachable history through tix pins.
@@ -149,6 +151,16 @@ impl Platform {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 split(repository, &graph)?;
             }
+            Command::Stash => {
+                let id = repository
+                    .head_id()
+                    .context("stashing changes requires a born HEAD")?
+                    .detach();
+                println!(
+                    "{}",
+                    crate::edit::stash::save_manual(repository.git_dir(), repository.is_bare(), id)?
+                );
+            }
             Command::Pin(args) => pin(&repository, args)?,
             Command::Travel(args) => return travel::run(repository, args),
             Command::Reword(args) => return reword::run(repository, args),
@@ -509,6 +521,13 @@ mod tests {
                 .command,
             Some(Command::Split)
         ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "stash"])
+                .expect("stash parses")
+                .platform
+                .command,
+            Some(Command::Stash)
+        ));
         let pin = Cli::try_parse_from(["tix", "pin", "main", "HEAD~2"])
             .expect("one or more pin revisions parse")
             .platform
@@ -627,6 +646,7 @@ mod tests {
             &["amend"],
             &["spill"],
             &["split"],
+            &["stash"],
             &["pin"],
             &["travel"],
             &["reword"],
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index a547d2bdb85..7cac41a1c6e 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -427,13 +427,13 @@ pub(crate) fn perform(
     perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, |_| {})
 }
 
-pub(crate) fn perform_with_progress(
+pub(crate) fn perform_reporting_rebased(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
-    report: impl FnMut(Progress),
+    report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, report)
 }
@@ -462,7 +462,7 @@ pub(super) fn perform_deleting_refs(
 
 #[expect(
     clippy::too_many_arguments,
-    reason = "shared edit preparation plus progress reporting"
+    reason = "shared edit preparation plus rebased-commit reporting"
 )]
 fn perform_inner(
     repo: &gix::Repository,
@@ -472,7 +472,7 @@ fn perform_inner(
     tree_mode: Tree,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     reset_index_paths: Option<Vec<BString>>,
-    mut report: impl FnMut(Progress),
+    mut report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     let mut repo = repo.clone();
     let repeat_checkout = match &edit {
@@ -507,11 +507,6 @@ fn perform_inner(
             .context("the edited commit is not in the loaded history")?,
         None => Vec::new(),
     };
-    let mut progress = Progress {
-        total: affected.len(),
-        ..Progress::default()
-    };
-    report(progress);
     validate(&repo, graph, &affected, removed, repeat, tree_mode)?;
 
     let signing = repo
@@ -603,7 +598,6 @@ fn perform_inner(
         } else {
             tree_mode
         };
-        let cherry_pick_started = (commit_tree_mode == Tree::CherryPick).then(Instant::now);
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
@@ -623,10 +617,6 @@ fn perform_inner(
                 ours
             }
         };
-        if let Some(started) = cherry_pick_started.filter(|_| new_conflict.is_none()) {
-            progress.cherry_picked += 1;
-            progress.cherry_pick_time += started.elapsed();
-        }
         commit.parents = new_parents.into_iter().collect();
         let pending = commit_tree_mode == Tree::LeaveAsIsAndMark
             || (commit_tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
@@ -647,14 +637,8 @@ fn perform_inner(
         } else {
             CommitState::Unmarked(signature)
         };
-        let (new_id, signing_time) =
-            write_commit_timed(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
-        if let Some(elapsed) = signing_time {
-            progress.signed += 1;
-            progress.signing_time += elapsed;
-        }
-        progress.processed += 1;
-        report(progress);
+        let new_id = write_commit(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
+        report(old_id);
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 960d421c541..2d298cdf09b 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     ffi::OsString,
     fmt::Write as _,
     path::{Path, PathBuf},
@@ -304,7 +305,7 @@ pub(crate) fn perform(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Perform> {
-    perform_with_progress(
+    perform_reporting_rebased(
         repository_path,
         bare,
         selected,
@@ -317,8 +318,11 @@ pub(crate) fn perform(
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %selected))]
-#[expect(clippy::too_many_arguments, reason = "time travel context plus progress reporting")]
-pub(crate) fn perform_with_progress(
+#[expect(
+    clippy::too_many_arguments,
+    reason = "time travel context plus rebased-commit reporting"
+)]
+pub(crate) fn perform_reporting_rebased(
     repository_path: &Path,
     bare: bool,
     mut selected: ObjectId,
@@ -326,7 +330,7 @@ pub(crate) fn perform_with_progress(
     review_roots: &[ObjectId],
     revisions: &[OsString],
     include_worktrees: bool,
-    mut report: impl FnMut(super::rebase::Progress),
+    mut report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository for time-travel")?;
@@ -347,12 +351,11 @@ pub(crate) fn perform_with_progress(
         anyhow::bail!("cannot time-travel with unresolved index conflicts");
     }
     let mut completed_graph = None;
-    let mut completed_progress = super::rebase::Progress::default();
+    let mut original_ids = HashMap::new();
     let mut review_roots = review_roots.to_vec();
     while let Some(base) = pending_base(&repository, selected)? {
-        let previous = completed_progress;
-        let mut latest = previous;
-        let outcome = super::rebase::perform_with_progress(
+        let mut rebased = Vec::new();
+        let outcome = super::rebase::perform_reporting_rebased(
             &repository,
             completed_graph.as_ref().unwrap_or(graph),
             super::rebase::Edit::Repeat {
@@ -361,12 +364,12 @@ pub(crate) fn perform_with_progress(
             },
             super::rebase::Signature::RedoIfNeeded,
             super::rebase::Tree::CherryPick,
-            |progress| {
-                latest = append_progress(previous, progress);
-                report(latest);
+            |id| {
+                let original = original_ids.get(&id).copied().unwrap_or(id);
+                rebased.push((id, original));
+                report(original);
             },
         )?;
-        completed_progress = latest;
         let outcome = match outcome {
             super::rebase::Perform::Complete(outcome) => outcome,
             super::rebase::Perform::Conflict(rebase) => {
@@ -379,6 +382,11 @@ pub(crate) fn perform_with_progress(
                 }));
             }
         };
+        for (old, original) in rebased {
+            if let Some(new) = outcome.map(old) {
+                original_ids.insert(new, original);
+            }
+        }
         selected = outcome
             .map(selected)
             .context("the time-travel destination disappeared while completing its rebase")?;
@@ -454,17 +462,6 @@ pub(crate) fn perform_with_progress(
     Ok(Perform::Complete(notice))
 }
 
-fn append_progress(previous: super::rebase::Progress, batch: super::rebase::Progress) -> super::rebase::Progress {
-    super::rebase::Progress {
-        total: previous.processed + batch.total,
-        processed: previous.processed + batch.processed,
-        cherry_picked: previous.cherry_picked + batch.cherry_picked,
-        signed: previous.signed + batch.signed,
-        cherry_pick_time: previous.cherry_pick_time + batch.cherry_pick_time,
-        signing_time: previous.signing_time + batch.signing_time,
-    }
-}
-
 #[derive(Clone, Debug, Eq, PartialEq)]
 struct ReviewTree {
     root: ObjectId,
@@ -866,35 +863,6 @@ mod tests {
 
     use super::*;
 
-    #[test]
-    fn progress_accumulates_when_travel_discovers_another_replay_batch() {
-        let previous = super::super::rebase::Progress {
-            total: 2,
-            processed: 2,
-            cherry_picked: 1,
-            signed: 1,
-            cherry_pick_time: std::time::Duration::from_millis(3),
-            signing_time: std::time::Duration::from_millis(5),
-        };
-        let progress = append_progress(
-            previous,
-            super::super::rebase::Progress {
-                total: 3,
-                processed: 1,
-                cherry_picked: 1,
-                signed: 1,
-                cherry_pick_time: std::time::Duration::from_millis(7),
-                signing_time: std::time::Duration::from_millis(11),
-            },
-        );
-        assert_eq!(progress.total, 5);
-        assert_eq!(progress.processed, 3);
-        assert_eq!(progress.cherry_picked, 2);
-        assert_eq!(progress.signed, 2);
-        assert_eq!(progress.cherry_pick_time, std::time::Duration::from_millis(10));
-        assert_eq!(progress.signing_time, std::time::Duration::from_millis(16));
-    }
-
     fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
         let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
         if !output.status.success() {
@@ -1685,31 +1653,16 @@ mod tests {
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
 
-        let mut middle_progress = Vec::new();
-        perform_with_progress(
-            &repository_path,
-            false,
-            pending_middle,
-            &graph,
-            &[],
-            &[],
-            false,
-            |progress| middle_progress.push(progress),
-        )?
+        let mut rebased = Vec::new();
+        perform_reporting_rebased(&repository_path, false, pending_middle, &graph, &[], &[], false, |id| {
+            rebased.push(id);
+        })?
         .complete()?;
-        let progress = middle_progress.last().context("time-travel progress is reported")?;
-        assert_eq!(
-            progress.total, 2,
-            "the selected commit and its pending descendant are processed"
-        );
-        assert_eq!(progress.processed, 2);
         assert_eq!(
-            progress.cherry_picked, 1,
-            "only the selected ancestry is replayed eagerly"
+            rebased,
+            [pending_middle, pending_tip],
+            "the selected commit and its pending descendant are reported in replay order"
         );
-        assert_eq!(progress.signed, 1, "the selected commit is signed");
-        assert!(progress.cherry_pick_time > std::time::Duration::ZERO);
-        assert!(progress.signing_time > std::time::Duration::ZERO);
 
         let repository = open()?;
         let materialized_middle = repository.head_id()?.detach();
@@ -1740,8 +1693,8 @@ mod tests {
         let graph = super::super::loaded_graph(&repository)?;
         drop(repository);
 
-        let mut tip_progress = Vec::new();
-        perform_with_progress(
+        let mut rebased = Vec::new();
+        perform_reporting_rebased(
             &repository_path,
             false,
             still_pending_tip,
@@ -1749,12 +1702,10 @@ mod tests {
             &[],
             &[],
             false,
-            |progress| tip_progress.push(progress),
+            |id| rebased.push(id),
         )?
         .complete()?;
-        let progress = tip_progress.last().context("tip time-travel progress is reported")?;
-        assert_eq!((progress.total, progress.processed), (1, 1));
-        assert_eq!((progress.cherry_picked, progress.signed), (1, 1));
+        assert_eq!(rebased, [still_pending_tip]);
         let repository = open()?;
         let tip_commit = repository.find_commit(repository.head_id()?)?;
         assert!(!super::super::rebase::is_pending(&tip_commit.decode()?.into_owned()?));
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index acccf6b2082..94bb05ac7ea 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -57,7 +57,7 @@ use ratatui::{backend::CrosstermBackend, text::Line};
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
 const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
-const REBASE_PROGRESS_DELAY: Duration = Duration::from_millis(300);
+const TODO_PROGRESS_DELAY: Duration = Duration::from_millis(300);
 const HISTORY_STATUS_DELAY: Duration = Duration::from_millis(500);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
 const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
@@ -2553,18 +2553,43 @@ fn event_loop(
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            run_with_rebase_progress(terminal, |report| {
-                                edit::time_travel::perform_with_progress(
-                                    &repository_path,
-                                    repository_is_bare,
-                                    id,
-                                    graph,
-                                    &review_roots,
-                                    &revisions,
-                                    false,
-                                    report,
-                                )
-                            })
+                            run_with_rebase_selection(
+                                |report| {
+                                    edit::time_travel::perform_reporting_rebased(
+                                        &repository_path,
+                                        repository_is_bare,
+                                        id,
+                                        graph,
+                                        &review_roots,
+                                        &revisions,
+                                        false,
+                                        report,
+                                    )
+                                },
+                                |id| {
+                                    app.select_commit(id);
+                                    let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
+                                    let tree = tree_changes.as_ref().map(|(_, changes)| changes);
+                                    let worktree = worktree_changes
+                                        .as_ref()
+                                        .filter(|(marker, _)| *marker != usize::MAX)
+                                        .map(|(_, changes)| changes);
+                                    terminal
+                                        .draw(|frame| {
+                                            ui::draw_with_worktree(
+                                                frame,
+                                                &mut app,
+                                                &decorations,
+                                                &mailmap,
+                                                message,
+                                                tree,
+                                                worktree,
+                                            );
+                                        })
+                                        .context("could not draw time-travel animation")?;
+                                    Ok(())
+                                },
+                            )
                         });
                     match result {
                         Ok(edit::time_travel::Perform::Complete(Some(notice))) => {
@@ -3834,20 +3859,94 @@ enum RebaseWorkerEvent<T> {
     Complete(Result<T>),
 }
 
+enum TravelWorkerEvent<T> {
+    Rebased(gix::ObjectId),
+    Complete(Result<T>),
+}
+
+fn run_with_rebase_selection<T: Send>(
+    operation: impl FnOnce(&mut dyn FnMut(gix::ObjectId)) -> Result<T> + Send,
+    mut render: impl FnMut(gix::ObjectId) -> Result<()>,
+) -> Result<T> {
+    std::thread::scope(|scope| {
+        let (sender, receiver) = mpsc::channel();
+        let worker = scope.spawn(move || {
+            let mut report = |id| {
+                let _ = sender.send(TravelWorkerEvent::Rebased(id));
+            };
+            let result = operation(&mut report);
+            let _ = sender.send(TravelWorkerEvent::Complete(result));
+        });
+        let mut last_draw: Option<Instant> = None;
+        let mut latest = None;
+        let mut rendered = None;
+        let mut complete = None;
+        let result = loop {
+            let event = if complete.is_some() {
+                None
+            } else if latest != rendered
+                && let Some(last_draw) = last_draw
+            {
+                match receiver.recv_timeout(FRAME_INTERVAL.saturating_sub(last_draw.elapsed())) {
+                    Ok(event) => Some(event),
+                    Err(mpsc::RecvTimeoutError::Timeout) => None,
+                    Err(mpsc::RecvTimeoutError::Disconnected) => {
+                        break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly"));
+                    }
+                }
+            } else {
+                match receiver.recv() {
+                    Ok(event) => Some(event),
+                    Err(_) => break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly")),
+                }
+            };
+            match event {
+                Some(TravelWorkerEvent::Rebased(id)) => latest = Some(id),
+                Some(TravelWorkerEvent::Complete(result)) => complete = Some(result),
+                None => {}
+            }
+            if latest != rendered
+                && (last_draw.is_none()
+                    || last_draw.is_some_and(|last_draw| last_draw.elapsed() >= FRAME_INTERVAL)
+                    || complete.is_some())
+            {
+                if complete.is_some()
+                    && let Some(last_draw) = last_draw
+                {
+                    std::thread::sleep(FRAME_INTERVAL.saturating_sub(last_draw.elapsed()));
+                }
+                let id = latest.expect("a changed rebased commit is available");
+                if let Err(err) = render(id) {
+                    break Err(err);
+                }
+                rendered = latest;
+                last_draw = Some(Instant::now());
+            }
+            if let Some(result) = complete.take() {
+                break result;
+            }
+        };
+        if worker.join().is_err() {
+            return Err(anyhow::anyhow!("time-travel worker panicked"));
+        }
+        result
+    })
+}
+
 fn run_rebase_plan(
     terminal: &mut ratatui::DefaultTerminal,
     repository: gix::ThreadSafeRepository,
     graph: &HistoryGraph,
     plan: edit::rebase::Plan,
 ) -> Result<edit::rebase::PlanPerform> {
-    run_with_rebase_progress(terminal, move |report| {
+    run_with_todo_progress(terminal, move |report| {
         let mut repository = repository.to_thread_local();
         repository.object_cache_size(None);
         edit::rebase::perform_plan_with_progress(&repository, graph, plan, report)
     })
 }
 
-fn run_with_rebase_progress<T: Send>(
+fn run_with_todo_progress<T: Send>(
     terminal: &mut ratatui::DefaultTerminal,
     operation: impl FnOnce(&mut dyn FnMut(edit::rebase::Progress)) -> Result<T> + Send,
 ) -> Result<T> {
@@ -3866,8 +3965,8 @@ fn run_with_rebase_progress<T: Send>(
         let mut rendered = None;
         let result = loop {
             let now = Instant::now();
-            let timeout = if now.duration_since(started) < REBASE_PROGRESS_DELAY {
-                Some(REBASE_PROGRESS_DELAY.saturating_sub(now.duration_since(started)))
+            let timeout = if now.duration_since(started) < TODO_PROGRESS_DELAY {
+                Some(TODO_PROGRESS_DELAY.saturating_sub(now.duration_since(started)))
             } else if latest != rendered {
                 Some(FRAME_INTERVAL.saturating_sub(now.duration_since(last_draw)))
             } else {
@@ -3892,12 +3991,12 @@ fn run_with_rebase_progress<T: Send>(
                 None => {}
             }
             let now = Instant::now();
-            if rebase_progress_visible(now.duration_since(started))
+            if todo_progress_visible(now.duration_since(started))
                 && latest != rendered
                 && now.duration_since(last_draw) >= FRAME_INTERVAL
             {
                 let progress = latest.expect("a changed progress snapshot is available");
-                if let Err(err) = terminal.draw(|frame| ui::draw_rebase_progress(frame, progress)) {
+                if let Err(err) = terminal.draw(|frame| ui::draw_todo_progress(frame, progress)) {
                     break Err(err).context("could not draw rebase progress");
                 }
                 rendered = latest;
@@ -3911,8 +4010,8 @@ fn run_with_rebase_progress<T: Send>(
     })
 }
 
-fn rebase_progress_visible(elapsed: Duration) -> bool {
-    elapsed >= REBASE_PROGRESS_DELAY
+fn todo_progress_visible(elapsed: Duration) -> bool {
+    elapsed >= TODO_PROGRESS_DELAY
 }
 
 #[derive(Clone, Copy)]
@@ -6503,9 +6602,61 @@ mod tests {
     }
 
     #[test]
-    fn rebase_progress_appears_at_three_hundred_milliseconds() {
-        assert!(!rebase_progress_visible(Duration::from_millis(299)));
-        assert!(rebase_progress_visible(REBASE_PROGRESS_DELAY));
+    fn todo_progress_appears_at_three_hundred_milliseconds() {
+        assert!(!todo_progress_visible(Duration::from_millis(299)));
+        assert!(todo_progress_visible(TODO_PROGRESS_DELAY));
+    }
+
+    #[test]
+    fn fast_time_travel_draws_the_first_and_latest_rebased_commits() -> Result<()> {
+        let ids = [
+            gix::ObjectId::Sha1([1; 20]),
+            gix::ObjectId::Sha1([2; 20]),
+            gix::ObjectId::Sha1([3; 20]),
+        ];
+        let mut rendered = Vec::new();
+
+        run_with_rebase_selection(
+            |report| {
+                for id in ids {
+                    report(id);
+                }
+                Ok(())
+            },
+            |id| {
+                rendered.push(id);
+                Ok(())
+            },
+        )?;
+
+        assert_eq!(rendered, [ids[0], ids[2]], "fast intermediate commits are coalesced");
+        Ok(())
+    }
+
+    #[test]
+    fn slow_time_travel_only_draws_rebased_selections() -> Result<()> {
+        let ids = [gix::ObjectId::Sha1([1; 20]), gix::ObjectId::Sha1([2; 20])];
+        let mut rendered = Vec::new();
+
+        run_with_rebase_selection(
+            |report| {
+                for id in ids {
+                    report(id);
+                    std::thread::sleep(FRAME_INTERVAL * 2);
+                }
+                Ok(())
+            },
+            |id| {
+                rendered.push(id);
+                Ok(())
+            },
+        )?;
+
+        assert_eq!(
+            rendered, ids,
+            "slow travel has no rendering mode besides selection frames"
+        );
+        Ok(())
     }
 
     #[test]
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7319c2026a0..b46ae645870 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -84,7 +84,7 @@ pub(crate) fn render_notice(frame: &mut Frame<'_>, area: Rect, notice: &Notice)
     );
 }
 
-pub(crate) fn draw_rebase_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::Progress) {
+pub(crate) fn draw_todo_progress(frame: &mut Frame<'_>, progress: crate::edit::rebase::Progress) {
     let area = frame.area();
     frame.render_widget(Clear, area);
     let width = area.width.min(72);
@@ -569,7 +569,6 @@ pub(crate) fn draw_with_worktree(
             HistoryAlignment::Columns => (metadata.align_columns(column_widths), max_lane_width),
         })
         .collect();
-    let graph_max_offset = max_lane_width.saturating_sub(content.width as usize);
     let max_offset = match alignment {
         HistoryAlignment::None => lanes
             .iter()
@@ -578,8 +577,7 @@ pub(crate) fn draw_with_worktree(
             .max()
             .unwrap_or_default()
             .saturating_sub(content.width as usize),
-        HistoryAlignment::Title => graph_max_offset,
-        HistoryAlignment::Columns => metadata
+        HistoryAlignment::Title | HistoryAlignment::Columns => metadata
             .iter()
             .map(|(metadata, metadata_x)| metadata_x.saturating_add(metadata.width()))
             .max()
@@ -588,11 +586,6 @@ pub(crate) fn draw_with_worktree(
     }
     .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
-    let graph_offset = if alignment == HistoryAlignment::Title {
-        horizontal_offset.min(graph_max_offset)
-    } else {
-        horizontal_offset
-    };
     let selection_info = selection_info_line(
         app.changes_visible()
             .then_some(tree_changes)
@@ -636,8 +629,7 @@ pub(crate) fn draw_with_worktree(
                 .count()
                 .saturating_add(metadata_width)
                 .saturating_sub(horizontal_offset),
-            HistoryAlignment::Title => metadata_x.saturating_add(metadata_width),
-            HistoryAlignment::Columns => metadata_x
+            HistoryAlignment::Title | HistoryAlignment::Columns => metadata_x
                 .saturating_add(metadata_width)
                 .saturating_sub(horizontal_offset),
         };
@@ -703,51 +695,25 @@ pub(crate) fn draw_with_worktree(
         );
 
         let row_area = Rect::new(content.x, y, content.width, 1);
-        if alignment == HistoryAlignment::Title {
-            frame.render_widget(
-                Paragraph::new(lane).style(style).scroll((0, graph_offset as u16)),
-                row_area,
-            );
-            color_graph(
-                frame,
-                row_area,
-                lane,
-                graph_offset,
-                highlight,
-                visible_rows[index].signature,
-                head_state,
-            );
-            let aligned = Rect::new(
-                content.x.saturating_add(u16::try_from(metadata_x).unwrap_or(u16::MAX)),
-                y,
-                content
-                    .width
-                    .saturating_sub(u16::try_from(metadata_x).unwrap_or(u16::MAX)),
-                1,
-            );
-            frame.render_widget(Clear, aligned);
-            frame.render_widget(Paragraph::new(metadata), aligned);
-        } else {
-            let mut spans = Vec::with_capacity(metadata.spans.len() + 2);
-            spans.push(Span::styled(lane, style));
-            if alignment == HistoryAlignment::Columns {
-                spans.push(Span::raw(" ".repeat(metadata_x.saturating_sub(lane.chars().count()))));
-            }
-            spans.extend(metadata.spans);
-            frame.render_widget(
-                Paragraph::new(Line::from(spans)).scroll((0, horizontal_offset as u16)),
-                row_area,
-            );
-            color_graph(
-                frame,
-                row_area,
-                lane,
-                horizontal_offset,
-                highlight,
-                visible_rows[index].signature,
-                head_state,
-            );
+        let mut spans = Vec::with_capacity(metadata.spans.len() + 2);
+        spans.push(Span::styled(lane, style));
+        if alignment != HistoryAlignment::None {
+            spans.push(Span::raw(" ".repeat(metadata_x.saturating_sub(lane.chars().count()))));
         }
+        spans.extend(metadata.spans);
+        frame.render_widget(
+            Paragraph::new(Line::from(spans)).scroll((0, horizontal_offset as u16)),
+            row_area,
+        );
+        color_graph(
+            frame,
+            row_area,
+            lane,
+            horizontal_offset,
+            highlight,
+            visible_rows[index].signature,
+            head_state,
+        );
         if selected && app.show_selection_tail && body.width > 0 {
             let marker_limit = hidden_branch_marker
                 .as_ref()
@@ -2495,10 +2461,10 @@ mod tests {
     }
 
     #[test]
-    fn renders_rebase_progress_with_operation_counts_and_times() -> Result<(), Box<dyn std::error::Error>> {
+    fn renders_todo_progress_with_operation_counts_and_times() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
         terminal.draw(|frame| {
-            draw_rebase_progress(
+            draw_todo_progress(
                 frame,
                 crate::edit::rebase::Progress {
                     total: 100,
@@ -6156,6 +6122,19 @@ mod tests {
             "title mode leaves earlier fields at natural positions"
         );
 
+        let mut narrow_title = Terminal::new(TestBackend::new(40, 3))?;
+        narrow_title.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let before = rendered_line(&narrow_title, 0);
+        app.update(Action::ScrollRight);
+        assert!(
+            app.horizontal_offset > 0,
+            "title-aligned rows expose their clipped width"
+        );
+        narrow_title.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert_ne!(rendered_line(&narrow_title, 0), before, "l pans the title-aligned row");
+        app.update(Action::ScrollLeft);
+        assert_eq!(app.horizontal_offset, 0, "h returns to the title-aligned row start");
+
         app.update(Action::ToggleAlign);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let first = rendered_line(&terminal, 0);

From 3e7d737bea0e6b2617db95e6551cc82fde3e99d1 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 19:23:47 +0200
Subject: [PATCH 194/282] feat: edit tix enrichments with commit messages

---
 gix-tix/spec.md               |  13 ++-
 gix-tix/src/command/reword.rs |  28 +++++-
 gix-tix/src/edit/create.rs    |  92 +++++++++++++----
 gix-tix/src/edit/reword.rs    | 182 +++++++++++++++++++++++++++++++---
 gix-tix/src/edit/split.rs     |  27 ++++-
 gix-tix/src/enrich.rs         |  99 ++++++++++++++++++
 gix-tix/src/lib.rs            |  17 +++-
 7 files changed, 409 insertions(+), 49 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 788bc78588c..68a3c758bd3 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -42,7 +42,12 @@ without trading responsiveness for metadata that is not visible.
   current-worktree tix pin at that commit or a descendant;
   every such covering pin participates so retained forks are rewritten together.
   Eligibility is checked before the editor opens, and an unchanged document is
-  an explicit no-op.
+  an explicit no-op. Editor documents also contain commented `Todo` and
+  `Message:` enrichment headers. An uncommented bare `Todo` enables the flag;
+  commenting or deleting it disables the flag. `Message:` accepts one title
+  line. Editing that title preserves an existing message body byte-for-byte,
+  while commenting, deleting, or emptying the header removes the whole message.
+  Explicit `-m` and `-f` messages preserve enrichments.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
@@ -604,8 +609,8 @@ space first; changes blocks adapt within the remaining history width.
   boundary or merge commit. It requires completed history and a live,
   conflict-free worktree, but unlike `e n` it is not restricted by descendants
   because it rewrites none of them. It is unavailable for unborn history.
-- Fork preparation reuses the new-commit editor, candidate-tree, identity, and
-  signing rules. Saving writes only the new commit and a temporary direct
+- Fork preparation reuses the new-commit editor, candidate-tree, identity,
+  signing, and enrichment-header rules. Saving writes only the new commit and a temporary direct
   `refs/worktree/tix/pins/*` ref; existing refs, descendants, indexes, and
   worktrees do not move during creation.
 - Tix immediately time-travels to the new fork. A successful checkout consumes
@@ -644,7 +649,7 @@ space first; changes blocks adapt within the remaining history width.
 - `tix split` performs the same split at `HEAD`: worktree changes are amended
   into the source commit and staged index changes become the new commit on top.
   Its upper-commit editor offers the same commented WIP author override as the
-  new-commit editor.
+  new-commit editor, including its enrichment headers.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Their final trees and ancestry
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index e6f6cff63a6..f7ccf4ec3aa 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -88,7 +88,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    finish(crate::edit::reword::apply(repository, &graph, target, &edited)?)
+    finish_editor(crate::edit::reword::apply(repository, &graph, target, &edited)?, target)
 }
 
 fn explicit_message(args: &Args, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
@@ -129,6 +129,15 @@ fn finish(outcome: Option<gix::ObjectId>) -> Result<()> {
     Ok(())
 }
 
+fn finish_editor(outcome: crate::edit::reword::Outcome, original: gix::ObjectId) -> Result<()> {
+    match (outcome.commit, outcome.enrichment) {
+        (Some(id), _) => println!("{}", id.to_hex_with_len(7)),
+        (None, Some(_)) => println!("{}", original.to_hex_with_len(7)),
+        (None, None) => println!("no reword performed: the edited commit was unchanged"),
+    }
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command};
@@ -195,6 +204,10 @@ mod tests {
     #[test]
     fn message_bypasses_the_editor_and_rewords_head() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let original = repository.head_id()?.detach();
+        crate::enrich::toggle(&repository, original)?;
+        crate::enrich::set_note(&repository, original, Some(b"kept\n\nbody"))?;
         let mut initial = args("HEAD");
         initial.message = vec!["replacement title".into(), ";literal body".into()];
         initial.author = Some("Agent <agent@example.com>".into());
@@ -210,6 +223,19 @@ mod tests {
             b"Agent <agent@example.com>\n",
             "an explicit message applies the author without opening an editor"
         );
+        let repository = crate::test_repository::open(fixture.path())?;
+        let head = repository.head_id()?.detach();
+        assert_eq!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, head)?
+            )?,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("kept\n\nbody".into()),
+            },
+            "explicit messages preserve enrichments"
+        );
         let rewritten = git(fixture.path(), &["rev-parse", "HEAD"])?;
         let mut same = args("HEAD");
         same.message = vec!["replacement title\n\n;literal body".into()];
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 2a0ae88cba4..18552d973fd 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -99,7 +99,13 @@ fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: boo
     )?;
     let line_counts = add_line_counts(&repo, &mut changes)?;
     let mut document = Vec::new();
-    reword::write_headers(&mut document, &author, &committer, Some(reword::WIP_AUTHOR))?;
+    reword::write_headers(
+        &mut document,
+        &author,
+        &committer,
+        Some(reword::WIP_AUTHOR),
+        &crate::enrich::Enrichment::default(),
+    )?;
     document.extend_from_slice(b"\nwhat\n\nwhy\n");
     for trailer in reword::missing_agent_trailers(b"what\n\nwhy\n").into_iter().flatten() {
         document.extend_from_slice(b"\n;");
@@ -242,9 +248,11 @@ pub(crate) fn apply(
     mut prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
+    let repository_path = repo.git_dir().to_owned();
+    let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let commit = commit_from_edit(&prepared, edited)?;
-    rebase::perform(
+    let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
+    let id = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Insert {
@@ -257,7 +265,11 @@ pub(crate) fn apply(
     )?
     .complete()?
     .selected
-    .context("inserting a commit did not produce a selection")
+    .context("inserting a commit did not produce a selection")?;
+    drop(repo);
+    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+        .context("the commit was created, but its enrichment could not be saved")?;
+    Ok(id)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
@@ -267,10 +279,12 @@ pub(crate) fn apply_fork(
     mut prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
+    let repository_path = repo.git_dir().to_owned();
+    let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
     let parent = prepared.parent.context("a fork commit requires a parent")?;
-    let commit = commit_from_edit(&prepared, edited)?;
-    rebase::perform(
+    let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
+    let id = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Fork { anchor: parent, commit },
@@ -279,23 +293,33 @@ pub(crate) fn apply_fork(
     )?
     .complete()?
     .selected
-    .context("forking a commit did not produce a selection")
+    .context("forking a commit did not produce a selection")?;
+    drop(repo);
+    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+        .context("the fork was created, but its enrichment could not be saved")?;
+    Ok(id)
 }
 
-pub(super) fn commit_from_edit(prepared: &Prepared, edited: &[u8]) -> Result<gix::objs::Commit> {
+pub(super) fn commit_from_edit(
+    prepared: &Prepared,
+    edited: &[u8],
+) -> Result<(gix::objs::Commit, crate::enrich::Headers)> {
     let edit = reword::parse(edited)?;
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
     }
-    Ok(gix::objs::Commit {
-        message: edit.message,
-        tree: prepared.tree,
-        author: reword::actor(edit.author, edit.author_time, "author")?,
-        committer: reword::actor(edit.committer, edit.committer_time, "committer")?,
-        encoding: None,
-        parents: prepared.parent.into_iter().collect(),
-        extra_headers: Vec::new(),
-    })
+    Ok((
+        gix::objs::Commit {
+            message: edit.message,
+            tree: prepared.tree,
+            author: reword::actor(edit.author, edit.author_time, "author")?,
+            committer: reword::actor(edit.committer, edit.committer_time, "committer")?,
+            encoding: None,
+            parents: prepared.parent.into_iter().collect(),
+            extra_headers: Vec::new(),
+        },
+        edit.enrichment,
+    ))
 }
 
 #[cfg(test)]
@@ -373,7 +397,10 @@ mod tests {
             "a ref may appear while the editor is open"
         );
 
-        let edited = prepared.document.replacen(b"what\n\nwhy", b"title\n\nbody", 1);
+        let edited = prepared
+            .document
+            .replacen(b"what\n\nwhy", b"title\n\nbody", 1)
+            .replacen(b";Todo\n;Message:", b"Todo\nMessage: created enrichment", 1);
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
         let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let after = gix_testtools::repository::snapshot(fixture.path())?;
@@ -387,6 +414,16 @@ mod tests {
         );
         let repository = open(fixture.path())?;
         let commit = repository.find_commit(new_id)?;
+        assert_eq!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, new_id)?
+            )?,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("created enrichment".into()),
+            }
+        );
         assert_eq!(commit.parent_ids().next().map(gix::Id::detach), Some(parent));
         assert_eq!(commit.message_raw()?, b"title\n\nbody\n".as_bstr());
         assert_eq!(
@@ -401,8 +438,8 @@ mod tests {
         );
         assert_eq!(
             after.commits.len(),
-            before.commits.len() + 1,
-            "exactly one reachable commit is added"
+            before.commits.len() + 2,
+            "the history commit and its enrichment note commit are added"
         );
         for name in ["refs/heads/main", "refs/patches/create", "refs/patches/late"] {
             assert_eq!(
@@ -466,11 +503,24 @@ mod tests {
         let parent = main;
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let prepared = prepare(open(fixture.path())?, Some(parent))?;
-        let edited = prepared.document.replacen(b"what\n\nwhy", b"fork\n\nreason", 1);
+        let edited = prepared
+            .document
+            .replacen(b"what\n\nwhy", b"fork\n\nreason", 1)
+            .replacen(b";Todo\n;Message:", b"Todo\nMessage: fork enrichment", 1);
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
         let fork = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
 
         let repository = open(fixture.path())?;
+        assert_eq!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, fork)?
+            )?,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("fork enrichment".into()),
+            }
+        );
         assert_eq!(repository.head_id()?.detach(), main, "forking does not move HEAD");
         assert_eq!(
             repository.find_reference("refs/heads/main")?.id().detach(),
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index ddf7bb945eb..30b99339631 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -8,6 +8,8 @@ const AUTHOR_DATE: &[u8] = b"AuthorDate: ";
 const COMMITTER: &[u8] = b"Committer: ";
 const COMMITTER_DATE: &[u8] = b"CommitterDate: ";
 const COMMENT_CHAR: &[u8] = b"CommentChar: ";
+const MESSAGE: &[u8] = b"Message:";
+const TODO: &[u8] = b"Todo";
 pub(super) const DEFAULT_COMMENT_CHAR: &[u8] = b";";
 pub(super) const WIP_AUTHOR: &[u8] = b"\xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>";
 pub(super) const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
@@ -19,6 +21,12 @@ pub(super) struct Edit<'a> {
     pub committer: &'a [u8],
     pub committer_time: gix::date::Time,
     pub message: BString,
+    pub enrichment: crate::enrich::Headers,
+}
+
+pub(crate) struct Outcome {
+    pub commit: Option<gix::ObjectId>,
+    pub enrichment: Option<crate::enrich::Enrichment>,
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -48,9 +56,10 @@ pub(crate) fn document_with_author(
         .context("could not resolve the Git committer")?
         .to_owned()
         .context("could not own the Git committer")?;
+    let enrichment = crate::enrich::load(&mut crate::enrich::open(repo)?, crate::change_id::for_commit(repo, id)?)?;
 
     let mut out = Vec::new();
-    write_headers(&mut out, &commit.author, &committer, None)?;
+    write_headers(&mut out, &commit.author, &committer, None, &enrichment)?;
     out.push(b'\n');
     out.extend_from_slice(&commit.message);
     if !out.ends_with(b"\n") {
@@ -91,7 +100,7 @@ pub(crate) fn apply(
     graph: &crate::history::HistoryGraph,
     old_id: gix::ObjectId,
     edited: &[u8],
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<Outcome> {
     let edit = parse(edited)?;
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
@@ -104,10 +113,18 @@ pub(crate) fn apply(
         .context("could not decode commit after editing")?
         .into_owned()
         .context("could not own commit after editing")?;
-    commit.author = actor(edit.author, edit.author_time, "author")?;
-    commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
-    commit.message = edit.message;
-    apply_commit(&repo, graph, old_id, commit)
+    let author = actor(edit.author, edit.author_time, "author")?;
+    let commit_changed = author != commit.author || edit.message != commit.message;
+    let commit = if commit_changed {
+        commit.author = author;
+        commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
+        commit.message = edit.message;
+        apply_commit(&repo, graph, old_id, commit)?
+    } else {
+        None
+    };
+    let enrichment = crate::enrich::apply_headers(&repo, commit.unwrap_or(old_id), &edit.enrichment)?;
+    Ok(Outcome { commit, enrichment })
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %old_id))]
@@ -164,6 +181,7 @@ pub(super) fn write_headers(
     author: &gix::actor::Signature,
     committer: &gix::actor::Signature,
     alternative_author: Option<&[u8]>,
+    enrichment: &crate::enrich::Enrichment,
 ) -> Result<()> {
     write_actor(out, AUTHOR, author);
     if let Some(alternative_author) = alternative_author {
@@ -178,6 +196,20 @@ pub(super) fn write_headers(
     out.extend_from_slice(COMMENT_CHAR);
     out.extend_from_slice(DEFAULT_COMMENT_CHAR);
     out.push(b'\n');
+    if !enrichment.todo {
+        out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+    }
+    out.extend_from_slice(TODO);
+    out.push(b'\n');
+    if enrichment.note.is_none() {
+        out.extend_from_slice(DEFAULT_COMMENT_CHAR);
+    }
+    out.extend_from_slice(MESSAGE);
+    if let Some(note) = enrichment.note.as_deref() {
+        out.push(b' ');
+        out.extend_from_slice(gix::objs::commit::MessageRef::from_bytes(note).summary().as_ref());
+    }
+    out.push(b'\n');
     Ok(())
 }
 
@@ -211,7 +243,7 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
                     .strip_prefix(DEFAULT_COMMENT_CHAR)
                     .is_some_and(|line| line.starts_with(AUTHOR))
         });
-    let mut parts = input.splitn(7 + usize::from(has_alternative_author), |byte| *byte == b'\n');
+    let mut parts = input.splitn(6 + usize::from(has_alternative_author), |byte| *byte == b'\n');
     let mut author = header(parts.next(), AUTHOR)?;
     let mut line = parts.next();
     if line
@@ -231,11 +263,42 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
     if comment_char.contains(&b'\r') {
         anyhow::bail!("CommentChar must not contain a line ending");
     }
-    if parts.next().map(trim_cr) != Some(&[][..]) {
-        anyhow::bail!("expected an empty line after the commit headers");
+    let remainder = parts.next().context("the enrichment headers are missing")?;
+    let mut enrichment = crate::enrich::Headers::default();
+    let mut todo_seen = false;
+    let mut message_seen = false;
+    let mut message_offset = None;
+    let mut consumed = 0;
+    for line in remainder.lines_with_terminator() {
+        consumed += line.len();
+        let line = trim_cr(line.strip_suffix(b"\n").unwrap_or(line));
+        if line.is_empty() {
+            message_offset = Some(consumed);
+            break;
+        }
+        if line.starts_with(comment_char) {
+            continue;
+        }
+        if line == TODO {
+            if std::mem::replace(&mut todo_seen, true) {
+                anyhow::bail!("duplicate Todo header");
+            }
+            enrichment.todo = true;
+        } else if let Some(title) = line.strip_prefix(MESSAGE) {
+            if std::mem::replace(&mut message_seen, true) {
+                anyhow::bail!("duplicate Message header");
+            }
+            let title = title.trim();
+            enrichment.message = (!title.is_empty()).then(|| title.into());
+        } else {
+            anyhow::bail!("unknown commit header: {}", line.as_bstr());
+        }
     }
+    let message_offset = message_offset.context("expected an empty line after the commit headers")?;
     let message = cleanup_message(
-        parts.next().context("the commit message is missing")?,
+        remainder
+            .get(message_offset..)
+            .context("the commit message is missing")?,
         Some(comment_char),
     );
     Ok(Edit {
@@ -244,6 +307,7 @@ pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
         committer,
         committer_time,
         message,
+        enrichment,
     })
 }
 
@@ -387,9 +451,9 @@ mod tests {
         );
         assert!(
             document
-                .windows(b"CommentChar: ;\n\n".len())
-                .any(|line| line == b"CommentChar: ;\n\n"),
-            "the template declares its default comment prefix"
+                .windows(b"CommentChar: ;\n;Todo\n;Message:\n\n".len())
+                .any(|line| line == b"CommentChar: ;\n;Todo\n;Message:\n\n"),
+            "the template declares its comment prefix and inactive enrichments"
         );
         assert!(
             !document
@@ -403,6 +467,86 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn parses_bare_todo_and_single_line_message_headers() -> gix_testtools::Result {
+        let document = |headers: &str| {
+            format!(
+                "Author: A <a@example.com>\n\
+                 AuthorDate: 2026-08-12 10:20:30 +0200\n\
+                 Committer: C <c@example.com>\n\
+                 CommitterDate: 2026-08-12 11:20:30 +0200\n\
+                 CommentChar: ;\n{headers}\n\n\
+                 title\n"
+            )
+        };
+
+        let active_document = document("Todo\nMessage: enrichment title");
+        let edit = parse(active_document.as_bytes())?;
+        assert_eq!(
+            edit.enrichment,
+            crate::enrich::Headers {
+                todo: true,
+                message: Some("enrichment title".into()),
+            }
+        );
+        assert_eq!(
+            parse(document(";Todo\n;Message:").as_bytes())?.enrichment,
+            Default::default()
+        );
+        assert_eq!(parse(document("Message:").as_bytes())?.enrichment, Default::default());
+        assert!(
+            parse(document("Todo\nTodo").as_bytes()).is_err(),
+            "duplicate Todo is rejected"
+        );
+        assert!(
+            parse(document("Message: one\nMessage: two").as_bytes()).is_err(),
+            "duplicate Message is rejected"
+        );
+        assert!(
+            parse(document("Todo: true").as_bytes()).is_err(),
+            "Todo has no value syntax"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn enrichment_only_edits_do_not_rewrite_the_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = crate::test_repository::open_with(
+            fixture.path(),
+            [
+                "committer.name=Current Committer",
+                "committer.email=current@example.com",
+            ],
+        )?;
+        let id = repository.head_id()?.detach();
+        crate::enrich::toggle(&repository, id)?;
+        crate::enrich::set_note(&repository, id, Some(b"Existing title\n\nexisting body\n"))?;
+        let (_, document) = document(&repository, id)?;
+        assert!(
+            document
+                .windows(b"Todo\nMessage: Existing title\n\n".len())
+                .any(|window| { window == b"Todo\nMessage: Existing title\n\n" }),
+            "active enrichments are shown before the commit message"
+        );
+
+        let edited = document.replacen(b"Message: Existing title", b"Message: New title", 1);
+        let graph = super::super::loaded_graph(&repository)?;
+        let outcome = apply(repository.clone(), &graph, id, &edited)?;
+        assert!(
+            outcome.commit.is_none(),
+            "enrichment changes leave the commit object untouched"
+        );
+        assert_eq!(repository.head_id()?.detach(), id);
+        let enrichment = outcome.enrichment.expect("the enrichment changed");
+        assert!(enrichment.todo);
+        assert_eq!(
+            enrichment.note.as_ref().map(|note| note.as_bstr()),
+            Some(b"New title\n\nexisting body\n".as_bstr())
+        );
+        Ok(())
+    }
+
     #[test]
     fn offers_only_missing_agent_trailer_keys() {
         assert_eq!(
@@ -457,7 +601,9 @@ mod tests {
             )
             .replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
         let graph = super::super::loaded_graph(&repository)?;
-        let new_middle = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
+        let new_middle = apply(repository.clone(), &graph, middle, &edited)?
+            .commit
+            .expect("the message changed");
         let new_tip = repository.head_id()?.detach();
         let rewritten = repository.find_commit(new_middle)?.decode()?.into_owned()?;
         assert_eq!(rewritten.committer.name, b"Current Committer".as_bstr());
@@ -500,7 +646,9 @@ mod tests {
         let (_, document) = document(&repository, middle)?;
         let edited = document.replacen(b"\nmiddle\n", b"\nrewritten middle\n", 1);
         let graph = super::super::loaded_graph(&repository)?;
-        let rewritten = apply(repository.clone(), &graph, middle, &edited)?.expect("the message changed");
+        let rewritten = apply(repository.clone(), &graph, middle, &edited)?
+            .commit
+            .expect("the message changed");
         assert!(
             repository
                 .find_commit(rewritten)?
@@ -561,7 +709,9 @@ mod tests {
                        \n\
                        rewritten title\n\nrewritten body\n\nAssisted-by: GPT 5.6\n;Co-authored-by: GPT 5.6 <codex@openai.com>\n";
         let graph = super::super::loaded_graph(&repository)?;
-        let new_id = apply(repository.clone(), &graph, old_id, edited)?.expect("the edited commit differs");
+        let new_id = apply(repository.clone(), &graph, old_id, edited)?
+            .commit
+            .expect("the edited commit differs");
         let commit = repository.find_commit(new_id)?;
         let decoded = commit.decode()?;
         assert_eq!(
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 2ec28edf5ac..eb6171b9e17 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -73,11 +73,13 @@ pub(crate) fn apply(
     mut prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
+    let repository_path = repo.git_dir().to_owned();
+    let bare = repo.is_bare();
     repo.objects
         .set_object_memory(std::mem::take(&mut prepared.create.objects));
-    let mut upper = create::commit_from_edit(&prepared.create, edited)?;
+    let (mut upper, enrichment) = create::commit_from_edit(&prepared.create, edited)?;
     upper.tree = prepared.tree;
-    rebase::perform(
+    let id = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Split {
@@ -90,7 +92,11 @@ pub(crate) fn apply(
     )?
     .complete()?
     .selected
-    .context("splitting HEAD did not produce a selection")
+    .context("splitting HEAD did not produce a selection")?;
+    drop(repo);
+    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+        .context("the commit was split, but its enrichment could not be saved")?;
+    Ok(id)
 }
 
 #[cfg(test)]
@@ -154,10 +160,23 @@ mod tests {
             "preparing both cherry-picks leaves the repository unchanged"
         );
 
-        let edited = prepared.document.replacen(b"what\n\nwhy", b"upper\n\nreason", 1);
+        let edited = prepared
+            .document
+            .replacen(b"what\n\nwhy", b"upper\n\nreason", 1)
+            .replacen(b";Todo\n;Message:", b"Todo\nMessage: split enrichment", 1);
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
         let upper = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let repository = open(fixture.path())?;
+        assert_eq!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, upper)?
+            )?,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("split enrichment".into()),
+            }
+        );
         let source = repository
             .find_commit(upper)?
             .parent_ids()
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index ac35ce1d776..866d3fd6294 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -15,6 +15,12 @@ pub(crate) struct Enrichment {
     pub note: Option<BString>,
 }
 
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(crate) struct Headers {
+    pub todo: bool,
+    pub message: Option<BString>,
+}
+
 pub(crate) fn marker(todo: bool, note: bool) -> &'static str {
     match (todo, note) {
         (true, true) => "🚧📝",
@@ -92,6 +98,59 @@ pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option
     })
 }
 
+pub(crate) fn apply_headers(
+    repo: &gix::Repository,
+    commit_id: ObjectId,
+    headers: &Headers,
+) -> Result<Option<Enrichment>> {
+    let current = load(&mut open(repo)?, crate::change_id::for_commit(repo, commit_id)?)?;
+    let note = match (
+        headers.message.as_ref().map(|message| message.as_bstr()),
+        current.note.as_ref().map(|note| note.as_bstr()),
+    ) {
+        (None, _) => None,
+        (Some(title), Some(existing)) => {
+            let parsed = gix::objs::commit::MessageRef::from_bytes(existing);
+            if parsed.summary().as_ref() == title {
+                Some(existing.to_owned())
+            } else {
+                let mut message = BString::from(title);
+                if let Some(body) = parsed.body {
+                    message.extend_from_slice(b"\n\n");
+                    message.extend_from_slice(body);
+                }
+                Some(message)
+            }
+        }
+        (Some(title), None) => Some(title.to_owned()),
+    };
+    let desired = Enrichment {
+        todo: headers.todo,
+        note,
+    };
+    if desired == current {
+        return Ok(None);
+    }
+    update(repo, commit_id, |config| {
+        let mut section = config
+            .section_mut_or_create_new("commit", None)
+            .context("could not create the commit enrichment section")?;
+        section
+            .set("todo", if desired.todo { "true" } else { "false" })
+            .context("could not update commit.todo")?;
+        match desired.note.as_ref().map(|note| note.as_bstr()) {
+            Some(note) => {
+                section.set("note", note).context("could not update commit.note")?;
+            }
+            None => {
+                section.remove("note");
+            }
+        }
+        Ok(())
+    })
+    .map(Some)
+}
+
 fn update(
     repo: &gix::Repository,
     commit_id: ObjectId,
@@ -204,6 +263,46 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn commit_headers_edit_only_the_message_title() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=header author", "user.email=header@example.com"],
+        )?;
+        let id = repo.head_id()?.detach();
+        set_note(&repo, id, Some(b"Old title\n\nbody stays byte-for-byte\n"))?;
+
+        let unchanged = apply_headers(
+            &repo,
+            id,
+            &Headers {
+                todo: false,
+                message: Some("Old title".into()),
+            },
+        )?;
+        assert!(unchanged.is_none(), "an unchanged title preserves the complete message");
+        let changed = apply_headers(
+            &repo,
+            id,
+            &Headers {
+                todo: true,
+                message: Some("New title".into()),
+            },
+        )?
+        .expect("the title and todo changed");
+        assert!(changed.todo);
+        assert_eq!(
+            changed.note.as_ref().map(|note| note.as_bstr()),
+            Some(b"New title\n\nbody stays byte-for-byte\n".as_bstr())
+        );
+
+        let removed = apply_headers(&repo, id, &Headers::default())?.expect("removing the title changes the message");
+        assert!(!removed.todo);
+        assert!(removed.note.is_none(), "removing the title removes its body as well");
+        Ok(())
+    }
+
     #[test]
     fn malformed_enrichments_are_not_overwritten() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 94bb05ac7ea..87374fe6d0c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2141,7 +2141,9 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(Some(new_id)) => {
+                        Ok(Some(edit::reword::Outcome {
+                            commit: Some(new_id), ..
+                        })) => {
                             app.leave_success(format!(
                                 "reworded {} as {}",
                                 id.to_hex_with_len(7),
@@ -2150,7 +2152,16 @@ fn event_loop(
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
+                        Ok(Some(edit::reword::Outcome {
+                            enrichment: Some(enrichment),
+                            ..
+                        })) => {
+                            app.clear_enrichments();
+                            app.set_enrichment(id, enrichment);
+                            app.leave_success("updated enrichment");
+                        }
                         Ok(None) => {}
+                        Ok(Some(_)) => {}
                         Err(err) => app.leave_error(format!("reword: {err:#}")),
                     }
                 }
@@ -3729,7 +3740,7 @@ fn reword_commit(
     graph: &HistoryGraph,
     id: gix::ObjectId,
     enhanced_keyboard: bool,
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<Option<edit::reword::Outcome>> {
     let (editor, document) = {
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before editing commit")?;
@@ -3750,7 +3761,7 @@ fn reword_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    edit::reword::apply(repository, graph, id, &edited)
+    edit::reword::apply(repository, graph, id, &edited).map(Some)
 }
 
 #[tracing::instrument(skip_all, fields(base = %base, commits = commits.len()))]

From ce4b1bc54e14b06d0cd0d3345e32f2beb60e4c30 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 19:58:36 +0200
Subject: [PATCH 195/282] feat: add tix new command

---
 gix-tix/spec.md               |  10 ++
 gix-tix/src/command.rs        |  36 +++++-
 gix-tix/src/command/new.rs    | 200 ++++++++++++++++++++++++++++++++++
 gix-tix/src/command/reword.rs |  51 +++++----
 gix-tix/src/edit/create.rs    |  77 +++++++++++--
 5 files changed, 336 insertions(+), 38 deletions(-)
 create mode 100644 gix-tix/src/command/new.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 68a3c758bd3..1dd463a51f2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -29,6 +29,16 @@ without trading responsiveness for metadata that is not visible.
   error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state at `HEAD` through the same
   commit-stash operation as the TUI.
+- `tix new [--index | --worktree] [--allow-empty] [--author "Name <email>"]
+  [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
+  unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
+  worktree-safety rules as `e n`. By default a changed index wins and tracked
+  worktree changes are used only when the index is unchanged. `--index` uses
+  only the index delta; `--worktree` applies only unstaged tracked-worktree
+  changes to the `HEAD` tree and omits staged-only changes. An unchanged
+  selected tree is rejected unless `--allow-empty` is given. Message files,
+  repeated messages, standard input, editor bypass, and `--author` follow
+  `tix reword`; the author uses the prepared new-commit date.
 - `tix reword REVSPEC [--author "Name <email>"] [-m MESSAGE ... | -f FILE]`
   applies the same signing,
   lazy-rebase, mutable-ref, and worktree-safety rules as the TUI. Without either
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 748128717d5..3798b2aeb06 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -5,6 +5,7 @@ use clap::Parser;
 use gix::prelude::{ObjectIdExt, ReferenceExt};
 use ratatui::text::Line;
 
+mod new;
 mod rebase;
 mod reword;
 mod travel;
@@ -45,6 +46,8 @@ enum Command {
     Travel(travel::Args),
     /// Edit a commit and lazily rebase every descendant retained by a tix pin.
     Reword(reword::Args),
+    /// Create a new commit at HEAD.
+    New(new::Args),
     /// Generate or apply a self-contained history-rebase todo.
     #[command(subcommand)]
     Rebase(rebase::Command),
@@ -164,6 +167,7 @@ impl Platform {
             Command::Pin(args) => pin(&repository, args)?,
             Command::Travel(args) => return travel::run(repository, args),
             Command::Reword(args) => return reword::run(repository, args),
+            Command::New(args) => return new::run(repository, args),
             Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
@@ -553,9 +557,9 @@ mod tests {
             panic!("reword was expected")
         };
         assert_eq!(reword.revision, "HEAD~2");
-        assert!(reword.message.is_empty());
-        assert!(reword.file.is_none());
-        assert!(reword.author.is_none());
+        assert!(reword.edit.message.is_empty());
+        assert!(reword.edit.file.is_none());
+        assert!(reword.edit.author.is_none());
         let reword = Cli::try_parse_from([
             "tix",
             "reword",
@@ -573,15 +577,37 @@ mod tests {
         let Some(Command::Reword(reword)) = reword else {
             panic!("reword was expected")
         };
-        assert_eq!(reword.message, ["title", "body"]);
+        assert_eq!(reword.edit.message, ["title", "body"]);
         assert_eq!(
-            reword.author.as_deref(),
+            reword.edit.author.as_deref(),
             Some(std::ffi::OsStr::new("Agent <agent@example.com>"))
         );
         assert!(
             Cli::try_parse_from(["tix", "reword", "HEAD", "-m", "message", "-f", "message.txt"]).is_err(),
             "message and file inputs are mutually exclusive"
         );
+        let new = Cli::try_parse_from([
+            "tix",
+            "new",
+            "--index",
+            "--allow-empty",
+            "--author",
+            "Agent <agent@example.com>",
+            "-m",
+            "title",
+        ])
+        .expect("new options parse")
+        .platform
+        .command;
+        let Some(Command::New(new)) = new else {
+            panic!("new was expected")
+        };
+        assert!(new.index);
+        assert!(!new.worktree);
+        assert!(new.allow_empty);
+        assert_eq!(new.edit.message, ["title"]);
+        assert!(Cli::try_parse_from(["tix", "new", "--index", "--worktree", "-m", "title"]).is_err());
+        assert!(Cli::try_parse_from(["tix", "new", "HEAD", "-m", "title"]).is_err());
         assert!(matches!(
             Cli::try_parse_from([
                 "tix",
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
new file mode 100644
index 00000000000..ac5dc6928d3
--- /dev/null
+++ b/gix-tix/src/command/new.rs
@@ -0,0 +1,200 @@
+use anyhow::{Context, Result};
+
+#[derive(Debug, clap::Args)]
+pub(super) struct Args {
+    /// Take changes only from the index.
+    #[arg(long, conflicts_with = "worktree")]
+    pub(super) index: bool,
+    /// Take only tracked worktree changes, ignoring staged-only changes.
+    #[arg(long, conflicts_with = "index")]
+    pub(super) worktree: bool,
+    /// Create the commit even when the selected tree is unchanged.
+    #[arg(long)]
+    pub(super) allow_empty: bool,
+    #[command(flatten)]
+    pub(super) edit: super::reword::MessageArgs,
+}
+
+pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
+    let parent = repository
+        .head()
+        .context("could not read HEAD before creating a commit")?
+        .id()
+        .map(gix::Id::detach);
+    let graph = crate::edit::loaded_graph(&repository)?;
+    let source = if args.index {
+        crate::edit::create::Source::Index
+    } else if args.worktree {
+        crate::edit::create::Source::Worktree
+    } else {
+        crate::edit::create::Source::Default
+    };
+    let author = args
+        .edit
+        .author
+        .as_deref()
+        .map(gix::path::os_str_into_bstr)
+        .transpose()
+        .context("author is not valid UTF-8")?;
+    let repository_path = repository.git_dir().to_owned();
+    let bare = repository.is_bare();
+    let prepared = crate::edit::create::prepare_from(repository, parent, source, author.as_deref())?;
+    if prepared.is_empty && !args.allow_empty {
+        anyhow::bail!("the new commit would be empty; use --allow-empty to create it anyway");
+    }
+
+    let explicit = super::reword::explicit_message(&args.edit, std::io::stdin())?;
+    let id = if let Some(message) = explicit {
+        let mut repository = crate::open_repository(&repository_path, bare, false)
+            .context("could not reopen repository before creating commit")?;
+        repository.object_cache_size(None);
+        crate::edit::create::apply_message(repository, &graph, prepared, &message)?
+    } else {
+        let Some(edited) = crate::edit::edit_document_without_terminal(
+            &prepared.editor,
+            &prepared.document,
+            &format!("tix-commit-{}.md", std::process::id()),
+        )?
+        else {
+            println!("no commit created: no input was provided");
+            return Ok(());
+        };
+        let mut repository = crate::open_repository(&repository_path, bare, false)
+            .context("could not reopen repository after editing commit")?;
+        repository.object_cache_size(None);
+        crate::edit::create::apply(repository, &graph, prepared, &edited)?
+    };
+    println!("{}", id.to_hex_with_len(7));
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::{path::Path, process::Command};
+
+    use super::*;
+
+    fn args() -> Args {
+        Args {
+            index: false,
+            worktree: false,
+            allow_empty: false,
+            edit: super::super::reword::MessageArgs {
+                message: vec!["new title".into(), "new body".into()],
+                file: None,
+                author: Some("New Author <new@example.com>".into()),
+            },
+        }
+    }
+
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if !output.status.success() {
+            return Err(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into());
+        }
+        Ok(output.stdout)
+    }
+
+    #[test]
+    fn explicit_message_uses_the_default_staged_tree_and_author() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        run(
+            crate::test_repository::open_with(fixture.path(), ["core.editor=false"])?,
+            args(),
+        )?;
+
+        assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"staged\n");
+        assert_eq!(
+            git(fixture.path(), &["log", "-1", "--format=%B"])?,
+            b"new title\n\nnew body\n\n"
+        );
+        assert_eq!(
+            git(fixture.path(), &["log", "-1", "--format=%an <%ae>"])?,
+            b"New Author <new@example.com>\n"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"unstaged\n");
+        Ok(())
+    }
+
+    #[test]
+    fn index_and_worktree_select_only_their_requested_changes() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        std::fs::write(fixture.path().join("staged-only"), b"staged only\n")?;
+        git(fixture.path(), &["add", "staged-only"])?;
+        let mut worktree = args();
+        worktree.worktree = true;
+        run(crate::test_repository::open(fixture.path())?, worktree)?;
+        assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"unstaged\n");
+        assert!(git(fixture.path(), &["cat-file", "-e", "HEAD:staged-only"]).is_err());
+
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let mut index = args();
+        index.index = true;
+        run(crate::test_repository::open(fixture.path())?, index)?;
+        assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"staged\n");
+        Ok(())
+    }
+
+    #[test]
+    fn unchanged_selected_trees_require_allow_empty() -> gix_testtools::Result {
+        for worktree in [false, true] {
+            let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+            if worktree {
+                git(fixture.path(), &["checkout", "--", "tracked"])?;
+            } else {
+                git(fixture.path(), &["reset", "-q", "HEAD"])?;
+            }
+            let parent = git(fixture.path(), &["rev-parse", "HEAD^{tree}"])?;
+            let mut selected = args();
+            selected.index = !worktree;
+            selected.worktree = worktree;
+            let err = run(crate::test_repository::open(fixture.path())?, selected)
+                .expect_err("an unchanged selected tree is rejected");
+            assert!(format!("{err:#}").contains("--allow-empty"));
+
+            let mut empty = args();
+            empty.index = !worktree;
+            empty.worktree = worktree;
+            empty.allow_empty = true;
+            run(crate::test_repository::open(fixture.path())?, empty)?;
+            assert_eq!(git(fixture.path(), &["rev-parse", "HEAD^{tree}"])?, parent);
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn allow_empty_creates_an_unborn_root() -> gix_testtools::Result {
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        git(fixture.path(), &["init", "-q", "-b", "main"])?;
+        git(fixture.path(), &["config", "user.name", "author"])?;
+        git(fixture.path(), &["config", "user.email", "author@example.com"])?;
+        let mut empty = args();
+        empty.allow_empty = true;
+        run(crate::test_repository::open(fixture.path())?, empty)?;
+
+        assert_eq!(git(fixture.path(), &["rev-list", "--count", "HEAD"])?, b"1\n");
+        assert_eq!(git(fixture.path(), &["ls-tree", "HEAD"])?, b"");
+        Ok(())
+    }
+
+    #[test]
+    fn unchanged_editor_input_creates_nothing() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let old = git(fixture.path(), &["rev-parse", "HEAD"])?;
+        let mut editor = args();
+        editor.edit.message.clear();
+        editor.edit.author = None;
+        run(
+            crate::test_repository::open_with(fixture.path(), ["core.editor=:"])?,
+            editor,
+        )?;
+
+        assert_eq!(git(fixture.path(), &["rev-parse", "HEAD"])?, old);
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index f7ccf4ec3aa..ad3fde8b7e8 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -7,10 +7,7 @@ use std::{
 use anyhow::{Context, Result};
 
 #[derive(Debug, clap::Args)]
-pub(super) struct Args {
-    /// Revision resolving to the commit whose message should be edited.
-    #[arg(value_name = "REVSPEC")]
-    pub(super) revision: OsString,
+pub(super) struct MessageArgs {
     /// Use this message instead of opening an editor; repeat to add paragraphs.
     #[arg(short = 'm', long, value_name = "MESSAGE", conflicts_with = "file")]
     pub(super) message: Vec<OsString>,
@@ -22,6 +19,15 @@ pub(super) struct Args {
     pub(super) author: Option<OsString>,
 }
 
+#[derive(Debug, clap::Args)]
+pub(super) struct Args {
+    /// Revision resolving to the commit whose message should be edited.
+    #[arg(value_name = "REVSPEC")]
+    pub(super) revision: OsString,
+    #[command(flatten)]
+    pub(super) edit: MessageArgs,
+}
+
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let revision = gix::path::os_str_into_bstr(&args.revision)
         .with_context(|| format!("revision {} is not valid UTF-8", args.revision.to_string_lossy()))?;
@@ -51,13 +57,14 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     }
 
     let author = args
+        .edit
         .author
         .as_deref()
         .map(gix::path::os_str_into_bstr)
         .transpose()
         .context("author is not valid UTF-8")?;
 
-    if let Some(message) = explicit_message(&args, std::io::stdin())? {
+    if let Some(message) = explicit_message(&args.edit, std::io::stdin())? {
         return finish(crate::edit::reword::apply_message(
             repository,
             &graph,
@@ -91,7 +98,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     finish_editor(crate::edit::reword::apply(repository, &graph, target, &edited)?, target)
 }
 
-fn explicit_message(args: &Args, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
+pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
     if !args.message.is_empty() {
         let mut out = Vec::new();
         for (index, message) in args.message.iter().enumerate() {
@@ -164,26 +171,28 @@ mod tests {
     fn args(revision: &str) -> Args {
         Args {
             revision: revision.into(),
-            message: Vec::new(),
-            file: None,
-            author: None,
+            edit: MessageArgs {
+                message: Vec::new(),
+                file: None,
+                author: None,
+            },
         }
     }
 
     #[test]
     fn explicit_message_sources_are_complete_and_git_like() -> gix_testtools::Result {
         let mut message_args = args("HEAD");
-        message_args.message = vec!["title".into(), "body".into()];
+        message_args.edit.message = vec!["title".into(), "body".into()];
         assert_eq!(
-            explicit_message(&message_args, &b"ignored"[..])?,
+            explicit_message(&message_args.edit, &b"ignored"[..])?,
             Some(b"title\n\nbody".to_vec()),
             "repeated messages become paragraphs without reading stdin"
         );
 
         let mut file_args = args("HEAD");
-        file_args.file = Some("-".into());
+        file_args.edit.file = Some("-".into());
         assert_eq!(
-            explicit_message(&file_args, &b"from stdin\n"[..])?,
+            explicit_message(&file_args.edit, &b"from stdin\n"[..])?,
             Some(b"from stdin\n".to_vec()),
             "a dash reads the entire message from stdin"
         );
@@ -192,9 +201,9 @@ mod tests {
         let path = fixture.path().join("message.md");
         std::fs::write(&path, b"from file\n\nbody\n")?;
         let mut file_args = args("HEAD");
-        file_args.file = Some(path);
+        file_args.edit.file = Some(path);
         assert_eq!(
-            explicit_message(&file_args, &b"ignored"[..])?,
+            explicit_message(&file_args.edit, &b"ignored"[..])?,
             Some(b"from file\n\nbody\n".to_vec()),
             "a file supplies the complete message"
         );
@@ -209,8 +218,8 @@ mod tests {
         crate::enrich::toggle(&repository, original)?;
         crate::enrich::set_note(&repository, original, Some(b"kept\n\nbody"))?;
         let mut initial = args("HEAD");
-        initial.message = vec!["replacement title".into(), ";literal body".into()];
-        initial.author = Some("Agent <agent@example.com>".into());
+        initial.edit.message = vec!["replacement title".into(), ";literal body".into()];
+        initial.edit.author = Some("Agent <agent@example.com>".into());
         run(open(fixture.path(), "false")?, initial)?;
 
         assert_eq!(
@@ -238,7 +247,7 @@ mod tests {
         );
         let rewritten = git(fixture.path(), &["rev-parse", "HEAD"])?;
         let mut same = args("HEAD");
-        same.message = vec!["replacement title\n\n;literal body".into()];
+        same.edit.message = vec!["replacement title\n\n;literal body".into()];
         run(open(fixture.path(), "false")?, same)?;
         assert_eq!(
             git(fixture.path(), &["rev-parse", "HEAD"])?,
@@ -247,7 +256,7 @@ mod tests {
         );
 
         let mut empty = args("HEAD");
-        empty.message = vec!["   ".into()];
+        empty.edit.message = vec!["   ".into()];
         let err = run(open(fixture.path(), "false")?, empty)
             .expect_err("an empty cleaned message must not replace the commit message");
         assert!(format!("{err:#}").contains("message is empty"));
@@ -260,7 +269,7 @@ mod tests {
         let message = git(fixture.path(), &["log", "-1", "--format=%B"])?;
         let author_date = git(fixture.path(), &["log", "-1", "--format=%aI"])?;
         let mut reword = args("HEAD");
-        reword.author = Some("Agent <agent@example.com>".into());
+        reword.edit.author = Some("Agent <agent@example.com>".into());
         run(open(fixture.path(), ":")?, reword)?;
 
         assert_eq!(git(fixture.path(), &["log", "-1", "--format=%B"])?, message);
@@ -272,7 +281,7 @@ mod tests {
 
         let old = git(fixture.path(), &["rev-parse", "HEAD"])?;
         let mut invalid = args("HEAD");
-        invalid.author = Some("missing-email".into());
+        invalid.edit.author = Some("missing-email".into());
         let err = run(open(fixture.path(), "false")?, invalid)
             .expect_err("an invalid author is rejected before invoking the editor");
         assert!(format!("{err:#}").contains("author identity"));
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 18552d973fd..1c85a3b92a0 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -20,17 +20,39 @@ pub(crate) struct Prepared {
     pub(super) reset_index: bool,
 }
 
+#[derive(Clone, Copy)]
+pub(crate) enum Source {
+    Default,
+    Index,
+    Worktree,
+}
+
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
 pub(crate) fn prepare(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
-    prepare_inner(repo, parent, false)
+    prepare_inner(repo, parent, false, Source::Default, None)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
 pub(crate) fn prepare_empty(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
-    prepare_inner(repo, parent, true)
+    prepare_inner(repo, parent, true, Source::Default, None)
+}
+
+pub(crate) fn prepare_from(
+    repo: gix::Repository,
+    parent: Option<ObjectId>,
+    source: Source,
+    author: Option<&gix::bstr::BStr>,
+) -> Result<Prepared> {
+    prepare_inner(repo, parent, false, source, author)
 }
 
-fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: bool) -> Result<Prepared> {
+fn prepare_inner(
+    mut repo: gix::Repository,
+    parent: Option<ObjectId>,
+    empty: bool,
+    source: Source,
+    author_override: Option<&gix::bstr::BStr>,
+) -> Result<Prepared> {
     repo.workdir().context("creating a commit requires a worktree")?;
     let head = repo.head().context("could not read HEAD before creating a commit")?;
     let head_id = head.id().map(gix::Id::detach);
@@ -45,12 +67,15 @@ fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: boo
         head.referent_name().context("an unborn HEAD must point to a branch")?;
     }
     let editor = repo.editor().context("no Git editor is available")?;
-    let author = repo
+    let mut author = repo
         .author()
         .context("no Git author is configured")?
         .context("could not resolve the Git author")?
         .to_owned()
         .context("could not own the Git author")?;
+    if let Some(value) = author_override {
+        author = reword::actor(value, author.time, "author")?;
+    }
     let committer = repo
         .committer()
         .context("no Git committer is configured")?
@@ -80,14 +105,14 @@ fn prepare_inner(mut repo: gix::Repository, parent: Option<ObjectId>, empty: boo
     }
     let index_tree = index_tree(&repo, &index)?;
     let based_on_parent = head_id == parent;
-    let tree = if empty {
+    let tree = if empty || !based_on_parent {
         baseline.id
-    } else if based_on_parent && index_tree != baseline.id {
-        index_tree
-    } else if based_on_parent {
-        worktree_tree_tracked(&repo, &baseline, &index)?
     } else {
-        baseline.id
+        match source {
+            Source::Default if index_tree != baseline.id => index_tree,
+            Source::Default | Source::Worktree => worktree_tree_tracked(&repo, &baseline, &index)?,
+            Source::Index => index_tree,
+        }
     };
 
     let new_tree = repo.find_tree(tree).context("could not load the candidate tree")?;
@@ -243,15 +268,36 @@ fn worktree_tree_with_changes_inner(
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
 pub(crate) fn apply(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    let edit = commit_from_edit(&prepared, edited)?;
+    apply_commit(repo, graph, prepared, edit)
+}
+
+pub(crate) fn apply_message(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    message: &[u8],
+) -> Result<ObjectId> {
+    let mut edit = reword::parse(&prepared.document)?;
+    edit.message = reword::cleanup_message(message, None);
+    let commit = commit_from_parsed_edit(&prepared, edit)?;
+    apply_commit(repo, graph, prepared, commit)
+}
+
+fn apply_commit(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
-    edited: &[u8],
+    (commit, enrichment): (gix::objs::Commit, crate::enrich::Headers),
 ) -> Result<ObjectId> {
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
     let id = rebase::perform(
         &repo,
         graph,
@@ -305,6 +351,13 @@ pub(super) fn commit_from_edit(
     edited: &[u8],
 ) -> Result<(gix::objs::Commit, crate::enrich::Headers)> {
     let edit = reword::parse(edited)?;
+    commit_from_parsed_edit(prepared, edit)
+}
+
+fn commit_from_parsed_edit(
+    prepared: &Prepared,
+    edit: reword::Edit<'_>,
+) -> Result<(gix::objs::Commit, crate::enrich::Headers)> {
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
     }

From d1a33ed4e857621d3c891f69946898caf30c24b6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 20:48:28 +0200
Subject: [PATCH 196/282] feat: include untracked files in tix new

---
 gix-tix/spec.md            |  9 +++----
 gix-tix/src/command.rs     |  3 +++
 gix-tix/src/command/new.rs | 49 ++++++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/create.rs |  2 ++
 4 files changed, 57 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1dd463a51f2..72ed8b662b2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -29,14 +29,15 @@ without trading responsiveness for metadata that is not visible.
   error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state at `HEAD` through the same
   commit-stash operation as the TUI.
-- `tix new [--index | --worktree] [--allow-empty] [--author "Name <email>"]
-  [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
+- `tix new [--index | --worktree | --worktree-untracked] [--allow-empty]
+  [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
   worktree-safety rules as `e n`. By default a changed index wins and tracked
   worktree changes are used only when the index is unchanged. `--index` uses
   only the index delta; `--worktree` applies only unstaged tracked-worktree
-  changes to the `HEAD` tree and omits staged-only changes. An unchanged
-  selected tree is rejected unless `--allow-empty` is given. Message files,
+  changes to the `HEAD` tree and omits staged-only changes. `--worktree-untracked`
+  additionally includes non-ignored untracked files. An unchanged selected tree
+  is rejected unless `--allow-empty` is given. Message files,
   repeated messages, standard input, editor bypass, and `--author` follow
   `tix reword`; the author uses the prepared new-commit date.
 - `tix reword REVSPEC [--author "Name <email>"] [-m MESSAGE ... | -f FILE]`
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 3798b2aeb06..9412a7c2d6f 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -604,9 +604,12 @@ mod tests {
         };
         assert!(new.index);
         assert!(!new.worktree);
+        assert!(!new.worktree_untracked);
         assert!(new.allow_empty);
         assert_eq!(new.edit.message, ["title"]);
         assert!(Cli::try_parse_from(["tix", "new", "--index", "--worktree", "-m", "title"]).is_err());
+        assert!(Cli::try_parse_from(["tix", "new", "--index", "--worktree-untracked", "-m", "title"]).is_err());
+        assert!(Cli::try_parse_from(["tix", "new", "--worktree", "--worktree-untracked", "-m", "title"]).is_err());
         assert!(Cli::try_parse_from(["tix", "new", "HEAD", "-m", "title"]).is_err());
         assert!(matches!(
             Cli::try_parse_from([
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index ac5dc6928d3..15262e6db96 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -3,11 +3,14 @@ use anyhow::{Context, Result};
 #[derive(Debug, clap::Args)]
 pub(super) struct Args {
     /// Take changes only from the index.
-    #[arg(long, conflicts_with = "worktree")]
+    #[arg(long, conflicts_with_all = ["worktree", "worktree_untracked"])]
     pub(super) index: bool,
     /// Take only tracked worktree changes, ignoring staged-only changes.
-    #[arg(long, conflicts_with = "index")]
+    #[arg(long, conflicts_with_all = ["index", "worktree_untracked"])]
     pub(super) worktree: bool,
+    /// Take worktree changes and untracked files, ignoring staged-only changes.
+    #[arg(long, conflicts_with_all = ["index", "worktree"])]
+    pub(super) worktree_untracked: bool,
     /// Create the commit even when the selected tree is unchanged.
     #[arg(long)]
     pub(super) allow_empty: bool,
@@ -24,6 +27,8 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let graph = crate::edit::loaded_graph(&repository)?;
     let source = if args.index {
         crate::edit::create::Source::Index
+    } else if args.worktree_untracked {
+        crate::edit::create::Source::WorktreeUntracked
     } else if args.worktree {
         crate::edit::create::Source::Worktree
     } else {
@@ -78,6 +83,7 @@ mod tests {
         Args {
             index: false,
             worktree: false,
+            worktree_untracked: false,
             allow_empty: false,
             edit: super::super::reword::MessageArgs {
                 message: vec!["new title".into(), "new body".into()],
@@ -131,6 +137,7 @@ mod tests {
         run(crate::test_repository::open(fixture.path())?, worktree)?;
         assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"unstaged\n");
         assert!(git(fixture.path(), &["cat-file", "-e", "HEAD:staged-only"]).is_err());
+        assert!(git(fixture.path(), &["cat-file", "-e", "HEAD:untracked"]).is_err());
 
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
         let mut index = args();
@@ -140,6 +147,24 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn worktree_untracked_includes_untracked_but_not_staged_or_ignored_files() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        std::fs::write(fixture.path().join("staged-only"), b"staged only\n")?;
+        git(fixture.path(), &["add", "staged-only"])?;
+        std::fs::write(fixture.path().join(".git/info/exclude"), b"ignored\n")?;
+        std::fs::write(fixture.path().join("ignored"), b"ignored\n")?;
+        let mut worktree = args();
+        worktree.worktree_untracked = true;
+        run(crate::test_repository::open(fixture.path())?, worktree)?;
+
+        assert_eq!(git(fixture.path(), &["show", "HEAD:tracked"])?, b"unstaged\n");
+        assert_eq!(git(fixture.path(), &["show", "HEAD:untracked"])?, b"untracked\n");
+        assert!(git(fixture.path(), &["cat-file", "-e", "HEAD:staged-only"]).is_err());
+        assert!(git(fixture.path(), &["cat-file", "-e", "HEAD:ignored"]).is_err());
+        Ok(())
+    }
+
     #[test]
     fn unchanged_selected_trees_require_allow_empty() -> gix_testtools::Result {
         for worktree in [false, true] {
@@ -182,6 +207,26 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn unchanged_worktree_untracked_requires_allow_empty() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        git(fixture.path(), &["clean", "-fdq"])?;
+        git(fixture.path(), &["checkout", "--", "tracked"])?;
+        let parent = git(fixture.path(), &["rev-parse", "HEAD^{tree}"])?;
+        let mut selected = args();
+        selected.worktree_untracked = true;
+        let err = run(crate::test_repository::open(fixture.path())?, selected)
+            .expect_err("an unchanged worktree including untracked files is rejected");
+        assert!(format!("{err:#}").contains("--allow-empty"));
+
+        let mut empty = args();
+        empty.worktree_untracked = true;
+        empty.allow_empty = true;
+        run(crate::test_repository::open(fixture.path())?, empty)?;
+        assert_eq!(git(fixture.path(), &["rev-parse", "HEAD^{tree}"])?, parent);
+        Ok(())
+    }
+
     #[test]
     fn unchanged_editor_input_creates_nothing() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 1c85a3b92a0..1c6e8517139 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -25,6 +25,7 @@ pub(crate) enum Source {
     Default,
     Index,
     Worktree,
+    WorktreeUntracked,
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
@@ -112,6 +113,7 @@ fn prepare_inner(
             Source::Default if index_tree != baseline.id => index_tree,
             Source::Default | Source::Worktree => worktree_tree_tracked(&repo, &baseline, &index)?,
             Source::Index => index_tree,
+            Source::WorktreeUntracked => worktree_tree(&repo, &baseline)?,
         }
     };
 

From 5ec2455526d4dc17ea5c2871fb4b7ebfac54eca4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 21:58:34 +0200
Subject: [PATCH 197/282] fix: ignore unavailable tix diagnostic logs

Diagnostic logging is optional, but command-line mutations previously failed when their platform log destination could not be opened. Interactive startup also emitted a warning for the same best-effort facility.

Treat initialization failure as diagnostics being disabled. Both command-line and interactive operation now continue silently while successful initialization retains the existing daily tracing behavior.
---
 gix-tix/spec.md        | 3 ++-
 gix-tix/src/command.rs | 2 +-
 gix-tix/src/lib.rs     | 8 +-------
 gix-tix/src/logging.rs | 6 +++++-
 4 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 72ed8b662b2..4c1c4aa26e4 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -995,7 +995,8 @@ space first; changes blocks adapt within the remaining history width.
 - Filesystem responses receive correlated IDs in daily tracing logs, including
   semantic trigger, coalesced paths, phases, presentation count, elapsed time,
   and outcome. Logs use the platform application-log directory, retain seven
-  days, and are best-effort.
+  days, and are best-effort. Failure to create or open the log is silently
+  ignored and never prevents either command-line or interactive operation.
 - After every event-loop wait, tix assumes that the original worktree and process
   working directory may have disappeared. Before processing filesystem events or
   redrawing, it lexically normalizes and enters the common repository, reopens it
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 9412a7c2d6f..772bdcc9523 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -131,7 +131,7 @@ impl Platform {
             Command::Show(args) => return show(&repository, args),
             command => command,
         };
-        let _log_guard = crate::logging::init().context("could not initialize tix diagnostics")?;
+        let _log_guard = crate::logging::init();
         match command {
             Command::RefTree(_) | Command::Show(_) => unreachable!("display commands return before logging"),
             Command::Amend(args) => {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 87374fe6d0c..737bd04517e 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -793,13 +793,7 @@ fn shade_terminal_background((red, green, blue): (u8, u8, u8), dark: bool) -> (u
 
 /// Run the interactive commit graph for `repository`.
 pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut options: Options) -> Result<()> {
-    let _log_guard = match logging::init() {
-        Ok(guard) => Some(guard),
-        Err(err) => {
-            eprintln!("warning: could not initialize tix diagnostics: {err:#}");
-            None
-        }
-    };
+    let _log_guard = logging::init();
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (validation_repository, _) = open_history_repository(&mut repository_path, &common_dir)?;
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index f25350b1fa9..08fd8922d26 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -358,7 +358,11 @@ fn classify_reference_path(path: &Path, git_dir: &Path, common_dir: &Path) -> Tr
     }
 }
 
-pub(crate) fn init() -> Result<tracing::subscriber::DefaultGuard> {
+pub(crate) fn init() -> Option<tracing::subscriber::DefaultGuard> {
+    try_init().ok()
+}
+
+fn try_init() -> Result<tracing::subscriber::DefaultGuard> {
     let directory = log_directory().context("could not determine the platform log directory")?;
     fs::create_dir_all(&directory)
         .with_context(|| format!("could not create log directory at {}", directory.display()))?;

From 16fccd406869e67c025bda5e921e94ab5d11bd8e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 21:59:47 +0200
Subject: [PATCH 198/282] feat: report rewritten refs after tix mutations

A mutation can print the commit it edited before lazy descendant replay has moved the final branch tip, leaving scripts and users without the resulting ref target.

Capture old-to-new commit targets from the successful shared ref transaction and propagate them through command-line amend, spill, split, reword, new, rebase, and pending time-travel replay. Existing primary output remains first, followed by deterministic full ref names and abbreviated commit mappings. TUI edits continue to consume selections without printing command output.
---
 gix-tix/spec.md                 |  6 +++
 gix-tix/src/command.rs          | 88 ++++++++++++++++++++++++++++++---
 gix-tix/src/command/new.rs      | 15 ++++--
 gix-tix/src/command/rebase.rs   |  4 +-
 gix-tix/src/command/reword.rs   |  8 +--
 gix-tix/src/command/travel.rs   | 12 +++--
 gix-tix/src/edit/create.rs      | 28 ++++++++---
 gix-tix/src/edit/head.rs        | 22 +++++++--
 gix-tix/src/edit/rebase.rs      | 62 ++++++++++++++++++++---
 gix-tix/src/edit/reword.rs      | 39 ++++++++++-----
 gix-tix/src/edit/split.rs       | 22 ++++++---
 gix-tix/src/edit/time_travel.rs | 33 ++++++++++---
 gix-tix/src/lib.rs              | 22 +++++----
 13 files changed, 290 insertions(+), 71 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 4c1c4aa26e4..3ee1f3dce76 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -642,6 +642,12 @@ space first; changes blocks adapt within the remaining history width.
 - Command-line edits use the same default HEAD, applicable pin, and review tips
   as the history view. Unrelated refs do not broaden their descendant rewrite
   scope, while mutable refs pointing into that scope are still retargeted.
+- After any command-line amend, spill, split, reword, new, rebase, or pending
+  time-travel replay, successfully retargeted commit refs are printed after the
+  command's existing result as sorted `full/ref/name: old-id -> new-id` lines.
+  IDs use the same seven-character display as other command results. Ref
+  creations, deletions, unchanged refs, and unreferenced replayed commits add no
+  mapping line.
 - With a path selected in the focused tree-changes block, the main `e` prefix
   offers `spill` and `e s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 772bdcc9523..8f1cdfdac08 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -137,12 +137,21 @@ impl Platform {
             Command::Amend(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 let amended = if args.index {
-                    crate::edit::head::amend_index(repository, &graph)?
+                    crate::edit::head::amend_index_reporting(repository, &graph)?
                 } else {
-                    crate::edit::head::perform(repository, &graph, crate::edit::head::Kind::Amend, None)?
+                    crate::edit::head::perform_reporting(repository, &graph, crate::edit::head::Kind::Amend)?
                 };
                 match amended {
-                    Some(id) => println!("{}", id.to_hex_with_len(7)),
+                    Some(outcome) => {
+                        println!(
+                            "{}",
+                            outcome
+                                .selected
+                                .context("amending did not produce a selection")?
+                                .to_hex_with_len(7)
+                        );
+                        print_ref_rewrites(&outcome.ref_rewrites);
+                    }
                     None => println!("nothing to amend"),
                 }
             }
@@ -380,8 +389,17 @@ fn edit_head(
     kind: crate::edit::head::Kind,
     verb: &str,
 ) -> Result<()> {
-    match crate::edit::head::perform(repository, graph, kind, None)? {
-        Some(id) => println!("{}", id.to_hex_with_len(7)),
+    match crate::edit::head::perform_reporting(repository, graph, kind)? {
+        Some(outcome) => {
+            println!(
+                "{}",
+                outcome
+                    .selected
+                    .context("editing HEAD did not produce a selection")?
+                    .to_hex_with_len(7)
+            );
+            print_ref_rewrites(&outcome.ref_rewrites);
+        }
         None => println!("nothing to {verb}"),
     }
     Ok(())
@@ -403,11 +421,41 @@ fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph) -> R
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing split")?;
     repository.object_cache_size(None);
-    let id = crate::edit::split::apply(repository, graph, prepared, &edited)?;
-    println!("{}", id.to_hex_with_len(7));
+    let outcome = crate::edit::split::apply_reporting(repository, graph, prepared, &edited)?;
+    println!(
+        "{}",
+        outcome
+            .selected
+            .context("splitting did not produce a selection")?
+            .to_hex_with_len(7)
+    );
+    print_ref_rewrites(&outcome.ref_rewrites);
     Ok(())
 }
 
+fn print_ref_rewrites(rewrites: &[crate::edit::rebase::RefRewrite]) {
+    for line in ref_rewrite_lines(rewrites) {
+        println!("{line}");
+    }
+}
+
+fn ref_rewrite_lines(rewrites: &[crate::edit::rebase::RefRewrite]) -> Vec<String> {
+    let mut rewrites = rewrites.to_vec();
+    rewrites.sort_by(|a, b| a.name.cmp(&b.name));
+    rewrites.dedup();
+    rewrites
+        .into_iter()
+        .map(|rewrite| {
+            format!(
+                "{}: {} -> {}",
+                rewrite.name,
+                rewrite.old.to_hex_with_len(7),
+                rewrite.new.to_hex_with_len(7)
+            )
+        })
+        .collect()
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command as ProcessCommand};
@@ -416,6 +464,32 @@ mod tests {
 
     use super::*;
 
+    #[test]
+    fn rewritten_ref_lines_are_sorted_and_show_the_commit_mapping() {
+        let old: gix::ObjectId = "1111111111111111111111111111111111111111"
+            .parse()
+            .expect("valid object ID");
+        let new: gix::ObjectId = "2222222222222222222222222222222222222222"
+            .parse()
+            .expect("valid object ID");
+        let branch = crate::edit::rebase::RefRewrite {
+            name: "refs/heads/z".try_into().expect("valid ref name"),
+            old,
+            new,
+        };
+        let first = crate::edit::rebase::RefRewrite {
+            name: "refs/heads/a".try_into().expect("valid ref name"),
+            old,
+            new,
+        };
+        assert_eq!(
+            ref_rewrite_lines(&[branch.clone(), first, branch]),
+            ["refs/heads/a: 1111111 -> 2222222", "refs/heads/z: 1111111 -> 2222222"],
+            "ref mappings are stable and duplicate-free"
+        );
+        assert!(ref_rewrite_lines(&[]).is_empty(), "unchanged refs add no output");
+    }
+
     #[test]
     fn clap_definition_is_valid() {
         Cli::command().debug_assert();
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index 15262e6db96..718d566891a 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -49,11 +49,11 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     }
 
     let explicit = super::reword::explicit_message(&args.edit, std::io::stdin())?;
-    let id = if let Some(message) = explicit {
+    let outcome = if let Some(message) = explicit {
         let mut repository = crate::open_repository(&repository_path, bare, false)
             .context("could not reopen repository before creating commit")?;
         repository.object_cache_size(None);
-        crate::edit::create::apply_message(repository, &graph, prepared, &message)?
+        crate::edit::create::apply_message_reporting(repository, &graph, prepared, &message)?
     } else {
         let Some(edited) = crate::edit::edit_document_without_terminal(
             &prepared.editor,
@@ -67,9 +67,16 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         let mut repository = crate::open_repository(&repository_path, bare, false)
             .context("could not reopen repository after editing commit")?;
         repository.object_cache_size(None);
-        crate::edit::create::apply(repository, &graph, prepared, &edited)?
+        crate::edit::create::apply_reporting(repository, &graph, prepared, &edited)?
     };
-    println!("{}", id.to_hex_with_len(7));
+    println!(
+        "{}",
+        outcome
+            .selected
+            .context("creating a commit did not produce a selection")?
+            .to_hex_with_len(7)
+    );
+    super::print_ref_rewrites(&outcome.ref_rewrites);
     Ok(())
 }
 
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index df66003dd47..2d5391f896a 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -249,6 +249,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
             } else {
                 println!("rebased history");
             }
+            super::print_ref_rewrites(&outcome.ref_rewrites);
             Ok(())
         }
         rebase::PlanPerform::Conflict(conflict) => {
@@ -287,7 +288,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
             }
             let materialized =
                 edit::time_travel::materialize_plan_conflict(conflict, &repository_path, bare, &revisions, false);
-            let (notice, _) = match materialized {
+            let (notice, _, ref_rewrites) = match materialized {
                 Ok(materialized) => materialized,
                 Err(err) => {
                     if destination != Path::new("-") {
@@ -296,6 +297,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
                     return Err(err);
                 }
             };
+            super::print_ref_rewrites(&ref_rewrites);
             eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
             anyhow::bail!("rebase stopped at a materialized conflict")
         }
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index ad3fde8b7e8..7164bcb126a 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -65,7 +65,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("author is not valid UTF-8")?;
 
     if let Some(message) = explicit_message(&args.edit, std::io::stdin())? {
-        return finish(crate::edit::reword::apply_message(
+        return finish(crate::edit::reword::apply_message_reporting(
             repository,
             &graph,
             target,
@@ -128,11 +128,12 @@ pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Resu
     }
 }
 
-fn finish(outcome: Option<gix::ObjectId>) -> Result<()> {
-    match outcome {
+fn finish(outcome: crate::edit::reword::Outcome) -> Result<()> {
+    match outcome.commit {
         Some(id) => println!("{}", id.to_hex_with_len(7)),
         None => println!("no reword performed: the edited commit was unchanged"),
     }
+    super::print_ref_rewrites(&outcome.ref_rewrites);
     Ok(())
 }
 
@@ -142,6 +143,7 @@ fn finish_editor(outcome: crate::edit::reword::Outcome, original: gix::ObjectId)
         (None, Some(_)) => println!("{}", original.to_hex_with_len(7)),
         (None, None) => println!("no reword performed: the edited commit was unchanged"),
     }
+    super::print_ref_rewrites(&outcome.ref_rewrites);
     Ok(())
 }
 
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 405f1665958..7ead7455552 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -57,12 +57,16 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let bare = repository.is_bare();
     drop(repository);
     match crate::edit::time_travel::perform(&repository_path, bare, selected, &graph, &reviews, &[], false)? {
-        crate::edit::time_travel::Perform::Complete(Some(notice)) => println!("{notice}"),
-        crate::edit::time_travel::Perform::Complete(None) => {
-            println!("already at {}", selected.to_hex_with_len(7));
+        crate::edit::time_travel::Perform::Complete { notice, ref_rewrites } => {
+            println!(
+                "{}",
+                notice.unwrap_or_else(|| format!("already at {}", selected.to_hex_with_len(7)))
+            );
+            super::print_ref_rewrites(&ref_rewrites);
         }
         crate::edit::time_travel::Perform::Conflict(conflict) if args.materialize_conflicts => {
-            let (notice, _) = conflict.accept()?;
+            let (notice, _, ref_rewrites) = conflict.accept()?;
+            super::print_ref_rewrites(&ref_rewrites);
             anyhow::bail!("{notice}");
         }
         crate::edit::time_travel::Perform::Conflict(_) => {
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 1c6e8517139..9ab139fb472 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -275,16 +275,27 @@ pub(crate) fn apply(
     prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
+    apply_reporting(repo, graph, prepared, edited)?
+        .selected
+        .context("inserting a commit did not produce a selection")
+}
+
+pub(crate) fn apply_reporting(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edited: &[u8],
+) -> Result<rebase::Outcome> {
     let edit = commit_from_edit(&prepared, edited)?;
     apply_commit(repo, graph, prepared, edit)
 }
 
-pub(crate) fn apply_message(
+pub(crate) fn apply_message_reporting(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     prepared: Prepared,
     message: &[u8],
-) -> Result<ObjectId> {
+) -> Result<rebase::Outcome> {
     let mut edit = reword::parse(&prepared.document)?;
     edit.message = reword::cleanup_message(message, None);
     let commit = commit_from_parsed_edit(&prepared, edit)?;
@@ -296,11 +307,11 @@ fn apply_commit(
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     (commit, enrichment): (gix::objs::Commit, crate::enrich::Headers),
-) -> Result<ObjectId> {
+) -> Result<rebase::Outcome> {
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let id = rebase::perform(
+    let outcome = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Insert {
@@ -311,13 +322,14 @@ fn apply_commit(
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
     )?
-    .complete()?
-    .selected
-    .context("inserting a commit did not produce a selection")?;
+    .complete()?;
+    let id = outcome
+        .selected
+        .context("inserting a commit did not produce a selection")?;
     drop(repo);
     crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
         .context("the commit was created, but its enrichment could not be saved")?;
-    Ok(id)
+    Ok(outcome)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index fe9cfff6cf9..7ec4270f2e8 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -17,11 +17,27 @@ pub fn perform(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
 ) -> Result<Option<ObjectId>> {
-    perform_inner(repo, graph, kind, selected_path, false)
+    Ok(perform_inner(repo, graph, kind, selected_path, false)?.and_then(|outcome| outcome.selected))
+}
+
+pub(crate) fn perform_reporting(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    kind: Kind,
+) -> Result<Option<rebase::Outcome>> {
+    perform_inner(repo, graph, kind, None, false)
 }
 
 #[tracing::instrument(skip_all)]
+#[cfg(test)]
 pub fn amend_index(repo: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<Option<ObjectId>> {
+    Ok(perform_inner(repo, graph, Kind::Amend, None, true)?.and_then(|outcome| outcome.selected))
+}
+
+pub(crate) fn amend_index_reporting(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+) -> Result<Option<rebase::Outcome>> {
     perform_inner(repo, graph, Kind::Amend, None, true)
 }
 
@@ -31,7 +47,7 @@ fn perform_inner(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
     index_only: bool,
-) -> Result<Option<ObjectId>> {
+) -> Result<Option<rebase::Outcome>> {
     let head = repo
         .head_id()
         .context("editing requires an existing HEAD commit")?
@@ -118,7 +134,7 @@ fn perform_inner(
         }
         _ => rebase::perform(&repo, graph, edit, signature, tree_mode)?,
     };
-    Ok(performed.complete()?.selected)
+    Ok(Some(performed.complete()?))
 }
 
 fn amend_path_tree(
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 7cac41a1c6e..b48c3763cd8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -259,9 +259,17 @@ pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
     pub checkout_reference: Option<gix::refs::FullName>,
     pub deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
+    pub ref_rewrites: Vec<RefRewrite>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RefRewrite {
+    pub name: gix::refs::FullName,
+    pub old: ObjectId,
+    pub new: ObjectId,
+}
+
 impl Outcome {
     pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
         self.rewritten.get(&id).copied().unwrap_or(Some(id))
@@ -303,6 +311,7 @@ impl Conflict {
             merged_tree: self.merged_tree,
             commit: self.commit,
             deferred_ref_deletions: outcome.deferred_ref_deletions,
+            ref_rewrites: outcome.ref_rewrites,
             rewritten: outcome.rewritten,
         })
     }
@@ -314,6 +323,7 @@ pub(crate) struct PersistedConflict {
     merged_tree: ObjectId,
     pub(crate) commit: ObjectId,
     pub(crate) deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
+    pub(crate) ref_rewrites: Vec<RefRewrite>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
@@ -1315,7 +1325,7 @@ impl Prepared {
                 !defer
             });
         }
-        let rollback_refs = update_refs(
+        let updated_refs = update_refs(
             &self.repo,
             &self.rewritten,
             self.root.is_none(),
@@ -1332,7 +1342,7 @@ impl Prepared {
                     &self.repo,
                     &self.committer,
                     &transitions[..transitioned],
-                    &rollback_refs,
+                    &updated_refs.rollback,
                     err,
                 );
             }
@@ -1345,13 +1355,14 @@ impl Prepared {
                         err = err.context(format!("index rollback failed: {restore}"));
                     }
                 }
-                return rollback(&self.repo, &self.committer, &transitions, &rollback_refs, err);
+                return rollback(&self.repo, &self.committer, &transitions, &updated_refs.rollback, err);
             }
         }
         Ok(Outcome {
             selected: self.selected,
             checkout_reference: self.checkout_reference.clone(),
             deferred_ref_deletions,
+            ref_rewrites: updated_refs.rewritten,
             rewritten: std::mem::take(&mut self.rewritten),
         })
     }
@@ -1892,10 +1903,11 @@ fn update_refs(
     expected_refs: Option<Vec<ExpectedRef>>,
     resources: (&[ObjectId], &[(gix::refs::FullName, Target)]),
     stash_edits: super::stash::RewriteEdits,
-) -> Result<Vec<RefEdit>> {
+) -> Result<UpdatedRefs> {
     let (pins, delete_refs) = resources;
     let mut edits = stash_edits.forward;
     let mut rollback = stash_edits.rollback;
+    let mut ref_rewrites = Vec::new();
     if let Some(expected_refs) = expected_refs {
         for ExpectedRef { name, old, new, .. } in expected_refs {
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
@@ -1904,6 +1916,13 @@ fn update_refs(
             if old == new {
                 continue;
             }
+            if let (Some(old), Some(new)) = (old, new) {
+                ref_rewrites.push(RefRewrite {
+                    name: name.clone(),
+                    old,
+                    new,
+                });
+            }
             edits.push(ref_edit(name.clone(), old, new));
             rollback.push(ref_edit(name, new, old));
         }
@@ -1928,6 +1947,13 @@ fn update_refs(
             if delete_refs.iter().any(|(delete, _)| delete == &name) {
                 continue;
             }
+            if let Some(new) = *new {
+                ref_rewrites.push(RefRewrite {
+                    name: name.clone(),
+                    old,
+                    new,
+                });
+            }
             edits.push(ref_edit(name.clone(), Some(old), *new));
             rollback.push(ref_edit(name, *new, Some(old)));
         }
@@ -1936,6 +1962,13 @@ fn update_refs(
             && let Some(new) = rewritten.get(&old)
         {
             let name = head.name().to_owned();
+            if let Some(new) = *new {
+                ref_rewrites.push(RefRewrite {
+                    name: name.clone(),
+                    old,
+                    new,
+                });
+            }
             edits.push(ref_edit(name.clone(), Some(old), *new));
             rollback.push(ref_edit(name, *new, Some(old)));
         }
@@ -2007,12 +2040,23 @@ fn update_refs(
         });
     }
     if edits.is_empty() {
-        return Ok(Vec::new());
+        return Ok(UpdatedRefs::default());
     }
     let mut time = gix::date::parse::TimeBuf::default();
     repo.edit_references_as(edits, Some(committer.to_ref(&mut time)))
         .context("could not update references after rebasing")?;
-    Ok(rollback)
+    ref_rewrites.sort_by(|a, b| a.name.cmp(&b.name));
+    ref_rewrites.dedup();
+    Ok(UpdatedRefs {
+        rollback,
+        rewritten: ref_rewrites,
+    })
+}
+
+#[derive(Default)]
+struct UpdatedRefs {
+    rollback: Vec<RefEdit>,
+    rewritten: Vec<RefRewrite>,
 }
 
 fn pin_name(
@@ -2127,6 +2171,12 @@ mod tests {
         let new_middle = outcome.selected.expect("replacement selects the rewritten commit");
         let new_tip = repo.head_id()?.detach();
         assert_ne!(new_tip, old_tip, "the descendant is rewritten");
+        assert!(
+            outcome.ref_rewrites.iter().any(|rewrite| {
+                rewrite.name.as_bstr() == b"refs/heads/main" && rewrite.old == old_tip && rewrite.new == new_tip
+            }),
+            "the successful branch transaction reports its old and final descendant IDs"
+        );
         assert_eq!(
             repo.find_commit(new_tip)?.parent_ids().next().map(gix::Id::detach),
             Some(new_middle),
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 30b99339631..2a8fb8eef12 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -27,6 +27,7 @@ pub(super) struct Edit<'a> {
 pub(crate) struct Outcome {
     pub commit: Option<gix::ObjectId>,
     pub enrichment: Option<crate::enrich::Enrichment>,
+    pub ref_rewrites: Vec<rebase::RefRewrite>,
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -115,26 +116,34 @@ pub(crate) fn apply(
         .context("could not own commit after editing")?;
     let author = actor(edit.author, edit.author_time, "author")?;
     let commit_changed = author != commit.author || edit.message != commit.message;
-    let commit = if commit_changed {
+    let rebased = if commit_changed {
         commit.author = author;
         commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
         commit.message = edit.message;
-        apply_commit(&repo, graph, old_id, commit)?
+        Some(apply_commit(&repo, graph, old_id, commit)?)
     } else {
         None
     };
+    let commit = rebased
+        .as_ref()
+        .and_then(|outcome| outcome.selected)
+        .filter(|new_id| *new_id != old_id);
     let enrichment = crate::enrich::apply_headers(&repo, commit.unwrap_or(old_id), &edit.enrichment)?;
-    Ok(Outcome { commit, enrichment })
+    Ok(Outcome {
+        commit,
+        enrichment,
+        ref_rewrites: rebased.map_or_else(Vec::new, |outcome| outcome.ref_rewrites),
+    })
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %old_id))]
-pub(crate) fn apply_message(
+pub(crate) fn apply_message_reporting(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     old_id: gix::ObjectId,
     message: &[u8],
     author: Option<&[u8]>,
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<Outcome> {
     let message = cleanup_message(message, None);
     if message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
@@ -150,13 +159,22 @@ pub(crate) fn apply_message(
         .map(|author| actor(author, commit.author.time, "author"))
         .transpose()?;
     if commit.message == message && changed_author.as_ref().is_none_or(|author| *author == commit.author) {
-        return Ok(None);
+        return Ok(Outcome {
+            commit: None,
+            enrichment: None,
+            ref_rewrites: Vec::new(),
+        });
     }
     if let Some(author) = changed_author {
         commit.author = author;
     }
     commit.message = message;
-    apply_commit(&repo, graph, old_id, commit)
+    let outcome = apply_commit(&repo, graph, old_id, commit)?;
+    Ok(Outcome {
+        commit: outcome.selected.filter(|new_id| *new_id != old_id),
+        enrichment: None,
+        ref_rewrites: outcome.ref_rewrites,
+    })
 }
 
 fn apply_commit(
@@ -164,16 +182,15 @@ fn apply_commit(
     graph: &crate::history::HistoryGraph,
     old_id: gix::ObjectId,
     commit: gix::objs::Commit,
-) -> Result<Option<gix::ObjectId>> {
-    let outcome = rebase::perform(
+) -> Result<rebase::Outcome> {
+    rebase::perform(
         repo,
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
     )?
-    .complete()?;
-    Ok(outcome.selected.filter(|new_id| *new_id != old_id))
+    .complete()
 }
 
 pub(super) fn write_headers(
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index eb6171b9e17..2705d8aef6d 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -68,18 +68,29 @@ pub(crate) fn prepare(mut repo: gix::Repository) -> Result<Prepared> {
 
 #[tracing::instrument(skip_all, fields(target = %prepared.target))]
 pub(crate) fn apply(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    apply_reporting(repo, graph, prepared, edited)?
+        .selected
+        .context("splitting HEAD did not produce a selection")
+}
+
+pub(crate) fn apply_reporting(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     edited: &[u8],
-) -> Result<ObjectId> {
+) -> Result<rebase::Outcome> {
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
     repo.objects
         .set_object_memory(std::mem::take(&mut prepared.create.objects));
     let (mut upper, enrichment) = create::commit_from_edit(&prepared.create, edited)?;
     upper.tree = prepared.tree;
-    let id = rebase::perform(
+    let outcome = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Split {
@@ -90,13 +101,12 @@ pub(crate) fn apply(
         rebase::Signature::InvalidateExisting,
         rebase::Tree::LeaveAsIsAndMark,
     )?
-    .complete()?
-    .selected
-    .context("splitting HEAD did not produce a selection")?;
+    .complete()?;
+    let id = outcome.selected.context("splitting HEAD did not produce a selection")?;
     drop(repo);
     crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
         .context("the commit was split, but its enrichment could not be saved")?;
-    Ok(id)
+    Ok(outcome)
 }
 
 #[cfg(test)]
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 2d298cdf09b..17a7d236f5d 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -22,7 +22,10 @@ use crate::{history, open_repository};
 use super::stash::SavedStash;
 
 pub(crate) enum Perform {
-    Complete(Option<String>),
+    Complete {
+        notice: Option<String>,
+        ref_rewrites: Vec<super::rebase::RefRewrite>,
+    },
     Conflict(Conflict),
 }
 
@@ -30,7 +33,7 @@ impl Perform {
     #[cfg(test)]
     pub(crate) fn complete(self) -> Result<Option<String>> {
         match self {
-            Perform::Complete(notice) => Ok(notice),
+            Perform::Complete { notice, .. } => Ok(notice),
             Perform::Conflict(_) => anyhow::bail!("time-travel unexpectedly suspended on a conflict"),
         }
     }
@@ -42,6 +45,7 @@ pub(crate) struct Conflict {
     bare: bool,
     revisions: Vec<OsString>,
     include_worktrees: bool,
+    ref_rewrites: Vec<super::rebase::RefRewrite>,
 }
 
 impl Conflict {
@@ -50,8 +54,10 @@ impl Conflict {
     }
 
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
-    pub(crate) fn accept(self) -> Result<(String, ObjectId)> {
+    pub(crate) fn accept(self) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
         let mut conflict = self.rebase.persist()?;
+        let mut ref_rewrites = self.ref_rewrites;
+        ref_rewrites.append(&mut conflict.ref_rewrites);
         let notice = move_head_to(
             &self.repository_path,
             self.bare,
@@ -64,7 +70,11 @@ impl Conflict {
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
         conflict.materialize()?;
-        Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
+        Ok((
+            format!("{notice}; ready to resolve conflicts"),
+            conflict.commit,
+            ref_rewrites,
+        ))
     }
 }
 
@@ -75,7 +85,7 @@ pub(crate) fn materialize_plan_conflict(
     bare: bool,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<(String, ObjectId)> {
+) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
     let original = conflict.original();
     let mut conflict = conflict.into_conflict().persist()?;
     let notice = move_head_to(
@@ -91,7 +101,11 @@ pub(crate) fn materialize_plan_conflict(
     delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
     conflict.materialize()?;
     tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
-    Ok((format!("{notice}; ready to resolve conflicts"), conflict.commit))
+    Ok((
+        format!("{notice}; ready to resolve conflicts"),
+        conflict.commit,
+        conflict.ref_rewrites,
+    ))
 }
 
 pub(crate) fn checkout_without_replay(
@@ -353,6 +367,7 @@ pub(crate) fn perform_reporting_rebased(
     let mut completed_graph = None;
     let mut original_ids = HashMap::new();
     let mut review_roots = review_roots.to_vec();
+    let mut ref_rewrites = Vec::new();
     while let Some(base) = pending_base(&repository, selected)? {
         let mut rebased = Vec::new();
         let outcome = super::rebase::perform_reporting_rebased(
@@ -379,9 +394,11 @@ pub(crate) fn perform_reporting_rebased(
                     bare,
                     revisions: revisions.to_vec(),
                     include_worktrees,
+                    ref_rewrites,
                 }));
             }
         };
+        ref_rewrites.extend(outcome.ref_rewrites.iter().cloned());
         for (old, original) in rebased {
             if let Some(new) = outcome.map(old) {
                 original_ids.insert(new, original);
@@ -459,7 +476,7 @@ pub(crate) fn perform_reporting_rebased(
             super::stash::apply(repository_path, bare, &workdir, stash)?,
         );
     }
-    Ok(Perform::Complete(notice))
+    Ok(Perform::Complete { notice, ref_rewrites })
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -1512,7 +1529,7 @@ mod tests {
             "preparing the exact merge result changes no repository state"
         );
 
-        let (_notice, conflict_id) = conflict.accept()?;
+        let (_notice, conflict_id, _) = conflict.accept()?;
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_id()?.detach(),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 737bd04517e..5f36de532aa 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1820,7 +1820,7 @@ fn event_loop(
                     .expect("a pending conflict was checked before accepting it");
                 let original = conflict.original();
                 match conflict.accept() {
-                    Ok((notice, id)) => {
+                    Ok((notice, id, _)) => {
                         tracing::info!(commit_id = %original, rewritten_id = %id, "accepted suspended rebase conflict");
                         app.begin_conflict_resolution();
                         app.leave_attention(notice);
@@ -1876,7 +1876,7 @@ fn event_loop(
                     &revisions,
                     false,
                 ) {
-                    Ok((notice, id)) => {
+                    Ok((notice, id, _)) => {
                         pending_todo_rebase_plan = Some(plan);
                         app.begin_conflict_resolution();
                         app.arm_rebase_continuation();
@@ -2224,7 +2224,7 @@ fn event_loop(
                                     )
                                 });
                             match travel {
-                                Ok(edit::time_travel::Perform::Complete(notice)) => {
+                                Ok(edit::time_travel::Perform::Complete { notice, .. }) => {
                                     app.leave_success(notice.map_or_else(
                                         || format!("created fork {}", new_id.to_hex_with_len(7)),
                                         |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
@@ -2597,7 +2597,9 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(edit::time_travel::Perform::Complete(Some(notice))) => {
+                        Ok(edit::time_travel::Perform::Complete {
+                            notice: Some(notice), ..
+                        }) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
                             app.leave_success(notice);
                             if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
@@ -2608,7 +2610,7 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Ok(edit::time_travel::Perform::Complete(None)) => {}
+                        Ok(edit::time_travel::Perform::Complete { notice: None, .. }) => {}
                         Ok(edit::time_travel::Perform::Conflict(conflict)) => {
                             let original = conflict.original();
                             app.arm_rebase_conflict(original);
@@ -4060,11 +4062,11 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    match mode {
-        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited),
-        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited),
-    }
-    .map(Some)
+    let id = match mode {
+        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited)?,
+        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited)?,
+    };
+    Ok(Some(id))
 }
 
 #[tracing::instrument(skip_all)]

From 3f9f2f24912c418d3ced4245028d61cdde19449e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Mon, 17 Aug 2026 22:09:06 +0200
Subject: [PATCH 199/282] fix: move the ref-tree cursor page-wise

Full- and half-page keys previously panned only the ref-tree viewport, unlike the same navigation in history where selection advances.

Choose the nearest selectable node at the requested vertical viewport distance and keep it visible. Page and Ctrl aliases share the behavior, while mouse scrolling and explicit Shift-direction panning remain cursor-independent.
---
 gix-tix/spec.md         |  6 ++-
 gix-tix/src/ref_tree.rs | 88 ++++++++++++++++++++++++++++++++++++++---
 2 files changed, 86 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3ee1f3dce76..eeb899d8af4 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -277,8 +277,10 @@ without trading responsiveness for metadata that is not visible.
   Topological Up moves toward leaves, Down toward roots, and Left/Right chooses
   a remembered child; `i/n` and an emphasized edge show the choice.
 - `g` selects the top ref-tree node, and `Shift-G` selects the root of the current
-  component. Shift-modified directions pan the ref-tree viewport; mouse and the existing
-  Ctrl/Page keys scroll without moving the ref-tree cursor.
+  component. Shift-modified directions and the mouse pan the ref-tree viewport.
+  The existing full- and half-page Ctrl/Page keys move the cursor by the
+  corresponding viewport distance and keep it visible, matching history
+  navigation.
 - `e` opens node-level reference editing. `d` deletes every eligible local branch
   immediately. `e r` is offered only when selected remote-tracking references
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 8efcd2b67f2..525ed14533a 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -363,21 +363,21 @@ impl Tree {
         if key.modifiers.contains(KeyModifiers::CONTROL) {
             let amount = self.offset().page_height.max(1);
             match key.code {
-                KeyCode::Char('u') => self.pan(Direction::Up, (amount / 2).max(1)),
-                KeyCode::Char('d') => self.pan(Direction::Down, (amount / 2).max(1)),
-                KeyCode::Char('b') => self.pan(Direction::Up, amount),
-                KeyCode::Char('f') => self.pan(Direction::Down, amount),
+                KeyCode::Char('u') => self.page(Direction::Up, (amount / 2).max(1)),
+                KeyCode::Char('d') => self.page(Direction::Down, (amount / 2).max(1)),
+                KeyCode::Char('b') => self.page(Direction::Up, amount),
+                KeyCode::Char('f') => self.page(Direction::Down, amount),
                 _ => return Input::Handled,
             }
             return Input::Handled;
         }
         match key.code {
             KeyCode::PageUp => {
-                self.pan(Direction::Up, self.offset().page_height.max(1));
+                self.page(Direction::Up, self.offset().page_height.max(1));
                 return Input::Handled;
             }
             KeyCode::PageDown => {
-                self.pan(Direction::Down, self.offset().page_height.max(1));
+                self.page(Direction::Down, self.offset().page_height.max(1));
                 return Input::Handled;
             }
             _ => {}
@@ -748,6 +748,46 @@ impl Tree {
         self.ensure_visible = false;
     }
 
+    fn page(&mut self, direction: Direction, amount: usize) {
+        let (Some(overview), Some(selected)) = (self.overview.as_ref(), self.selected) else {
+            return;
+        };
+        let temporary;
+        let placed = match self.placed.as_ref() {
+            Some(placed) => placed,
+            None => {
+                temporary = place_rail(overview, self.overlay.as_ref());
+                &temporary
+            }
+        };
+        let source = placed.nodes[selected];
+        let target = match direction {
+            Direction::Up => source.y.saturating_sub(amount),
+            Direction::Down => source.y.saturating_add(amount),
+            Direction::Left | Direction::Right => return,
+        };
+        let next = placed
+            .nodes
+            .iter()
+            .copied()
+            .enumerate()
+            .filter(|(index, point)| {
+                *index != selected
+                    && match direction {
+                        Direction::Up => point.y < source.y,
+                        Direction::Down => point.y > source.y,
+                        Direction::Left | Direction::Right => false,
+                    }
+            })
+            .min_by_key(|(index, point)| (point.y.abs_diff(target), point.x.abs_diff(source.x), *index))
+            .map(|(index, _)| index);
+        if let Some(next) = next {
+            self.selected = Some(next);
+            self.selection_changed();
+            self.ensure_visible = true;
+        }
+    }
+
     fn offset(&self) -> &Offset {
         &self.offset
     }
@@ -2196,6 +2236,42 @@ mod tests {
         assert_eq!(tree.selected, Some(root), "shift-modified lowercase g reaches the root");
     }
 
+    #[test]
+    fn page_keys_move_the_cursor_while_mouse_scrolling_only_pans() {
+        let (graph, refs, decorations) = fixture();
+        let mut tree = Tree::default();
+        tree.rebuild(&graph, &refs, &decorations);
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        tree.offset.page_height = 4;
+        let points = tree.placed.as_ref().expect("the ref-tree is placed").nodes.clone();
+        let first = points
+            .iter()
+            .enumerate()
+            .min_by_key(|(_, point)| point.y)
+            .map(|(index, _)| index)
+            .expect("the fixture has nodes");
+        tree.selected = Some(first);
+        let first_y = points[first].y;
+
+        tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE));
+        let full_page = tree.selected.expect("PageDown retains a selection");
+        let full_page_y = points[full_page].y;
+        assert!(full_page_y > first_y, "PageDown advances the ref-tree cursor");
+        assert!(tree.ensure_visible, "page navigation keeps the new cursor visible");
+
+        tree.selected = Some(first);
+        tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL));
+        let half_page_y = points[tree.selected.expect("Ctrl-d retains a selection")].y;
+        assert!(
+            half_page_y > first_y && half_page_y <= full_page_y,
+            "half-page navigation advances no farther than a full page"
+        );
+
+        let selected = tree.selected;
+        tree.handle_mouse(MouseEventKind::ScrollDown, 2);
+        assert_eq!(tree.selected, selected, "mouse scrolling remains viewport-only");
+    }
+
     #[test]
     fn enter_pins_every_visible_reference_kind_but_not_synthetic_nodes() {
         let (graph, refs, mut decorations) = fixture();

From f211ac21d36344e06a9a5e2ce0539ad4dd376763 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 05:45:24 +0200
Subject: [PATCH 200/282] change: remove WIP author choices from commit editors

Todo and Message enrichment headers supersede the commented provisional-author choice. Remove the option from the shared document writer and parser so new, fork, and split editors expose only their configured author, and update the specification and regression coverage accordingly.
---
 gix-tix/spec.md            |  7 ++---
 gix-tix/src/edit/create.rs | 11 ++++---
 gix-tix/src/edit/reword.rs | 62 +++-----------------------------------
 gix-tix/src/edit/split.rs  | 10 +++---
 4 files changed, 18 insertions(+), 72 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index eeb899d8af4..7948aaedc72 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -606,9 +606,7 @@ space first; changes blocks adapt within the remaining history width.
   to its parent; `new-empty` deliberately reuses it.
 - The Markdown editor buffer contains editable identities and dates, a `what`
   title, a `why` body, optional attribution trailers, and a commented Git-style
-  per-path diffstat with signed net line counts. A commented
-  `Author: 🚧WIP🚧 <wip@invalid>` directly below the configured author can be
-  uncommented to select it instead. Commit hooks are not run.
+  per-path diffstat with signed net line counts. Commit hooks are not run.
 - After editing, tix revalidates the destination, applies configured signing,
   marks linear descendants for lazy replay, persists the prepared objects, and atomically
   advances mutable refs throughout the rewritten stack. This includes local
@@ -667,8 +665,7 @@ space first; changes blocks adapt within the remaining history width.
   changes abort without writing objects or changing refs, the index, or files.
 - `tix split` performs the same split at `HEAD`: worktree changes are amended
   into the source commit and staged index changes become the new commit on top.
-  Its upper-commit editor offers the same commented WIP author override as the
-  new-commit editor, including its enrichment headers.
+  Its upper-commit editor uses the same enrichment headers as the new-commit editor.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Their final trees and ancestry
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 9ab139fb472..860299d20ee 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -130,7 +130,6 @@ fn prepare_inner(
         &mut document,
         &author,
         &committer,
-        Some(reword::WIP_AUTHOR),
         &crate::enrich::Enrichment::default(),
     )?;
     document.extend_from_slice(b"\nwhat\n\nwhy\n");
@@ -429,12 +428,14 @@ mod tests {
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let objects_before = object_count(fixture.path())?;
         let prepared = prepare(open(fixture.path())?, Some(parent))?;
-        assert!(
+        assert_eq!(
             prepared
                 .document
-                .windows(b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>".len())
-                .any(|window| window == b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>"),
-            "new-commit editors offer the provisional author"
+                .split(|byte| *byte == b'\n')
+                .filter(|line| line.strip_prefix(b";").unwrap_or(line).starts_with(b"Author: "))
+                .count(),
+            1,
+            "new-commit editors contain only the configured author"
         );
         assert!(
             prepared
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 2a8fb8eef12..8abcab80ceb 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -11,7 +11,6 @@ const COMMENT_CHAR: &[u8] = b"CommentChar: ";
 const MESSAGE: &[u8] = b"Message:";
 const TODO: &[u8] = b"Todo";
 pub(super) const DEFAULT_COMMENT_CHAR: &[u8] = b";";
-pub(super) const WIP_AUTHOR: &[u8] = b"\xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>";
 pub(super) const ASSISTED_BY: &[u8] = b"Assisted-by: GPT 5.6";
 pub(super) const CO_AUTHORED_BY: &[u8] = b"Co-authored-by: GPT 5.6 <codex@openai.com>";
 
@@ -60,7 +59,7 @@ pub(crate) fn document_with_author(
     let enrichment = crate::enrich::load(&mut crate::enrich::open(repo)?, crate::change_id::for_commit(repo, id)?)?;
 
     let mut out = Vec::new();
-    write_headers(&mut out, &commit.author, &committer, None, &enrichment)?;
+    write_headers(&mut out, &commit.author, &committer, &enrichment)?;
     out.push(b'\n');
     out.extend_from_slice(&commit.message);
     if !out.ends_with(b"\n") {
@@ -197,16 +196,9 @@ pub(super) fn write_headers(
     out: &mut Vec<u8>,
     author: &gix::actor::Signature,
     committer: &gix::actor::Signature,
-    alternative_author: Option<&[u8]>,
     enrichment: &crate::enrich::Enrichment,
 ) -> Result<()> {
     write_actor(out, AUTHOR, author);
-    if let Some(alternative_author) = alternative_author {
-        out.extend_from_slice(DEFAULT_COMMENT_CHAR);
-        out.extend_from_slice(AUTHOR);
-        out.extend_from_slice(alternative_author);
-        out.push(b'\n');
-    }
     write_date(out, AUTHOR_DATE, author.time)?;
     write_actor(out, COMMITTER, committer);
     write_date(out, COMMITTER_DATE, committer.time)?;
@@ -250,30 +242,9 @@ fn write_date(out: &mut Vec<u8>, label: &[u8], time: gix::date::Time) -> Result<
 }
 
 pub(super) fn parse(input: &[u8]) -> Result<Edit<'_>> {
-    let has_alternative_author = input
-        .splitn(3, |byte| *byte == b'\n')
-        .nth(1)
-        .map(trim_cr)
-        .is_some_and(|line| {
-            line.starts_with(AUTHOR)
-                || line
-                    .strip_prefix(DEFAULT_COMMENT_CHAR)
-                    .is_some_and(|line| line.starts_with(AUTHOR))
-        });
-    let mut parts = input.splitn(6 + usize::from(has_alternative_author), |byte| *byte == b'\n');
-    let mut author = header(parts.next(), AUTHOR)?;
-    let mut line = parts.next();
-    if line
-        .map(trim_cr)
-        .and_then(|line| line.strip_prefix(DEFAULT_COMMENT_CHAR))
-        .is_some_and(|line| line.starts_with(AUTHOR))
-    {
-        line = parts.next();
-    } else if line.map(trim_cr).is_some_and(|line| line.starts_with(AUTHOR)) {
-        author = header(line, AUTHOR)?;
-        line = parts.next();
-    }
-    let author_time = date(header(line, AUTHOR_DATE)?, "author")?;
+    let mut parts = input.splitn(6, |byte| *byte == b'\n');
+    let author = header(parts.next(), AUTHOR)?;
+    let author_time = date(header(parts.next(), AUTHOR_DATE)?, "author")?;
     let committer = header(parts.next(), COMMITTER)?;
     let committer_time = date(header(parts.next(), COMMITTER_DATE)?, "committer")?;
     let comment_char = header(parts.next(), COMMENT_CHAR)?;
@@ -419,31 +390,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn a_commented_alternative_author_can_be_selected_by_uncommenting_it() -> gix_testtools::Result {
-        let input = b"Author: Default <default@example.com>\n\
-                      ;Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>\n\
-                      AuthorDate: 2026-08-12 10:20:30 +0200\n\
-                      Committer: C <c@example.com>\n\
-                      CommitterDate: 2026-08-12 11:20:30 +0200\n\
-                      CommentChar: ;\n\
-                      \n\
-                      title\n";
-
-        assert_eq!(
-            parse(input)?.author,
-            b"Default <default@example.com>",
-            "the commented alternative leaves the configured author active"
-        );
-        let selected = input.replacen(b";Author: ", b"Author: ", 1);
-        assert_eq!(
-            parse(&selected)?.author,
-            "🚧WIP🚧 <wip@invalid>".as_bytes(),
-            "uncommenting the offered author is sufficient to select it"
-        );
-        Ok(())
-    }
-
     #[test]
     fn document_does_not_repeat_existing_agent_trailers() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 2705d8aef6d..d2c88f506eb 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -143,12 +143,14 @@ mod tests {
         }
         let before = gix_testtools::repository::snapshot(fixture.path())?;
         let prepared = prepare(open(fixture.path())?)?;
-        assert!(
+        assert_eq!(
             prepared
                 .document
-                .windows(b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>".len())
-                .any(|window| window == b";Author: \xf0\x9f\x9a\xa7WIP\xf0\x9f\x9a\xa7 <wip@invalid>"),
-            "split editors offer the provisional author"
+                .split(|byte| *byte == b'\n')
+                .filter(|line| line.strip_prefix(b";").unwrap_or(line).starts_with(b"Author: "))
+                .count(),
+            1,
+            "split editors contain only the configured author"
         );
         assert!(
             prepared

From 9f90e2e3d65ff0000d319ae19cc152e7733e9ca7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 05:55:38 +0200
Subject: [PATCH 201/282] feat: show and resolve abbreviated change IDs

Expose unambiguous seven-character change IDs beside commit hashes in plain history output and accept reverse-hex prefixes in travel and reword commands. Resolve Git syntax first and scope change-ID fallback to the default Tix view so unrelated repository history cannot silently broaden mutation targets.
---
 gix-tix/spec.md               | 23 +++++----
 gix-tix/src/change_id.rs      | 91 +++++++++++++++++++++++++++++++++++
 gix-tix/src/command.rs        | 59 ++++++++++++++++++++++-
 gix-tix/src/command/reword.rs | 21 ++++----
 gix-tix/src/command/travel.rs | 21 ++++----
 gix-tix/src/history.rs        |  4 ++
 gix-tix/src/ui.rs             | 15 +++---
 7 files changed, 193 insertions(+), 41 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7948aaedc72..93a58015256 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -17,16 +17,20 @@ without trading responsiveness for metadata that is not visible.
   history view without opening a terminal UI. Tips default to `HEAD`, and
   applicable pins participate exactly as they do in the history view. Output
   uses the history view's graph lanes and default metadata, without colors,
-  selection, clipping, or a footer.
+  selection, clipping, or a footer. Each seven-character commit hash is followed
+  by its seven-character reverse-hex change ID when that prefix identifies
+  exactly one commit in this invocation; colliding or duplicated change IDs are
+  omitted.
 - `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
   checkout, pending-rebase replay, stash handling, and pin reconciliation as
-  TUI time travel. Travelling to the current `HEAD` is a no-op. A detached
-  source may travel to a descendant without a pin, but travelling to an ancestor
-  or unrelated commit requires an existing current-worktree pin at `HEAD` or a
-  descendant. An attached source is preserved through the singleton HEAD-pin
-  rules. Replay conflicts change nothing unless explicitly materialized; an
-  accepted conflict writes the checkout and unmerged index, then exits with an
-  error so resolution cannot be mistaken for completion.
+  TUI time travel. Its target may also be an unambiguous reverse-hex change-ID
+  prefix from the default Tix view. Travelling to the current `HEAD` is a no-op.
+  A detached source may travel to a descendant without a pin, but travelling to
+  an ancestor or unrelated commit requires an existing current-worktree pin at
+  `HEAD` or a descendant. An attached source is preserved through the singleton
+  HEAD-pin rules. Replay conflicts change nothing unless explicitly
+  materialized; an accepted conflict writes the checkout and unmerged index,
+  then exits with an error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state at `HEAD` through the same
   commit-stash operation as the TUI.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty]
@@ -50,7 +54,8 @@ without trading responsiveness for metadata that is not visible.
   actor while preserving its date. Without an explicit message it prefills the
   normal editor document; with one it is applied non-interactively. An attached
   `HEAD` may reword itself without a pin. Every other target requires an existing
-  current-worktree tix pin at that commit or a descendant;
+  current-worktree tix pin at that commit or a descendant. As with `tix travel`,
+  an unambiguous default-view change-ID prefix may replace the Git revspec;
   every such covering pin participates so retained forks are rewritten together.
   Eligibility is checked before the editor opens, and an unchanged document is
   an explicit no-op. Editor documents also contain commented `Todo` and
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index 5776d2dc521..857a277e2f6 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -1,4 +1,5 @@
 use std::{
+    cmp::Ordering as CmpOrdering,
     collections::{HashMap, HashSet},
     sync::atomic::{AtomicBool, Ordering},
 };
@@ -26,6 +27,57 @@ pub(crate) fn for_commit(repo: &gix::Repository, id: ObjectId) -> Result<ChangeI
     Ok(effective(id, commit.extra_headers().find_all(HEADER)))
 }
 
+pub(crate) fn abbreviations(
+    repo: &gix::Repository,
+    ids: impl IntoIterator<Item = ObjectId>,
+    len: usize,
+) -> Result<HashMap<ObjectId, ChangeId>> {
+    let values = ids
+        .into_iter()
+        .map(|id| Ok((id, for_commit(repo, id)?)))
+        .collect::<Result<Vec<_>>>()?;
+    Ok(unique_abbreviations(values, len))
+}
+
+pub(crate) fn resolve_prefix(
+    repo: &gix::Repository,
+    prefix: &str,
+    ids: impl IntoIterator<Item = ObjectId>,
+) -> Result<Option<ObjectId>> {
+    let Ok(prefix) = gix::hash::Prefix::from_reverse_hex(prefix) else {
+        return Ok(None);
+    };
+    let mut found = None;
+    for id in ids {
+        let change_id = for_commit(repo, id)?;
+        if prefix.cmp_oid(&change_id) != CmpOrdering::Equal {
+            continue;
+        }
+        if found.replace(id).is_some() {
+            anyhow::bail!(
+                "change ID prefix {} is ambiguous in the default Tix view",
+                prefix.to_reverse_hex()
+            );
+        }
+    }
+    Ok(found)
+}
+
+fn unique_abbreviations(
+    values: impl IntoIterator<Item = (ObjectId, ChangeId)>,
+    len: usize,
+) -> HashMap<ObjectId, ChangeId> {
+    let mut by_prefix = HashMap::<String, Option<(ObjectId, ChangeId)>>::new();
+    for (id, change_id) in values {
+        let prefix = change_id.to_reverse_hex_with_len(len).to_string();
+        by_prefix
+            .entry(prefix)
+            .and_modify(|entry| *entry = None)
+            .or_insert(Some((id, change_id)));
+    }
+    by_prefix.into_values().flatten().collect()
+}
+
 pub(crate) fn inherit(repo: &gix::Repository, commit: &mut gix::objs::Commit, predecessor: ObjectId) -> Result<()> {
     let change_id = for_commit(repo, predecessor).context("could not preserve predecessor change ID")?;
     store(commit, change_id);
@@ -104,6 +156,29 @@ mod tests {
         );
     }
 
+    #[test]
+    fn abbreviates_only_unique_prefixes() -> gix_testtools::Result {
+        let shared_a = ChangeId::from_reverse_hex(format!("zzzzzzz{}", "k".repeat(33)).as_bytes())?;
+        let shared_b = ChangeId::from_reverse_hex(format!("zzzzzzz{}", "l".repeat(33)).as_bytes())?;
+        let duplicate = ChangeId::from_reverse_hex(format!("yyyyyyy{}", "m".repeat(33)).as_bytes())?;
+        let unique = ChangeId::from_reverse_hex(format!("xxxxxxx{}", "n".repeat(33)).as_bytes())?;
+        assert_eq!(
+            unique_abbreviations(
+                [
+                    (id(1), shared_a),
+                    (id(2), shared_b),
+                    (id(3), duplicate),
+                    (id(4), duplicate),
+                    (id(5), unique),
+                ],
+                7,
+            ),
+            HashMap::from([(id(5), unique)]),
+            "prefix collisions and complete duplicates are omitted"
+        );
+        Ok(())
+    }
+
     #[test]
     fn scans_the_whole_scene_for_duplicate_identities() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -115,6 +190,22 @@ mod tests {
             .push((HEADER.into(), ChangeId::from(predecessor).to_string().into()));
         let duplicate = repo.write_object(&duplicate)?.detach();
 
+        let prefix = ChangeId::from(predecessor).to_reverse_hex_with_len(7).to_string();
+        assert_eq!(
+            resolve_prefix(&repo, &prefix, [predecessor])?,
+            Some(predecessor),
+            "a unique default-view change ID resolves"
+        );
+        assert!(
+            format!(
+                "{:#}",
+                resolve_prefix(&repo, &prefix, [predecessor, duplicate])
+                    .expect_err("two commits sharing a change ID are ambiguous")
+            )
+            .contains("ambiguous"),
+            "ambiguity is reported explicitly"
+        );
+
         let mut successor = repo.find_commit(duplicate)?.decode()?.into_owned()?;
         successor.extra_headers.clear();
         inherit(&repo, &mut successor, duplicate)?;
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 8f1cdfdac08..875f065b5dc 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -1,4 +1,9 @@
-use std::{collections::HashSet, ffi::OsString, io::Write, sync::atomic::AtomicBool};
+use std::{
+    collections::HashSet,
+    ffi::{OsStr, OsString},
+    io::Write,
+    sync::atomic::AtomicBool,
+};
 
 use anyhow::{Context, Result};
 use clap::Parser;
@@ -294,6 +299,8 @@ fn write_history(
         }
     }
 
+    let change_ids = crate::change_id::abbreviations(repository, app.rows.iter().map(|row| row.id), 7)?;
+
     let mailmap = repository.open_mailmap();
     let lanes = app.render_lanes(0..app.rows.len());
     let enrichment_gutter = app
@@ -309,7 +316,14 @@ fn write_history(
         .max()
         .unwrap_or_default();
     for (index, row) in app.rows.iter().enumerate() {
-        let metadata = crate::ui::plain_history_metadata(&app, row, &decorations, &mailmap, note_ids.contains(&row.id));
+        let metadata = crate::ui::plain_history_metadata(
+            &app,
+            row,
+            &decorations,
+            &mailmap,
+            note_ids.contains(&row.id),
+            change_ids.get(&row.id).copied(),
+        );
         if enrichment_gutter != 0 {
             let marker = crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
             write!(
@@ -328,6 +342,38 @@ fn write_history(
     Ok(())
 }
 
+fn resolve_commit(
+    repository: &gix::Repository,
+    revision: &OsStr,
+    description: &str,
+) -> Result<(gix::ObjectId, Option<crate::history::HistoryGraph>)> {
+    let revision = gix::path::os_str_into_bstr(revision)
+        .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
+    match repository.rev_parse_single(revision) {
+        Ok(id) => {
+            let id = id
+                .object()
+                .with_context(|| format!("could not read {description}"))?
+                .peel_to_commit()
+                .with_context(|| format!("{description} does not resolve to a commit"))?
+                .id;
+            Ok((id, None))
+        }
+        Err(revision_error) => {
+            let graph = crate::edit::loaded_view_graph(repository)?;
+            let resolved = std::str::from_utf8(revision)
+                .ok()
+                .map(|prefix| crate::change_id::resolve_prefix(repository, prefix, graph.commit_ids()))
+                .transpose()?
+                .flatten();
+            match resolved {
+                Some(id) => Ok((id, Some(graph))),
+                None => Err(revision_error).with_context(|| format!("could not resolve {description} {revision:?}")),
+            }
+        }
+    }
+}
+
 fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
     for pin in create_pins(repository, &args.revisions)? {
         println!("{}", display_pin(repository, &pin)?);
@@ -880,6 +926,7 @@ mod tests {
         assert!(format!("{err:#}").contains("at least one -x/--hide"));
         create_pins(&repository, &[OsString::from("topic")])?;
         let head = repository.head_id()?.detach();
+        let head_change_id = crate::change_id::for_commit(&repository, head)?;
         assert!(crate::enrich::toggle(&repository, head)?.todo);
 
         let mut output = Vec::new();
@@ -887,6 +934,14 @@ mod tests {
         let output = String::from_utf8(output)?;
 
         assert_eq!(output.lines().count(), 5, "the complete projected history is printed");
+        assert!(
+            output.contains(&format!(
+                "{} {}",
+                head.to_hex_with_len(7),
+                head_change_id.to_reverse_hex_with_len(7)
+            )),
+            "an unambiguous change ID follows its commit hash: {output:?}"
+        );
         assert!(output.contains('●'), "history graph lanes are rendered");
         assert!(
             output.lines().any(|line| line.starts_with("🚧├")),
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 7164bcb126a..6682aff38b5 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -29,16 +29,7 @@ pub(super) struct Args {
 }
 
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
-    let revision = gix::path::os_str_into_bstr(&args.revision)
-        .with_context(|| format!("revision {} is not valid UTF-8", args.revision.to_string_lossy()))?;
-    let target = repository
-        .rev_parse_single(revision)
-        .with_context(|| format!("could not resolve revision {revision:?}"))?
-        .object()
-        .context("could not read reword target")?
-        .peel_to_commit()
-        .context("reword target does not resolve to a commit")?
-        .id;
+    let (target, resolved_graph) = super::resolve_commit(&repository, &args.revision, "reword target")?;
     let head = repository.head().context("could not read HEAD before rewording")?;
     let head_id = head.id().map(gix::Id::detach).context("cannot reword an unborn HEAD")?;
     let attached_head = !head.is_detached() && target == head_id;
@@ -50,7 +41,10 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         pins.iter()
             .map(|pin| gix::path::from_bstr(pin.name.as_bstr()).into_owned().into_os_string()),
     );
-    let graph = crate::edit::loaded_view_graph_with(&repository, &revisions)?;
+    let graph = match resolved_graph {
+        Some(graph) => graph,
+        None => crate::edit::loaded_view_graph_with(&repository, &revisions)?,
+    };
     let covering_pin = pins.iter().any(|pin| graph.is_ancestor(target, pin.id));
     if !attached_head && !covering_pin {
         anyhow::bail!("the reword target or one of its descendants must be pinned");
@@ -332,10 +326,13 @@ mod tests {
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test pin",
         )?;
+        let change_id = crate::change_id::for_commit(&repository, repository.rev_parse_single("HEAD~1")?.detach())?
+            .to_reverse_hex_with_len(7)
+            .to_string();
         drop(repository);
         run(
             open(path, "sed -i.bak -e 's/^middle$/rewritten middle/'")?,
-            args("HEAD~1"),
+            args(&change_id),
         )?;
 
         let repository = crate::test_repository::open(path)?;
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 7ead7455552..44d41a290fd 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -13,16 +13,7 @@ pub(super) struct Args {
 }
 
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
-    let revision = gix::path::os_str_into_bstr(&args.revision)
-        .with_context(|| format!("revision {} is not valid UTF-8", args.revision.to_string_lossy()))?;
-    let selected = repository
-        .rev_parse_single(revision)
-        .with_context(|| format!("could not resolve revision {revision:?}"))?
-        .object()
-        .context("could not read time-travel destination")?
-        .peel_to_commit()
-        .context("time-travel destination does not resolve to a commit")?
-        .id;
+    let (selected, resolved_graph) = super::resolve_commit(&repository, &args.revision, "time-travel destination")?;
     let head = repository.head().context("could not read HEAD before time-travel")?;
     let head_id = head
         .id()
@@ -36,7 +27,10 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     }
 
     let revisions = vec![OsString::from("HEAD"), OsString::from(selected.to_string())];
-    let graph = crate::edit::loaded_view_graph_with(&repository, &revisions)?;
+    let graph = match resolved_graph {
+        Some(graph) => graph,
+        None => crate::edit::loaded_view_graph_with(&repository, &revisions)?,
+    };
     let forward = graph.is_ancestor(head_id, selected);
     if detached && !forward {
         let source_is_pinned = crate::history::all_pins(&repository)?
@@ -104,7 +98,10 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
-        run(repository, args("HEAD~1"))?;
+        let change_id = crate::change_id::for_commit(&repository, middle)?
+            .to_reverse_hex_with_len(7)
+            .to_string();
+        run(repository, args(&change_id))?;
 
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), middle);
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index c33c69e1833..dd6407266e3 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -237,6 +237,10 @@ impl HistoryGraph {
         self.commits.len()
     }
 
+    pub(crate) fn commit_ids(&self) -> impl Iterator<Item = ObjectId> + '_ {
+        self.commits.iter().map(|commit| commit.id)
+    }
+
     pub(crate) fn is_ancestor(&self, ancestor: ObjectId, descendant: ObjectId) -> bool {
         let (Some(ancestor), Some(descendant)) = (self.index(ancestor), self.index(descendant)) else {
             return false;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index b46ae645870..42d021aff47 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -2233,8 +2233,9 @@ pub(crate) fn plain_history_metadata(
     decorations: &Decorations,
     mailmap: &gix::mailmap::Snapshot,
     has_notes: bool,
+    change_id: Option<gix::hash::ChangeId>,
 ) -> String {
-    metadata_line(
+    let mut line = metadata_line(
         row,
         app.title(row),
         app.attributions(row),
@@ -2255,11 +2256,12 @@ pub(crate) fn plain_history_metadata(
             selected: false,
             copy_feedback: None,
         },
-    )
-    .spans
-    .into_iter()
-    .map(|span| span.content.into_owned())
-    .collect()
+    );
+    if let Some(change_id) = change_id {
+        line.spans
+            .insert(1, Span::raw(format!(" {}", change_id.to_reverse_hex_with_len(7))));
+    }
+    line.spans.into_iter().map(|span| span.content.into_owned()).collect()
 }
 
 pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::Snapshot) -> String {
@@ -5995,6 +5997,7 @@ mod tests {
             &Decorations::new(),
             &gix::mailmap::Snapshot::default(),
             false,
+            None,
         );
         assert!(!plain.contains("0101010"), "history rows hide IDs by default");
 

From 1a18591364dde90d15a8f953fccf47df52fbd2c6 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 06:02:38 +0200
Subject: [PATCH 202/282] feat: add tix rebase todo --update-base

Expose the TUI rebase-update behavior through command-line todo generation. Reuse the same hidden local branch update calculation for the uniquely derived fork point, label the selected target as updated-base, and keep unchanged plans actionable while rejecting explicit --onto combinations or missing update targets.
---
 gix-tix/spec.md               |   9 ++-
 gix-tix/src/app.rs            |   4 ++
 gix-tix/src/command.rs        |  11 ++++
 gix-tix/src/command/rebase.rs | 114 +++++++++++++++++++++++++++++-----
 4 files changed, 122 insertions(+), 16 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 93a58015256..28c8c7f03a2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -69,9 +69,14 @@ without trading responsiveness for metadata that is not visible.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
 - `--quit-on-finish` exits after traversal and lane computation, for measurement
   and non-interactive use.
-- `tix rebase todo [-x HIDDEN...] [--no-auto-hide] [--onto REV] [TIP...]`
+- `tix rebase todo [-x HIDDEN...] [--no-auto-hide]
+  [--onto REV | --update-base] [TIP...]`
   writes a self-contained Markdown history-rebase plan to stdout. Visible tips
-  default to `HEAD`, and an ambiguous derived fork point is an error.
+  default to `HEAD`, and an ambiguous derived fork point is an error. With
+  `--update-base`, the uniquely derived fork point is rebased onto the same newer
+  hidden local branch tip offered by TUI `rebase-update`; absence of such a tip
+  is an error. The resulting `(updated-base)` plan remains actionable when saved
+  unchanged. `--update-base` and an explicit `--onto` are mutually exclusive.
   `--edit-and-apply` opens the same plan with Git's configured editor and applies
   it when the editor exits.
 - `tix show` and `tix rebase todo` automatically inspect symbolic
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index fdab25bb1a0..74ac3717c95 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1446,6 +1446,10 @@ impl App {
         self.hidden_branch_updates.get(&id).map(|(behind, _)| *behind)
     }
 
+    pub(crate) fn hidden_branch_update(&self, id: ObjectId) -> Option<ObjectId> {
+        self.hidden_branch_updates.get(&id).map(|(_, target)| *target)
+    }
+
     pub(crate) fn selected_tree_diff_target(&self) -> Option<TreeDiffTarget> {
         let id = self.selected.and_then(|index| self.rows.get(index))?.id;
         Some(match self.hidden_branch_targets.get(&id) {
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 875f065b5dc..dfe87f534e5 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -749,6 +749,17 @@ mod tests {
             .command,
             Some(Command::Rebase(rebase::Command::Todo(_)))
         ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "rebase", "todo", "-x", "main", "--update-base", "topic"])
+                .expect("rebase update todo parses")
+                .platform
+                .command,
+            Some(Command::Rebase(rebase::Command::Todo(_)))
+        ));
+        assert!(
+            Cli::try_parse_from(["tix", "rebase", "todo", "-x", "main", "--onto", "next", "--update-base"]).is_err(),
+            "explicit and inferred rebase targets are mutually exclusive"
+        );
         assert!(matches!(
             Cli::try_parse_from(["tix", "rebase", "apply", "-"])
                 .expect("rebase apply parses")
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 2d5391f896a..1660d4a237b 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -38,8 +38,11 @@ pub(super) struct Todo {
     #[arg(long)]
     no_auto_hide: bool,
     /// Rebase the derived scope onto this commit instead of its fork point.
-    #[arg(long, value_name = "REV")]
+    #[arg(long, value_name = "REV", conflicts_with = "update_base")]
     onto: Option<OsString>,
+    /// Rebase onto the newer hidden local branch tip associated with the fork point.
+    #[arg(long)]
+    update_base: bool,
     /// Open the todo in Git's editor and apply it after the editor exits.
     #[arg(long)]
     edit_and_apply: bool,
@@ -97,12 +100,12 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
             revision.to_string_lossy()
         );
     }
-    let resolved_tips = history::snapshot(repo, &args.tips, &hide, false)?.view_tips;
+    let refs = history::snapshot(repo, &args.tips, &hide, false)?;
 
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
     let mut app = App::new(usize::MAX);
     let mut decorations = Decorations::default();
-    let mut complete = false;
+    let mut graph = None;
     history::load(
         repo,
         &args.tips,
@@ -115,15 +118,14 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
                 Event::Decorations(value) => decorations = value,
                 Event::Commits(commits) => app.extend_commits(commits),
                 Event::HiddenCommits(commits) => app.extend_hidden_commits(commits),
-                Event::Complete(_) => complete = true,
+                Event::Complete(value) => graph = Some(value),
                 Event::VisibleComplete | Event::Cancelled => {}
             }
             true
         },
     )?;
-    if !complete {
-        anyhow::bail!("history traversal did not produce a graph");
-    }
+    let graph = graph.context("history traversal did not produce a graph")?;
+    crate::update_hidden_branch_updates(&mut app, Some(&graph), &refs);
     let mut candidates = app.hidden_rebase_candidates();
     if candidates.len() != 1 {
         if candidates.is_empty() {
@@ -140,12 +142,21 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
         );
     }
     let (base, scope) = candidates.pop().context("one rebase candidate was expected")?;
-    let onto = args
-        .onto
-        .as_deref()
-        .map(|revision| resolve_commit(repo, revision, "onto revision"))
-        .transpose()?
-        .unwrap_or(base);
+    let (onto, onto_kind) = if args.update_base {
+        let onto = app
+            .hidden_branch_update(base)
+            .context("--update-base found no newer hidden local branch tip for the derived base")?;
+        (onto, todo::OntoKind::UpdatedBase)
+    } else {
+        (
+            args.onto
+                .as_deref()
+                .map(|revision| resolve_commit(repo, revision, "onto revision"))
+                .transpose()?
+                .unwrap_or(base),
+            todo::OntoKind::Onto,
+        )
+    };
 
     let mut notes = repo
         .notes()
@@ -194,7 +205,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
             })
         })
         .collect::<Result<Vec<_>>>()?;
-    todo::prepare(repo, base, onto, &commits, &resolved_tips, todo::OntoKind::Onto)
+    todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind)
 }
 
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
@@ -334,6 +345,7 @@ mod tests {
                 hide: vec!["HEAD~2".into()],
                 no_auto_hide: false,
                 onto: None,
+                update_base: false,
                 edit_and_apply: false,
                 tips: Vec::new(),
             },
@@ -361,6 +373,7 @@ mod tests {
                 hide: Vec::new(),
                 no_auto_hide: true,
                 onto: None,
+                update_base: false,
                 edit_and_apply: false,
                 tips: Vec::new(),
             },
@@ -397,6 +410,7 @@ mod tests {
                 hide: Vec::new(),
                 no_auto_hide: false,
                 onto: None,
+                update_base: false,
                 edit_and_apply: false,
                 tips: Vec::new(),
             },
@@ -408,6 +422,77 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn update_base_uses_the_newer_hidden_local_branch_tip() -> gix_testtools::Result {
+        let (fixture, repo) = repository()?;
+        drop(repo);
+        for args in [
+            &["branch", "base", "HEAD~2"][..],
+            &["checkout", "-q", "base"][..],
+            &[
+                "-c",
+                "user.name=updated base",
+                "-c",
+                "user.email=updated@example.com",
+                "-c",
+                "commit.gpgSign=false",
+                "commit",
+                "-q",
+                "--allow-empty",
+                "-m",
+                "updated base",
+            ][..],
+            &["checkout", "-q", "main"][..],
+        ] {
+            let output = Command::new("git").current_dir(fixture.path()).args(args).output()?;
+            assert!(
+                output.status.success(),
+                "git {args:?} prepares the updated base: {}",
+                String::from_utf8_lossy(&output.stderr)
+            );
+        }
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["core.abbrev=7", "user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let updated = repo.rev_parse_single("base")?.detach();
+        let prepared = prepare(
+            &repo,
+            &Todo {
+                hide: vec!["base".into()],
+                no_auto_hide: false,
+                onto: None,
+                update_base: true,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )?;
+        let document = String::from_utf8(prepared.document)?;
+        assert!(
+            prepared.apply_unchanged,
+            "moving to the updated base makes an unchanged todo actionable"
+        );
+        assert!(
+            document.contains(&format!("{} (updated-base)", updated.to_hex_with_len(7))),
+            "the TUI-selected hidden tip is labelled as the updated base: {document}"
+        );
+
+        let err = prepare(
+            &repo,
+            &Todo {
+                hide: vec!["HEAD~2".into()],
+                no_auto_hide: false,
+                onto: None,
+                update_base: true,
+                edit_and_apply: false,
+                tips: Vec::new(),
+            },
+        )
+        .expect_err("a derived revision without a hidden local branch has no update target");
+        assert!(format!("{err:#}").contains("no newer hidden local branch tip"));
+        Ok(())
+    }
+
     #[test]
     fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
@@ -517,6 +602,7 @@ mod tests {
                 hide: vec!["HEAD~2".into()],
                 no_auto_hide: false,
                 onto: None,
+                update_base: false,
                 edit_and_apply: false,
                 tips: Vec::new(),
             },

From 5230a58ea1869fa66d82980fa2a7199ff980f49a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 06:48:57 +0200
Subject: [PATCH 203/282] feat: let edited rebase todos materialize conflicts

Allow tix rebase todo --edit-and-apply to opt into the same conflict materialization and continuation-document workflow already available through tix rebase apply. Require immediate editing when the option is present and retain the existing safe default of leaving conflicts unmaterialized.
---
 gix-tix/spec.md               | 15 +++++++++------
 gix-tix/src/command.rs        |  6 ++++++
 gix-tix/src/command/rebase.rs | 19 +++++++++++++++++--
 3 files changed, 32 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 28c8c7f03a2..f1a31275b35 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -78,7 +78,9 @@ without trading responsiveness for metadata that is not visible.
   is an error. The resulting `(updated-base)` plan remains actionable when saved
   unchanged. `--update-base` and an explicit `--onto` are mutually exclusive.
   `--edit-and-apply` opens the same plan with Git's configured editor and applies
-  it when the editor exits.
+  it when the editor exits. It also accepts `--materialize-conflicts [CONTINUE]`
+  to opt into the same conflict checkout and continuation-document workflow as
+  `tix rebase apply`; the option requires `--edit-and-apply`.
 - `tix show` and `tix rebase todo` automatically inspect symbolic
   `refs/remotes/<remote>/HEAD` references. Their targets are reverse-mapped
   through each remote's fetch refspec, and existing local commit branches are
@@ -911,11 +913,12 @@ space first; changes blocks adapt within the remaining history width.
   without writes.
   Once the index has no unresolved stages, `<enter>` continues; another conflict
   repeats the same choice.
-- Command-line apply reports a conflict without changes unless
-  `--materialize-conflicts` was explicitly supplied. Its continuation document
-  uses the full null object ID for the command whose tree must come from the
-  resolved index. Already produced commits use their new IDs, completed drops and
-  squash sources disappear, unapplied squash sources remain, and the remaining
+- Command-line apply, including todo `--edit-and-apply`, reports a conflict
+  without changes unless `--materialize-conflicts` was explicitly supplied. Its
+  continuation document uses the full null object ID for the command whose tree
+  must come from the resolved index. Already produced commits use their new IDs,
+  completed drops and squash sources disappear, unapplied squash sources remain,
+  and the remaining
   todo stays editable. Applying it
   requires only that `HEAD` names a commit and the index has no unresolved stages;
   the index tree, including additional staged changes, becomes the resolved tree.
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index dfe87f534e5..0e429e29b11 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -742,6 +742,8 @@ mod tests {
                 "--onto",
                 "next",
                 "--edit-and-apply",
+                "--materialize-conflicts",
+                "continue.md",
                 "topic"
             ])
             .expect("rebase todo parses")
@@ -760,6 +762,10 @@ mod tests {
             Cli::try_parse_from(["tix", "rebase", "todo", "-x", "main", "--onto", "next", "--update-base"]).is_err(),
             "explicit and inferred rebase targets are mutually exclusive"
         );
+        assert!(
+            Cli::try_parse_from(["tix", "rebase", "todo", "-x", "main", "--materialize-conflicts"]).is_err(),
+            "todo conflict materialization requires immediate editing and application"
+        );
         assert!(matches!(
             Cli::try_parse_from(["tix", "rebase", "apply", "-"])
                 .expect("rebase apply parses")
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 1660d4a237b..a57bfe0b4e4 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -28,7 +28,7 @@ pub(super) enum Command {
 
 #[derive(Debug, clap::Args)]
 #[command(
-    after_long_help = "Without --edit-and-apply, the todo is written to stdout. With it, Git's normal editor selection is used; GIT_EDITOR=<command> overrides it.\n\nExamples:\n  tix rebase todo -x main topic >todo.md\n  ${GIT_EDITOR:-editor} todo.md\n  tix rebase apply todo.md\n  tix rebase todo --edit-and-apply -x main topic"
+    after_long_help = "Without --edit-and-apply, the todo is written to stdout. With it, Git's normal editor selection is used; GIT_EDITOR=<command> overrides it.\n\nExamples:\n  tix rebase todo -x main topic >todo.md\n  ${GIT_EDITOR:-editor} todo.md\n  tix rebase apply todo.md\n  tix rebase todo --edit-and-apply -x main topic\n  tix rebase todo --edit-and-apply --materialize-conflicts todo.continue.md -x main topic"
 )]
 pub(super) struct Todo {
     /// Hide this revision and derive the editable fork point from it.
@@ -46,6 +46,15 @@ pub(super) struct Todo {
     /// Open the todo in Git's editor and apply it after the editor exits.
     #[arg(long)]
     edit_and_apply: bool,
+    /// On conflict, materialize it and write a continuation todo to FILE, or stdout if omitted or '-'.
+    #[arg(
+        long,
+        value_name = "CONTINUE",
+        num_args = 0..=1,
+        default_missing_value = "-",
+        requires = "edit_and_apply"
+    )]
+    materialize_conflicts: Option<PathBuf>,
     /// Visible traversal tips, or HEAD if omitted.
     #[arg(value_name = "TIP")]
     tips: Vec<OsString>,
@@ -84,7 +93,7 @@ fn todo(repo: gix::Repository, args: Todo) -> Result<()> {
         &format!("tix-rebase-{}.md", std::process::id()),
     )?
     .unwrap_or(prepared.document);
-    apply_document(repo, &edited, None)
+    apply_document(repo, &edited, args.materialize_conflicts.as_deref())
 }
 
 fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
@@ -347,6 +356,7 @@ mod tests {
                 onto: None,
                 update_base: false,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )?;
@@ -375,6 +385,7 @@ mod tests {
                 onto: None,
                 update_base: false,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )
@@ -412,6 +423,7 @@ mod tests {
                 onto: None,
                 update_base: false,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )?;
@@ -464,6 +476,7 @@ mod tests {
                 onto: None,
                 update_base: true,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )?;
@@ -485,6 +498,7 @@ mod tests {
                 onto: None,
                 update_base: true,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )
@@ -604,6 +618,7 @@ mod tests {
                 onto: None,
                 update_base: false,
                 edit_and_apply: false,
+                materialize_conflicts: None,
                 tips: Vec::new(),
             },
         )?;

From 7623e83b522a6f89fef15717e20de065ac10cb54 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 07:10:06 +0200
Subject: [PATCH 204/282] fix: persist rebase objects before writing
 continuation todos

Flush candidate replay objects to the repository before formatting a conflict continuation, so generated short IDs resolve through the persistent ODB. Keep an empty object-memory transaction active until conflict materialization finishes.
---
 gix-tix/src/command/rebase.rs | 43 +++++++++++++++++++++++++++++------
 gix-tix/src/edit/rebase.rs    | 19 ++++++++++++++--
 2 files changed, 53 insertions(+), 9 deletions(-)

diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index a57bfe0b4e4..550b7ac0bd3 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -272,7 +272,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
             super::print_ref_rewrites(&outcome.ref_rewrites);
             Ok(())
         }
-        rebase::PlanPerform::Conflict(conflict) => {
+        rebase::PlanPerform::Conflict(mut conflict) => {
             let Some(destination) = materialize_conflicts else {
                 anyhow::bail!(
                     "rebase aborted without changes: conflict while applying {}; pass --materialize-conflicts to opt in",
@@ -284,6 +284,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
                     "rebase aborted without changes: refusing to materialize a conflict without a continuation output file"
                 );
             }
+            conflict.persist_objects()?;
             let plan = conflict.continuation_plan();
             let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
             let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips)?.document;
@@ -510,13 +511,32 @@ mod tests {
     #[test]
     fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        // This descendant is rewritten into object memory after the earlier commit conflicts.
+        std::fs::write(fixture.path().join("after"), b"after\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "after"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "-m", "after"])
+                .status()?
+                .success()
+        );
         let repo = crate::test_repository::open_with(
             fixture.path(),
             ["user.name=todo author", "user.email=todo@example.com"],
         )?;
-        let base = repo.rev_parse_single("HEAD~2")?.detach();
-        let middle = repo.rev_parse_single("HEAD~1")?.detach();
-        let tip = repo.head_id()?.detach();
+        let base = repo.rev_parse_single("HEAD~3")?.detach();
+        let middle = repo.rev_parse_single("HEAD~2")?.detach();
+        let tip = repo.rev_parse_single("HEAD~1")?.detach();
+        let after = repo.head_id()?.detach();
         let prepared = todo::prepare(
             &repo,
             base,
@@ -532,8 +552,13 @@ mod tests {
                     parents: vec![base],
                     info: "middle".into(),
                 },
+                todo::Commit {
+                    id: after,
+                    parents: vec![tip],
+                    info: "after".into(),
+                },
             ],
-            &[tip],
+            &[after],
             todo::OntoKind::Onto,
         )?;
         let generated = std::str::from_utf8(&prepared.document)?;
@@ -541,14 +566,18 @@ mod tests {
             .find("<!-- tix-rebase-state-v2")
             .expect("generated state is present")..];
         let edited = format!(
-            "`@pick {}` tip\n──── fork {} ────\n\n{state}",
+            "`@pick {}` after\n`pick {}` tip\n──── fork {} ────\n\n{state}",
+            after.to_hex_with_len(7),
             tip.to_hex_with_len(7),
             base.to_hex_with_len(7)
         );
         let output_dir = gix_testtools::tempfile::tempdir()?;
         let output = output_dir.path().join("continue.md");
         let err = apply_document(repo, edited.as_bytes(), Some(&output)).expect_err("the conflict stops the command");
-        assert!(format!("{err:#}").contains("materialized conflict"));
+        assert!(
+            format!("{err:#}").contains("materialized conflict"),
+            "the conflict is materialized after its continuation is written: {err:#}"
+        );
         let continuation = std::fs::read(&output)?;
         assert!(
             continuation
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index b48c3763cd8..df3f8a6ee96 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -179,6 +179,10 @@ impl PlanConflict {
         &self.conflict.prepared.repo
     }
 
+    pub(crate) fn persist_objects(&mut self) -> Result<()> {
+        self.conflict.prepared.persist_objects()
+    }
+
     pub(crate) fn map(&self, id: ObjectId) -> Option<ObjectId> {
         self.rewritten.get(&id).copied().unwrap_or(Some(id))
     }
@@ -1276,8 +1280,7 @@ pub(crate) fn perform_plan_with_progress(
 }
 
 impl Prepared {
-    fn finish(&mut self) -> Result<Outcome> {
-        let stash_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
+    fn persist_objects(&mut self) -> Result<()> {
         let objects = self
             .repo
             .objects
@@ -1288,6 +1291,18 @@ impl Prepared {
                 .write_buf_with_known_id(*kind, data, *id)
                 .map_err(|err| anyhow::anyhow!("could not persist a prepared rebase object: {err}"))?;
         }
+        self.repo.objects.set_object_memory(Default::default());
+        Ok(())
+    }
+
+    fn finish(&mut self) -> Result<Outcome> {
+        let stash_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
+        self.persist_objects()?;
+        let _ = self
+            .repo
+            .objects
+            .take_object_memory()
+            .context("candidate object memory was unavailable")?;
 
         let transitions = worktree_transitions(
             &self.repo,

From bc672ed1d9ad2d206d9ffadd828c6d03d9e852b2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 07:27:18 +0200
Subject: [PATCH 205/282] feat: mark ambiguous change IDs without hiding them

Keep colliding short change IDs visible in tix show and mark affected rows with a bomb gutter. Mark duplicate TUI change IDs with a twin gutter while retaining the full short change ID. Replace the worktree conflict C with a bomb gutter so selection and dirty markers remain visible.
---
 gix-tix/src/change_id.rs |  57 +++++++++--------
 gix-tix/src/command.rs   |  55 ++++++++++++++--
 gix-tix/src/lib.rs       |   2 +-
 gix-tix/src/ui.rs        | 131 ++++++++++++++++++++++++++++-----------
 4 files changed, 180 insertions(+), 65 deletions(-)

diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index 857a277e2f6..a708a41b21b 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -31,12 +31,17 @@ pub(crate) fn abbreviations(
     repo: &gix::Repository,
     ids: impl IntoIterator<Item = ObjectId>,
     len: usize,
-) -> Result<HashMap<ObjectId, ChangeId>> {
+) -> Result<Abbreviations> {
     let values = ids
         .into_iter()
         .map(|id| Ok((id, for_commit(repo, id)?)))
         .collect::<Result<Vec<_>>>()?;
-    Ok(unique_abbreviations(values, len))
+    Ok(collect_abbreviations(values, len))
+}
+
+pub(crate) struct Abbreviations {
+    pub values: HashMap<ObjectId, ChangeId>,
+    pub ambiguous: HashSet<ObjectId>,
 }
 
 pub(crate) fn resolve_prefix(
@@ -63,19 +68,19 @@ pub(crate) fn resolve_prefix(
     Ok(found)
 }
 
-fn unique_abbreviations(
-    values: impl IntoIterator<Item = (ObjectId, ChangeId)>,
-    len: usize,
-) -> HashMap<ObjectId, ChangeId> {
-    let mut by_prefix = HashMap::<String, Option<(ObjectId, ChangeId)>>::new();
+fn collect_abbreviations(values: impl IntoIterator<Item = (ObjectId, ChangeId)>, len: usize) -> Abbreviations {
+    let mut by_prefix = HashMap::new();
+    let mut all = HashMap::new();
+    let mut ambiguous = HashSet::new();
     for (id, change_id) in values {
         let prefix = change_id.to_reverse_hex_with_len(len).to_string();
-        by_prefix
-            .entry(prefix)
-            .and_modify(|entry| *entry = None)
-            .or_insert(Some((id, change_id)));
+        if let Some(first) = by_prefix.insert(prefix, id) {
+            ambiguous.insert(first);
+            ambiguous.insert(id);
+        }
+        all.insert(id, change_id);
     }
-    by_prefix.into_values().flatten().collect()
+    Abbreviations { values: all, ambiguous }
 }
 
 pub(crate) fn inherit(repo: &gix::Repository, commit: &mut gix::objs::Commit, predecessor: ObjectId) -> Result<()> {
@@ -157,24 +162,26 @@ mod tests {
     }
 
     #[test]
-    fn abbreviates_only_unique_prefixes() -> gix_testtools::Result {
+    fn marks_ambiguous_abbreviations_without_omitting_them() -> gix_testtools::Result {
         let shared_a = ChangeId::from_reverse_hex(format!("zzzzzzz{}", "k".repeat(33)).as_bytes())?;
         let shared_b = ChangeId::from_reverse_hex(format!("zzzzzzz{}", "l".repeat(33)).as_bytes())?;
         let duplicate = ChangeId::from_reverse_hex(format!("yyyyyyy{}", "m".repeat(33)).as_bytes())?;
         let unique = ChangeId::from_reverse_hex(format!("xxxxxxx{}", "n".repeat(33)).as_bytes())?;
+        let abbreviations = collect_abbreviations(
+            [
+                (id(1), shared_a),
+                (id(2), shared_b),
+                (id(3), duplicate),
+                (id(4), duplicate),
+                (id(5), unique),
+            ],
+            7,
+        );
+        assert_eq!(abbreviations.values.len(), 5, "every change ID remains visible");
         assert_eq!(
-            unique_abbreviations(
-                [
-                    (id(1), shared_a),
-                    (id(2), shared_b),
-                    (id(3), duplicate),
-                    (id(4), duplicate),
-                    (id(5), unique),
-                ],
-                7,
-            ),
-            HashMap::from([(id(5), unique)]),
-            "prefix collisions and complete duplicates are omitted"
+            abbreviations.ambiguous,
+            HashSet::from([id(1), id(2), id(3), id(4)]),
+            "prefix collisions and complete duplicates are marked"
         );
         Ok(())
     }
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 0e429e29b11..17d80735ae0 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -315,6 +315,7 @@ fn write_history(
         })
         .max()
         .unwrap_or_default();
+    let ambiguity_gutter = (!change_ids.ambiguous.is_empty()).then(|| Line::raw("💥").width());
     for (index, row) in app.rows.iter().enumerate() {
         let metadata = crate::ui::plain_history_metadata(
             &app,
@@ -322,7 +323,7 @@ fn write_history(
             &decorations,
             &mailmap,
             note_ids.contains(&row.id),
-            change_ids.get(&row.id).copied(),
+            change_ids.values.get(&row.id).copied(),
         );
         if enrichment_gutter != 0 {
             let marker = crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
@@ -333,6 +334,19 @@ fn write_history(
             )
             .context("could not write enrichment marker")?;
         }
+        if let Some(width) = ambiguity_gutter {
+            let marker = if change_ids.ambiguous.contains(&row.id) {
+                "💥"
+            } else {
+                ""
+            };
+            write!(
+                out,
+                "{marker}{}",
+                " ".repeat(width.saturating_sub(Line::raw(marker).width()))
+            )
+            .context("could not write change ID ambiguity marker")?;
+        }
         write!(out, "{}{}", lanes.lane(index), metadata).context("could not write history row")?;
         if let Some(behind) = app.hidden_branch_behind(row.id) {
             write!(out, " ⇣{behind}").context("could not write hidden-branch status")?;
@@ -942,7 +956,30 @@ mod tests {
         .expect_err("disabling auto-hide requires an explicit hidden revision");
         assert!(format!("{err:#}").contains("at least one -x/--hide"));
         create_pins(&repository, &[OsString::from("topic")])?;
-        let head = repository.head_id()?.detach();
+        let old_head = repository.head_id()?.detach();
+        let parent = repository
+            .find_commit(old_head)?
+            .parent_ids()
+            .next()
+            .context("the fixture head has a parent")?
+            .detach();
+        let mut commit = repository.find_commit(old_head)?.decode()?.into_owned()?;
+        commit.extra_headers.push((
+            crate::change_id::HEADER.into(),
+            crate::change_id::for_commit(&repository, parent)?.to_string().into(),
+        ));
+        let head = repository.write_object(&commit)?.detach();
+        let head_ref = repository
+            .head()?
+            .referent_name()
+            .context("the fixture head is attached")?
+            .to_owned();
+        repository.reference(
+            head_ref,
+            head,
+            gix::refs::transaction::PreviousValue::ExistingMustMatch(gix::refs::Target::Object(old_head)),
+            "test ambiguous change ID",
+        )?;
         let head_change_id = crate::change_id::for_commit(&repository, head)?;
         assert!(crate::enrich::toggle(&repository, head)?.todo);
 
@@ -957,11 +994,21 @@ mod tests {
                 head.to_hex_with_len(7),
                 head_change_id.to_reverse_hex_with_len(7)
             )),
-            "an unambiguous change ID follows its commit hash: {output:?}"
+            "a change ID follows its commit hash even when ambiguous: {output:?}"
         );
+        for id in [head, parent] {
+            let line = output
+                .lines()
+                .find(|line| line.contains(&id.to_hex_with_len(7).to_string()))
+                .context("the ambiguous commit is shown")?;
+            assert!(
+                line.contains('💥'),
+                "ambiguous change IDs are marked in the gutter: {line:?}"
+            );
+        }
         assert!(output.contains('●'), "history graph lanes are rendered");
         assert!(
-            output.lines().any(|line| line.starts_with("🚧├")),
+            output.lines().any(|line| line.starts_with("🚧💥├")),
             "todos directly lead their rows: {output:?}"
         );
         assert!(output.contains("📌"), "applicable pins are decorated and traversed");
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 5f36de532aa..65dc7ff5c93 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -6710,7 +6710,7 @@ mod tests {
                 .get(app.selected.expect("the conflict is selected"))
                 .map(|row| row.id),
             Some(conflict.commit()),
-            "the displayed red-C row is the prepared result, not its original source"
+            "the displayed conflict row is the prepared result, not its original source"
         );
         Ok(())
     }
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 42d021aff47..ac0fbdf5e9d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -482,11 +482,37 @@ pub(crate) fn draw_with_worktree(
         .map(|row| Line::raw(crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some())).width())
         .max()
         .unwrap_or_default() as u16;
-    let status_x = body.x.saturating_add(enrichment_gutter);
+    let change_id_gutter = visible_rows
+        .iter()
+        .any(|row| app.has_duplicate_change_id(row.id))
+        .then(|| Line::raw("👯‍♂️").width() as u16)
+        .unwrap_or_default();
+    let conflict_gutter = visible_rows
+        .iter()
+        .any(|row| {
+            let head = decorations.get(&row.id).is_some_and(|decorations| {
+                decorations
+                    .iter()
+                    .any(|decoration| decoration.kind == DecorationKind::Head)
+            });
+            app.conflict_marker(row.id, head)
+        })
+        .then(|| Line::raw("💥").width() as u16)
+        .unwrap_or_default();
+    let status_x = body
+        .x
+        .saturating_add(enrichment_gutter)
+        .saturating_add(change_id_gutter)
+        .saturating_add(conflict_gutter);
     let content = Rect::new(
         status_x.saturating_add(2),
         body.y,
-        body.width.saturating_sub(enrichment_gutter.saturating_add(2)),
+        body.width.saturating_sub(
+            enrichment_gutter
+                .saturating_add(change_id_gutter)
+                .saturating_add(conflict_gutter)
+                .saturating_add(2),
+        ),
         body.height,
     );
     let rendered_lane_width = lanes
@@ -528,7 +554,6 @@ pub(crate) fn draw_with_worktree(
                     date_mode,
                     id_mode,
                     change_id: app.change_id(row.id),
-                    duplicate_change_id: app.has_duplicate_change_id(row.id),
                     show_author_name,
                     show_emails: app.show_emails,
                     show_trailers,
@@ -674,23 +699,34 @@ pub(crate) fn draw_with_worktree(
                 Rect::new(body.x, y, enrichment_gutter, 1),
             );
         }
+        if app.has_duplicate_change_id(visible_rows[index].id) {
+            frame.render_widget(
+                Paragraph::new("👯‍♂️"),
+                Rect::new(body.x.saturating_add(enrichment_gutter), y, change_id_gutter, 1),
+            );
+        }
+        if conflict {
+            frame.render_widget(
+                Paragraph::new("💥").style(color(Color::LightRed).add_modifier(Modifier::SLOW_BLINK)),
+                Rect::new(
+                    body.x
+                        .saturating_add(enrichment_gutter)
+                        .saturating_add(change_id_gutter),
+                    y,
+                    conflict_gutter,
+                    1,
+                ),
+            );
+        }
         frame.render_widget(
-            Paragraph::new(if conflict {
-                "C "
-            } else if head && worktree_dirty {
+            Paragraph::new(if head && worktree_dirty {
                 "D "
             } else if selected {
                 "> "
             } else {
                 "  "
             })
-            .style(if conflict {
-                color(Color::LightRed).add_modifier(Modifier::SLOW_BLINK)
-            } else if selected {
-                style
-            } else {
-                Style::default()
-            }),
+            .style(if selected { style } else { Style::default() }),
             Rect::new(status_x, y, body.right().saturating_sub(status_x).min(2), 1),
         );
 
@@ -1914,7 +1950,6 @@ struct MetadataOptions {
     date_mode: DateMode,
     id_mode: IdMode,
     change_id: gix::hash::ChangeId,
-    duplicate_change_id: bool,
     show_author_name: bool,
     show_emails: bool,
     show_trailers: bool,
@@ -1973,7 +2008,6 @@ fn metadata_columns<'a>(
         date_mode,
         id_mode,
         change_id,
-        duplicate_change_id,
         show_author_name,
         show_emails,
         show_trailers,
@@ -2003,16 +2037,6 @@ fn metadata_columns<'a>(
             row.id.to_hex_with_len(7).to_string(),
             selected_style(commit_style),
         )),
-        IdMode::Change if duplicate_change_id => {
-            id.push(Span::styled(
-                change_id.to_reverse_hex_with_len(4).to_string(),
-                selected_style(change_style),
-            ));
-            id.push(Span::styled(
-                row.id.to_hex_with_len(3).to_string(),
-                selected_style(commit_style),
-            ));
-        }
         IdMode::Change => id.push(Span::styled(
             change_id.to_reverse_hex_with_len(7).to_string(),
             selected_style(change_style),
@@ -2245,7 +2269,6 @@ pub(crate) fn plain_history_metadata(
             date_mode: app.date_mode,
             id_mode: app.effective_id_mode(),
             change_id: app.change_id(row.id),
-            duplicate_change_id: app.has_duplicate_change_id(row.id),
             show_author_name: app.name_mode != NameMode::None,
             show_emails: app.show_emails,
             show_trailers: app.name_mode == NameMode::All && app.show_trailers,
@@ -2277,7 +2300,6 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
             date_mode: app.date_mode,
             id_mode: IdMode::Off,
             change_id: row.id.into(),
-            duplicate_change_id: false,
             show_author_name: app.name_mode != crate::app::NameMode::None,
             show_emails: app.show_emails,
             show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
@@ -4130,9 +4152,10 @@ mod tests {
     #[test]
     fn marks_dirty_head_independently_of_history_selection() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);
+        let other = gix::ObjectId::Sha1([2; 20]);
         let mut app = App::new(5);
         app.extend_commits(
-            [head, gix::ObjectId::Sha1([2; 20])]
+            [head, other]
                 .into_iter()
                 .map(|id| Commit {
                     id,
@@ -4230,7 +4253,11 @@ mod tests {
                 Some(&conflicted),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("C @"));
+        assert!(
+            rendered_line(&terminal, 0).starts_with("💥 D @"),
+            "the conflict gutter precedes the ordinary status: {:?}",
+            rendered_line(&terminal, 0)
+        );
         assert_eq!(terminal.backend().buffer()[(0, 0)].fg, Color::LightRed);
         assert!(
             terminal.backend().buffer()[(0, 0)]
@@ -4255,6 +4282,27 @@ mod tests {
             "resolving the index restores the ordinary dirty marker"
         );
 
+        app.arm_rebase_conflict(other);
+        app.selected = Some(1);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                Some(&dirty),
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 1).starts_with("💥 > ●"),
+            "the conflict gutter does not replace selection: {:?}",
+            rendered_line(&terminal, 1)
+        );
+        app.clear_rebase_conflict();
+        app.selected = Some(0);
+
         app.changes_mode = Some(ChangesMode::Tree);
         terminal.draw(|frame| {
             super::draw_with_worktree(
@@ -5918,7 +5966,6 @@ mod tests {
                 date_mode: DateMode::Committer,
                 id_mode: IdMode::Commit,
                 change_id: row.id.into(),
-                duplicate_change_id: false,
                 show_author_name: true,
                 show_emails: false,
                 show_trailers: true,
@@ -5974,7 +6021,7 @@ mod tests {
     }
 
     #[test]
-    fn hides_ids_by_default_and_color_splits_duplicate_change_ids() {
+    fn hides_ids_by_default_and_marks_duplicate_change_ids() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
         let mut app = App::new(1);
         app.extend_commits(vec![Commit {
@@ -6019,7 +6066,6 @@ mod tests {
                 date_mode: DateMode::None,
                 id_mode: app.effective_id_mode(),
                 change_id: app.change_id(id),
-                duplicate_change_id: app.has_duplicate_change_id(id),
                 show_author_name: false,
                 show_emails: false,
                 show_trailers: false,
@@ -6031,13 +6077,28 @@ mod tests {
                 copy_feedback: None,
             },
         );
-        assert_eq!(line.spans[0].content, change_id.to_reverse_hex_with_len(4).to_string());
+        assert_eq!(line.spans[0].content, change_id.to_reverse_hex_with_len(7).to_string());
         assert_eq!(
             line.spans[0].style,
             color(Color::LightCyan).add_modifier(Modifier::BOLD)
         );
-        assert_eq!(line.spans[1].content, id.to_hex_with_len(3).to_string());
-        assert_eq!(line.spans[1].style, color(Color::Magenta).add_modifier(Modifier::BOLD));
+        assert!(
+            line.spans
+                .iter()
+                .all(|span| span.style != color(Color::Magenta).add_modifier(Modifier::BOLD)),
+            "the commit ID is not mixed into an ambiguous change ID"
+        );
+
+        complete(&mut app);
+        app.selected = Some(0);
+        let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        assert!(
+            rendered_line(&terminal, 0).starts_with("👯‍♂️ > "),
+            "the ambiguity gutter does not replace selection: {:?}",
+            rendered_line(&terminal, 0)
+        );
+        Ok(())
     }
 
     #[test]

From 34dd1aec172550d34aa605a462e61226f97cbd9e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 07:45:35 +0200
Subject: [PATCH 206/282] fix: avoid redundant pins during conflict
 continuation

Skip provisional departure pins when the destination already retains the mapped departure. Exercise two successive materialized conflicts and verify that continuation leaves no pins.
---
 gix-tix/src/command/rebase.rs   | 34 ++++++++++++++++++++++++++++-----
 gix-tix/src/edit/time_travel.rs |  1 +
 2 files changed, 30 insertions(+), 5 deletions(-)

diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 550b7ac0bd3..daaa223887a 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -511,13 +511,13 @@ mod tests {
     #[test]
     fn materialized_conflicts_emit_an_applicable_continuation_todo() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
-        // This descendant is rewritten into object memory after the earlier commit conflicts.
-        std::fs::write(fixture.path().join("after"), b"after\n")?;
+        // This descendant is rewritten into object memory and conflicts after the earlier conflict is resolved.
+        std::fs::write(fixture.path().join("file"), b"after\n")?;
         assert!(
             Command::new("git")
                 .arg("-C")
                 .arg(fixture.path())
-                .args(["add", "after"])
+                .args(["add", "file"])
                 .status()?
                 .success()
         );
@@ -609,7 +609,27 @@ mod tests {
             "the materialized conflict commit records the ours tree"
         );
 
-        std::fs::write(fixture.path().join("file"), b"resolved\n")?;
+        std::fs::write(fixture.path().join("file"), b"base\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "file"])
+                .status()?
+                .success()
+        );
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=todo author", "user.email=todo@example.com"],
+        )?;
+        let next_output = output_dir.path().join("continue-again.md");
+        let err = apply_document(repo, &continuation, Some(&next_output))
+            .expect_err("the descendant conflict stops the continuation");
+        assert!(
+            format!("{err:#}").contains("materialized conflict"),
+            "the second conflict is materialized: {err:#}"
+        );
+        std::fs::write(fixture.path().join("file"), b"resolved again\n")?;
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -622,7 +642,7 @@ mod tests {
             fixture.path(),
             ["user.name=todo author", "user.email=todo@example.com"],
         )?;
-        apply_document(repo, &continuation, None)?;
+        apply_document(repo, &std::fs::read(next_output)?, None)?;
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -633,6 +653,10 @@ mod tests {
                 .is_empty(),
             "the continuation consumes the resolved index"
         );
+        assert!(
+            crate::history::all_pins(&crate::test_repository::open(fixture.path())?)?.is_empty(),
+            "successive materialized conflicts do not leave departure pins"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 17a7d236f5d..fd634dc3718 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -239,6 +239,7 @@ where
         .then_some(departure)
         .flatten()
         .filter(|departure| *departure != selected)
+        .filter(|departure| !contains(&repository, *departure, selected))
         .map(|departure| {
             let target = head_ref.clone().map_or(Target::Object(departure), Target::Symbolic);
             create_or_reuse_pin(&repository, target, departure, "tix time-travel")

From 39bcfb4583c13a651d2a540207c334b897ff3da7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 08:42:28 +0200
Subject: [PATCH 207/282] feat: make history counts relative to visible bases

Start each visible commit tree at zero and count descendants by their displayed row distance, choosing the nearest root for merges. Render visible roots as centered metadata-bearing base separators in tix show.
---
 gix-tix/spec.md        | 15 ++++---
 gix-tix/src/app.rs     | 25 +++++++++++
 gix-tix/src/command.rs | 98 +++++++++++++++++++++++++++++++-----------
 gix-tix/src/ui.rs      | 74 ++++++++++++++++++++++++++-----
 4 files changed, 172 insertions(+), 40 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index f1a31275b35..bc95b5d403a 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -17,10 +17,12 @@ without trading responsiveness for metadata that is not visible.
   history view without opening a terminal UI. Tips default to `HEAD`, and
   applicable pins participate exactly as they do in the history view. Output
   uses the history view's graph lanes and default metadata, without colors,
-  selection, clipping, or a footer. Each seven-character commit hash is followed
-  by its seven-character reverse-hex change ID when that prefix identifies
-  exactly one commit in this invocation; colliding or duplicated change IDs are
-  omitted.
+  selection, clipping, or a footer. Each visible root replaces its ordinary row
+  with a centered `──── base <metadata> ────` separator; distinct roots therefore
+  delineate their trees while retaining the commit's markers and metadata. Each
+  seven-character commit hash is followed by its seven-character reverse-hex
+  change ID. Colliding or duplicated prefixes remain visible and receive a `💥`
+  gutter marker.
 - `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
   checkout, pending-rebase replay, stash handling, and pin reconciliation as
   TUI time travel. Its target may also be an unambiguous reverse-hex change-ID
@@ -114,8 +116,9 @@ without trading responsiveness for metadata that is not visible.
 
 - Traversal streams commits before graph-lane computation finishes. The footer
   reports the number received while loading and switches to the selected row
-  number after completion. Rows are numbered from the bottom, so the oldest row
-  is `#1` and the newest row is `#N`.
+  number after completion. Every visible root starts at `#0`; descendants use
+  their on-screen row distance from that root. A merge reachable from multiple
+  visible roots uses the visually closest root, so only one count is shown.
 - Commit topology, commit time, and generation are loaded through the same
   commit-graph-or-ODB lookup model as `gix-traverse`. A small object cache avoids
   repeated ODB decoding during a walk.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 74ac3717c95..fbe0ae086b1 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -976,6 +976,13 @@ impl App {
         }
     }
 
+    pub(crate) fn visual_count(&self, index: usize) -> Option<usize> {
+        self.graph
+            .as_ref()
+            .and_then(|graph| graph.visual_counts.get(index))
+            .copied()
+    }
+
     pub(crate) fn attributions(&self, row: &CommitRow) -> &[Attribution] {
         debug_assert!(row.metadata_loaded, "visible rows have metadata");
         &self.attributions[row.attributions.clone()]
@@ -2379,6 +2386,7 @@ const CHECKPOINT_INTERVAL: usize = 256;
 pub(crate) struct Graph {
     offsets: Vec<usize>,
     columns: Vec<ObjectId>,
+    visual_counts: Vec<usize>,
 }
 
 impl Graph {
@@ -2387,6 +2395,7 @@ impl Graph {
         let mut graph = Graph {
             offsets: Vec::with_capacity(rows.len().div_ceil(CHECKPOINT_INTERVAL) + 1),
             columns: Vec::new(),
+            visual_counts: visual_counts(rows),
         };
         for (index, row) in rows.iter().enumerate() {
             if index % CHECKPOINT_INTERVAL == 0 {
@@ -2424,6 +2433,22 @@ impl Graph {
     }
 }
 
+fn visual_counts(rows: &[SharedCommitRow]) -> Vec<usize> {
+    let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
+    let mut counts = vec![0; rows.len()];
+    for (index, row) in rows.iter().enumerate().rev() {
+        let base = row
+            .parent_ids
+            .iter()
+            .filter_map(|parent| positions.get(parent).copied())
+            .map(|parent| parent.saturating_add(counts[parent]))
+            .min()
+            .unwrap_or(index);
+        counts[index] = base.saturating_sub(index);
+    }
+    counts
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct RenderedLanes {
     data: String,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 17d80735ae0..d16595ca268 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -316,7 +316,7 @@ fn write_history(
         .max()
         .unwrap_or_default();
     let ambiguity_gutter = (!change_ids.ambiguous.is_empty()).then(|| Line::raw("💥").width());
-    for (index, row) in app.rows.iter().enumerate() {
+    let render_line = |index: usize, row: &crate::app::SharedCommitRow| {
         let metadata = crate::ui::plain_history_metadata(
             &app,
             row,
@@ -325,33 +325,52 @@ fn write_history(
             note_ids.contains(&row.id),
             change_ids.values.get(&row.id).copied(),
         );
+        let enrichment_marker =
+            crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
+        let ambiguity_marker = if change_ids.ambiguous.contains(&row.id) {
+            "💥"
+        } else {
+            ""
+        };
+        let mut gutter = String::new();
         if enrichment_gutter != 0 {
-            let marker = crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
-            write!(
-                out,
-                "{marker}{}",
-                " ".repeat(enrichment_gutter.saturating_sub(Line::raw(marker).width()))
-            )
-            .context("could not write enrichment marker")?;
+            gutter.push_str(enrichment_marker);
+            gutter.push_str(&" ".repeat(enrichment_gutter.saturating_sub(Line::raw(enrichment_marker).width())));
         }
         if let Some(width) = ambiguity_gutter {
-            let marker = if change_ids.ambiguous.contains(&row.id) {
-                "💥"
-            } else {
-                ""
-            };
-            write!(
-                out,
-                "{marker}{}",
-                " ".repeat(width.saturating_sub(Line::raw(marker).width()))
-            )
-            .context("could not write change ID ambiguity marker")?;
+            gutter.push_str(ambiguity_marker);
+            gutter.push_str(&" ".repeat(width.saturating_sub(Line::raw(ambiguity_marker).width())));
         }
-        write!(out, "{}{}", lanes.lane(index), metadata).context("could not write history row")?;
-        if let Some(behind) = app.hidden_branch_behind(row.id) {
-            write!(out, " ⇣{behind}").context("could not write hidden-branch status")?;
+        let behind = app
+            .hidden_branch_behind(row.id)
+            .map(|behind| format!(" ⇣{behind}"))
+            .unwrap_or_default();
+        let line = format!("{gutter}{}{metadata}{behind}", lanes.lane(index));
+        let base = (app.visual_count(index) == Some(0))
+            .then(|| format!("base {enrichment_marker}{ambiguity_marker}{metadata}{behind}"));
+        (line, base)
+    };
+    let width = app
+        .rows
+        .iter()
+        .enumerate()
+        .map(|(index, row)| {
+            let (line, base) = render_line(index, row);
+            base.as_ref()
+                .map_or_else(|| Line::raw(&line).width(), |base| Line::raw(base).width() + 10)
+        })
+        .max()
+        .unwrap_or_default();
+    for (index, row) in app.rows.iter().enumerate() {
+        let (line, base) = render_line(index, row);
+        if let Some(base) = base {
+            let rails = width.saturating_sub(Line::raw(&base).width() + 2).max(8);
+            let left = rails / 2;
+            writeln!(out, "{} {base} {}", "─".repeat(left), "─".repeat(rails - left))
+                .context("could not write history base")?;
+        } else {
+            writeln!(out, "{line}").context("could not write history row")?;
         }
-        writeln!(out).context("could not finish history row")?;
     }
     Ok(())
 }
@@ -980,6 +999,11 @@ mod tests {
             gix::refs::transaction::PreviousValue::ExistingMustMatch(gix::refs::Target::Object(old_head)),
             "test ambiguous change ID",
         )?;
+        let mut orphan = repository.find_commit(parent)?.decode()?.into_owned()?;
+        orphan.parents.clear();
+        orphan.message = "orphan base".into();
+        let orphan = repository.write_object(&orphan)?.detach();
+        create_pins(&repository, &[OsString::from(orphan.to_string())])?;
         let head_change_id = crate::change_id::for_commit(&repository, head)?;
         assert!(crate::enrich::toggle(&repository, head)?.todo);
 
@@ -987,7 +1011,33 @@ mod tests {
         write_history(&repository, &[], &[OsString::from("v1")], &mut output)?;
         let output = String::from_utf8(output)?;
 
-        assert_eq!(output.lines().count(), 5, "the complete projected history is printed");
+        assert_eq!(output.lines().count(), 6, "the complete projected history is printed");
+        let bases = output
+            .lines()
+            .filter(|line| line.contains(" base "))
+            .collect::<Vec<_>>();
+        assert_eq!(bases.len(), 2, "each distinct visible root becomes a base separator");
+        assert!(
+            bases
+                .iter()
+                .all(|line| line.starts_with("────") && line.ends_with("────")),
+            "base separators use the rebase-todo rails: {bases:?}"
+        );
+        assert!(
+            bases
+                .iter()
+                .any(|line| line.contains(&orphan.to_hex_with_len(7).to_string()) && line.contains("orphan base")),
+            "a base separator retains commit metadata: {bases:?}"
+        );
+        assert_eq!(
+            bases
+                .iter()
+                .map(|line| Line::raw(*line).width())
+                .collect::<HashSet<_>>()
+                .len(),
+            1,
+            "all base separators span the same display width"
+        );
         assert!(
             output.contains(&format!(
                 "{} {}",
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index ac0fbdf5e9d..cb4e6f61ae0 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1212,9 +1212,12 @@ pub(crate) fn draw_with_worktree(
 }
 
 fn history_position(app: &App) -> String {
-    match (app.deferred_history_state.unwrap_or(app.state), app.selected) {
-        (State::Complete, Some(selected)) => format!("#{}", app.rows.len().saturating_sub(selected)),
-        _ => format!("{} commits", app.rows.len()),
+    if let (State::Complete, Some(selected)) = (app.deferred_history_state.unwrap_or(app.state), app.selected)
+        && let Some(count) = app.visual_count(selected)
+    {
+        format!("#{count}")
+    } else {
+        format!("{} commits", app.rows.len())
     }
 }
 
@@ -2512,12 +2515,15 @@ mod tests {
 
     #[test]
     fn counts_commits_until_the_graph_is_complete_then_tracks_the_selected_row() {
+        let ids = [1, 2, 3].map(|byte| gix::ObjectId::Sha1([byte; 20]));
         let mut app = App::new(3);
         app.extend_commits(
-            (1..=3)
-                .map(|byte| Commit {
-                    id: gix::ObjectId::Sha1([byte; 20]),
-                    parent_ids: Default::default(),
+            ids.into_iter()
+                .rev()
+                .enumerate()
+                .map(|(index, id)| Commit {
+                    id,
+                    parent_ids: (index < 2).then(|| ids[1 - index]).into_iter().collect(),
                     author_time: gix::date::Time::default(),
                     committer_time: gix::date::Time::default(),
                     author: author(b"author", b"author@example.com"),
@@ -2539,11 +2545,59 @@ mod tests {
         let (rows, lanes, lane_time) = crate::app::compute_lanes(rows);
         app.finish_lane_computation(rows, lanes, lane_time);
 
-        assert_eq!(history_position(&app), "#3");
-        app.update(Action::MoveDown);
         assert_eq!(history_position(&app), "#2");
         app.update(Action::MoveDown);
         assert_eq!(history_position(&app), "#1");
+        app.update(Action::MoveDown);
+        assert_eq!(history_position(&app), "#0");
+    }
+
+    #[test]
+    fn visual_counts_restart_at_each_root_and_merges_choose_the_closest() {
+        let ids = [2, 3, 4, 5, 6, 7, 8].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let parents = [
+            &[ids[5], ids[3]][..],
+            &[ids[2]][..],
+            &[ids[2]][..],
+            &[ids[1]][..],
+            &[][..],
+            &[ids[0]][..],
+            &[][..],
+        ];
+        let mut app = App::new(ids.len());
+        app.extend_commits(
+            ids.into_iter()
+                .rev()
+                .zip(parents)
+                .map(|(id, parents)| Commit {
+                    id,
+                    parent_ids: parents.iter().copied().collect(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: "subject".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+
+        let expected = [ids[6], ids[5], ids[3], ids[1], ids[0], ids[4], ids[2]];
+        assert_eq!(app.rows.iter().map(|row| row.id).collect::<Vec<_>>(), expected);
+        app.selected = Some(0);
+        assert_eq!(
+            history_position(&app),
+            "#4",
+            "the merge uses its visually closest root and counts an interleaved row"
+        );
+        app.selected = Some(4);
+        assert_eq!(history_position(&app), "#0", "the first root starts at zero");
+        app.selected = Some(6);
+        assert_eq!(history_position(&app), "#0", "the second root restarts at zero");
     }
 
     #[test]
@@ -3218,7 +3272,7 @@ mod tests {
             "todo commit metadata uses the author date and excludes separately represented refs"
         );
 
-        let footer_text = "#1 · view · edit · enrich · copy · refs · ? · quit";
+        let footer_text = "#0 · view · edit · enrich · copy · refs · ? · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {

From 4a218aaee26c1ca5373f3922c22b15d33f71b181 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 09:13:45 +0200
Subject: [PATCH 208/282] feat: cycle through duplicate commits in history

Show a next-duplicate action for commits sharing an effective change ID and move selection through the group with wraparound.
---
 gix-tix/spec.md    |  4 ++-
 gix-tix/src/app.rs | 65 ++++++++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs |  8 +++++-
 gix-tix/src/ui.rs  | 25 +++++++++++++++---
 4 files changed, 96 insertions(+), 6 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bc95b5d403a..2c5f33bbec1 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -359,6 +359,7 @@ without trading responsiveness for metadata that is not visible.
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
 | `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
+| `x` | Select the next visible commit with the same change ID, wrapping at the end. |
 
 Alignment uses only rows in the current viewport to determine widths and starts
 in title mode. Horizontal navigation pans the complete padded row in title and
@@ -377,7 +378,8 @@ every applicable display option and a closing `)` so direct shortcuts remain vis
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
 actions end at the information prefix while it is closed. An available direct
-time-travel action follows the edit group, and copy follows time travel; the reference toggle immediately precedes
+time-travel action follows the edit group, duplicate cycling follows time travel when
+the selected commit has duplicates, and copy follows these actions; the reference toggle immediately precedes
 the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
 possible; keys that cannot be expressed naturally in the label remain explicit.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index fbe0ae086b1..6d785076f8d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -331,6 +331,7 @@ pub(crate) enum Action {
     MoveDown,
     MoveUpBy(usize),
     MoveDownBy(usize),
+    CycleDuplicate,
     ScrollLeft,
     ScrollRight,
     HalfPageUp,
@@ -658,6 +659,10 @@ impl App {
         self.duplicate_change_ids.contains(&id)
     }
 
+    pub(crate) fn can_cycle_duplicate(&self) -> bool {
+        self.changes_focus.is_none() && self.next_duplicate().is_some()
+    }
+
     pub(crate) fn set_change_ids(&mut self, change_ids: HashMap<ObjectId, ChangeId>, duplicates: HashSet<ObjectId>) {
         self.change_ids = change_ids;
         self.duplicate_change_ids = duplicates;
@@ -1051,6 +1056,13 @@ impl App {
             Action::MoveDown => self.move_reachable(1, true),
             Action::MoveUpBy(distance) => self.move_reachable(distance, false),
             Action::MoveDownBy(distance) => self.move_reachable(distance, true),
+            Action::CycleDuplicate => {
+                if self.changes_focus.is_none()
+                    && let Some(selected) = self.next_duplicate()
+                {
+                    self.select(selected);
+                }
+            }
             Action::ScrollLeft => {
                 if self.changes_focus.is_some() {
                     self.pan_changes(false);
@@ -1838,6 +1850,18 @@ impl App {
         self.ensure_visible();
     }
 
+    fn next_duplicate(&self) -> Option<usize> {
+        let selected = self.selected?;
+        let id = self.rows.get(selected)?.id;
+        if !self.has_duplicate_change_id(id) {
+            return None;
+        }
+        let change_id = self.change_id(id);
+        ((selected + 1)..self.rows.len())
+            .chain(0..selected)
+            .find(|index| self.change_id(self.rows[*index].id) == change_id)
+    }
+
     fn move_reachable(&mut self, distance: usize, down: bool) {
         self.pending_initial_selection = None;
         let (Some(selected), Some(reachable)) = (self.selected, self.reachable_rows.as_ref()) else {
@@ -2737,6 +2761,47 @@ mod tests {
         app.finish_lane_computation(rows, graph, lane_time);
     }
 
+    #[test]
+    fn cycles_duplicate_change_ids_and_wraps() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![row(1), row(2), row(3), row(4), row(5)]);
+        complete(&mut app);
+        let duplicate = ChangeId::from(id(9));
+        app.set_change_ids(
+            HashMap::from([(id(1), duplicate), (id(3), duplicate), (id(5), duplicate)]),
+            HashSet::from([id(1), id(3), id(5)]),
+        );
+
+        assert!(app.can_cycle_duplicate());
+        for expected in [id(3), id(5), id(1)] {
+            app.update(Action::CycleDuplicate);
+            assert_eq!(
+                app.selected.map(|index| app.rows[index].id),
+                Some(expected),
+                "duplicate cycling skips unrelated rows and wraps"
+            );
+            assert!(
+                app.selected
+                    .is_some_and(|selected| selected >= app.offset && selected < app.offset + 2),
+                "duplicate cycling keeps the new selection visible"
+            );
+        }
+
+        app.changes_focus = Some(ChangePane::Tree);
+        assert!(!app.can_cycle_duplicate());
+        app.update(Action::CycleDuplicate);
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(1)),
+            "duplicate cycling does not move history while a changes pane is focused"
+        );
+        app.changes_focus = None;
+        app.select_commit(id(2));
+        assert!(!app.can_cycle_duplicate());
+        app.update(Action::CycleDuplicate);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(2)));
+    }
+
     fn show_tree_changes(app: &mut App) {
         app.set_changes_layout(ChangesLayout::SideBySide, true, false);
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 65dc7ff5c93..bda0d5568ff 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4852,6 +4852,7 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
                 | Action::MoveDown
                 | Action::MoveUpBy(_)
                 | Action::MoveDownBy(_)
+                | Action::CycleDuplicate
                 | Action::ScrollLeft
                 | Action::ScrollRight
                 | Action::HalfPageUp
@@ -4911,6 +4912,7 @@ fn action_with_shortcut_groups(
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
         KeyCode::Down | KeyCode::Char('j') => Some(Action::MoveDown),
+        KeyCode::Char('x') => Some(Action::CycleDuplicate),
         KeyCode::Char('h') if edit_expanded => Some(Action::Stash),
         KeyCode::Char('h') if history_display_expanded => Some(Action::ToggleHidden),
         KeyCode::Char('h') => Some(Action::ScrollLeft),
@@ -6161,7 +6163,10 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::CONTROL)),
             Some(Action::ForceQuit)
         );
-        assert_eq!(action(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE)), None);
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('x'), KeyModifiers::NONE)),
+            Some(Action::CycleDuplicate)
+        );
     }
 
     #[test]
@@ -6238,6 +6243,7 @@ mod tests {
     fn materialized_rebases_allow_inspection_but_block_repository_changes() {
         for action in [
             Action::MoveDown,
+            Action::CycleDuplicate,
             Action::ToggleChangesFocus,
             Action::ToggleCommit,
             Action::Copy,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index cb4e6f61ae0..602dd47324a 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1138,6 +1138,10 @@ pub(crate) fn draw_with_worktree(
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut(label, '@', true));
     }
+    if app.can_cycle_duplicate() {
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("next duplicate", 'x', true));
+    }
     ordered.push(Span::raw(" · "));
     ordered.extend(shortcut("copy", 'y', true));
     ordered.push(Span::raw(" · "));
@@ -6077,8 +6081,9 @@ mod tests {
     #[test]
     fn hides_ids_by_default_and_marks_duplicate_change_ids() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
+        let duplicate_id = gix::ObjectId::Sha1([2; 20]);
         let mut app = App::new(1);
-        app.extend_commits(vec![Commit {
+        let commit = Commit {
             id,
             parent_ids: Default::default(),
             author_time: gix::date::Time::default(),
@@ -6090,7 +6095,15 @@ mod tests {
             has_agent_marker: false,
             is_review: false,
             signature: SignatureState::Unsigned,
-        }]);
+        };
+        app.extend_commits(vec![
+            commit.clone(),
+            Commit {
+                id: duplicate_id,
+                title: "duplicate".into(),
+                ..commit
+            },
+        ]);
         let row = &app.rows[0];
         let plain = plain_history_metadata(
             &app,
@@ -6102,10 +6115,10 @@ mod tests {
         );
         assert!(!plain.contains("0101010"), "history rows hide IDs by default");
 
-        let change_id = gix::hash::ChangeId::from(gix::ObjectId::Sha1([2; 20]));
+        let change_id = gix::hash::ChangeId::from(duplicate_id);
         app.set_change_ids(
             std::collections::HashMap::from([(id, change_id)]),
-            std::collections::HashSet::from([id]),
+            std::collections::HashSet::from([id, duplicate_id]),
         );
         let row = &app.rows[0];
         let decorations = Decorations::new();
@@ -6152,6 +6165,10 @@ mod tests {
             "the ambiguity gutter does not replace selection: {:?}",
             rendered_line(&terminal, 0)
         );
+        assert!(
+            rendered_line(&terminal, 1).contains("next duplicate"),
+            "the footer advertises duplicate cycling for the selected commit"
+        );
         Ok(())
     }
 

From 707299e12808e332ecfd26367e5be59d4984b4d9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 10:25:51 +0200
Subject: [PATCH 209/282] fix: release startup repository before the TUI event
 loop

Hidden-revision validation previously left its repository alive for the entire interactive session even though only detached revision and warning data were needed afterward.

Confine validation to a helper whose return type cannot retain repository state, and document the startup lifetime boundary.
---
 gix-tix/spec.md    |  3 +++
 gix-tix/src/lib.rs | 26 ++++++++++++++++++++++++--
 2 files changed, 27 insertions(+), 2 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2c5f33bbec1..6b1b8e64fbb 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1031,6 +1031,9 @@ space first; changes blocks adapt within the remaining history width.
 
 - No `gix::Repository`, commit-graph, object platform, notes platform, or other
   repository-owning value may remain in idle application/event-loop state.
+- Hidden-revision startup validation returns only detached revision and warning
+  data; its temporary repository is dropped before terminal initialization and
+  the event loop.
 - View population opens a fresh non-isolated repository so mailmap, notes, diff
   drivers, pagers, signing, and other Git configuration are current. It starts
   without an object cache; bounded diff operations may enable one temporarily and
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index bda0d5568ff..5d1e314e039 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -796,8 +796,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     let _log_guard = logging::init();
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
-    let (validation_repository, _) = open_history_repository(&mut repository_path, &common_dir)?;
-    let (hide, unavailable) = history::available_hidden_revisions(&validation_repository, &options.hide, false)?;
+    let (hide, unavailable) = validate_hidden_revisions(&mut repository_path, &common_dir, &options.hide)?;
     options.hide = hide;
     for (revision, err) in unavailable {
         eprintln!(
@@ -837,6 +836,15 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     Ok(())
 }
 
+fn validate_hidden_revisions(
+    repository_path: &mut PathBuf,
+    common_dir: &Path,
+    hide: &[OsString],
+) -> Result<(Vec<OsString>, Vec<(OsString, String)>)> {
+    let (repository, _) = open_history_repository(repository_path, common_dir)?;
+    history::available_hidden_revisions(&repository, hide, false)
+}
+
 fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
     execute!(backend, EnableFocusChange, EnableMouseCapture)?;
     if enhanced_keyboard {
@@ -5730,6 +5738,20 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn startup_validation_returns_only_detached_hidden_revision_data() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
+        let repository = test_repository::open(&fixture)?;
+        let mut git_dir = repository.git_dir().to_owned();
+        let common_dir = repository.common_dir().to_owned();
+        drop(repository);
+
+        let (hide, unavailable) = validate_hidden_revisions(&mut git_dir, &common_dir, &[OsString::from("main")])?;
+        assert_eq!(hide, [OsString::from("main")]);
+        assert!(unavailable.is_empty(), "the fixture's main branch resolves");
+        Ok(())
+    }
+
     #[test]
     fn opens_the_common_repository_when_the_initial_worktree_is_already_gone() -> gix_testtools::Result {
         const COMMON_DIR: &str = "GIX_TIX_TEST_REMOVED_WORKTREE_COMMON_DIR";

From a147b4f7de4add4ec2759a0c06b152ff6f802da4 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 10:32:28 +0200
Subject: [PATCH 210/282] fix: limit change ID scans to filtered history views

Lane completion previously started a full change-ID scan even for unrestricted histories, keeping large repositories busy after their graph was ready.

Start the worker only when hidden tips are currently excluded, cancel it immediately on reload, and keep expanded or otherwise unrestricted views scan-free.
---
 gix-tix/spec.md    |  3 +++
 gix-tix/src/lib.rs | 35 ++++++++++++++++++++++++++++++-----
 2 files changed, 33 insertions(+), 5 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6b1b8e64fbb..fa64240add2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1044,6 +1044,9 @@ space first; changes blocks adapt within the remaining history width.
 - Traversal and incremental refresh workers may use a bounded object cache and
   must drop their repository when finished. Lane, verification, and line-diff
   workers exist only for active work and do not form persistent pools.
+- Change IDs are scanned only while configured hidden tips are actively excluded.
+  Unrestricted and explicitly expanded views perform no scan; expanding or
+  refreshing a view cancels any scan for its previous projection.
 - Redraw is reactive and capped at approximately 60 frames per second while
   streaming. Mouse events are drained and coalesced in bounded batches so input
   storms cannot starve the main loop.
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 5d1e314e039..1002b02eb4d 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1279,11 +1279,13 @@ fn event_loop(
                     if quit_on_finish {
                         return Ok(app.lane_time);
                     }
-                    change_id_worker = Some(start_change_id_scan(
-                        repository_path.clone(),
-                        repository_is_bare,
-                        app.rows.iter().map(|row| row.id).collect(),
-                    ));
+                    if change_id_scan_needed(&app) {
+                        change_id_worker = Some(start_change_id_scan(
+                            repository_path.clone(),
+                            repository_is_bare,
+                            app.rows.iter().map(|row| row.id).collect(),
+                        ));
+                    }
                 }
                 Err(mpsc::TryRecvError::Empty) => {}
                 Err(mpsc::TryRecvError::Disconnected) => {
@@ -2080,6 +2082,7 @@ fn event_loop(
                     execute!(terminal.backend_mut(), CopyToClipboard::to_clipboard_from(actor))?;
                 }
                 Effect::Reload(show_hidden) => {
+                    change_id_worker = None;
                     app.show_hidden = show_hidden;
                     refresh_pending = true;
                     refresh_expand_hidden = true;
@@ -2715,6 +2718,10 @@ fn start_change_id_scan(repository_path: PathBuf, bare: bool, ids: Vec<gix::Obje
     ChangeIdWorker { cancelled, results }
 }
 
+fn change_id_scan_needed(app: &App) -> bool {
+    app.has_hidden_filter && !app.show_hidden
+}
+
 type SignatureVerification = (gix::ObjectId, bool);
 
 fn start_signature_verification(
@@ -5034,6 +5041,24 @@ mod tests {
         assert_eq!(shade_terminal_background((32, 64, 128), false), (30, 60, 120));
     }
 
+    #[test]
+    fn scans_change_ids_only_for_the_current_filtered_view() {
+        let mut app = App::new(1);
+        assert!(!change_id_scan_needed(&app), "unrestricted history needs no scan");
+
+        app.configure_hidden_filter(true);
+        assert!(
+            change_id_scan_needed(&app),
+            "excluded hidden tips make the view limited"
+        );
+
+        app.show_hidden = true;
+        assert!(
+            !change_id_scan_needed(&app),
+            "expanding hidden history makes the current view unrestricted"
+        );
+    }
+
     #[test]
     fn retains_unseen_filesystem_redraws_until_focus_returns() {
         assert!(!unseen_filesystem_redraw(false, false, false));

From cfd4948476d40a9cb6d1933bfb9d5857a37f7c34 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 10:38:36 +0200
Subject: [PATCH 211/282] feat: add --todo to tix new and split

Command-line commit creation previously required editing the Todo header manually, and split had no option for marking its new upper commit.

Seed the existing editable enrichment header from --todo for both commands. Explicit new messages apply it directly, while editor users can still comment it out; split keeps pre-existing source enrichments on the rewritten lower identity.
---
 gix-tix/spec.md            | 11 +++++---
 gix-tix/src/command.rs     | 51 ++++++++++++++++++++++++++++++++------
 gix-tix/src/command/new.rs | 51 +++++++++++++++++++++++++++++++++++++-
 gix-tix/src/edit/create.rs | 13 +++++++---
 gix-tix/src/edit/split.rs  |  8 +++---
 gix-tix/src/lib.rs         |  2 +-
 6 files changed, 115 insertions(+), 21 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index fa64240add2..b2eaff4744f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -35,7 +35,7 @@ without trading responsiveness for metadata that is not visible.
   then exits with an error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state at `HEAD` through the same
   commit-stash operation as the TUI.
-- `tix new [--index | --worktree | --worktree-untracked] [--allow-empty]
+- `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
   worktree-safety rules as `e n`. By default a changed index wins and tracked
@@ -45,7 +45,8 @@ without trading responsiveness for metadata that is not visible.
   additionally includes non-ignored untracked files. An unchanged selected tree
   is rejected unless `--allow-empty` is given. Message files,
   repeated messages, standard input, editor bypass, and `--author` follow
-  `tix reword`; the author uses the prepared new-commit date.
+  `tix reword`; the author uses the prepared new-commit date. `--todo` enables
+  the new commit's editable Todo header.
 - `tix reword REVSPEC [--author "Name <email>"] [-m MESSAGE ... | -f FILE]`
   applies the same signing,
   lazy-rebase, mutable-ref, and worktree-safety rules as the TUI. Without either
@@ -680,9 +681,11 @@ space first; changes blocks adapt within the remaining history width.
   commit from the staged delta using the standard Markdown editor buffer. Both
   deltas are three-way applied in memory before the editor opens, so overlapping
   changes abort without writing objects or changing refs, the index, or files.
-- `tix split` performs the same split at `HEAD`: worktree changes are amended
+- `tix split [--todo]` performs the same split at `HEAD`: worktree changes are amended
   into the source commit and staged index changes become the new commit on top.
-  Its upper-commit editor uses the same enrichment headers as the new-commit editor.
+  Its upper-commit editor uses the same enrichment headers as the new-commit
+  editor; `--todo` enables its Todo header. Existing source enrichments stay
+  with the rewritten lower commit.
 - A successful split leaves the worktree bytes untouched and resets the index to
   the new upper commit. The rewritten source retains its message and ancestry;
   the upper commit receives the edited message. Their final trees and ancestry
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index d16595ca268..485afa8f425 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -42,7 +42,7 @@ enum Command {
     /// Move the changes introduced by HEAD into the worktree.
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
-    Split,
+    Split(Split),
     /// Save index and worktree changes at HEAD.
     Stash,
     /// Pin one or more commits as persistent history tips.
@@ -94,6 +94,13 @@ struct Amend {
     index: bool,
 }
 
+#[derive(Debug, clap::Args)]
+struct Split {
+    /// Mark the new upper commit as TODO.
+    #[arg(long)]
+    todo: bool,
+}
+
 #[derive(Debug, clap::Args)]
 struct Pin {
     /// Revisions resolving to commits to pin.
@@ -164,9 +171,9 @@ impl Platform {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
                 edit_head(repository, &graph, crate::edit::head::Kind::Spill, "spill")?;
             }
-            Command::Split => {
+            Command::Split(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
-                split(repository, &graph)?;
+                split(repository, &graph, args)?;
             }
             Command::Stash => {
                 let id = repository
@@ -484,10 +491,10 @@ fn edit_head(
     Ok(())
 }
 
-fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<()> {
+fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph, args: Split) -> Result<()> {
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
-    let prepared = crate::edit::split::prepare(repository)?;
+    let prepared = crate::edit::split::prepare(repository, args.todo)?;
     let Some(edited) = crate::edit::edit_document_without_terminal(
         &prepared.editor,
         &prepared.document,
@@ -676,7 +683,14 @@ mod tests {
                 .expect("split parses")
                 .platform
                 .command,
-            Some(Command::Split)
+            Some(Command::Split(Split { todo: false }))
+        ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "split", "--todo"])
+                .expect("TODO split parses")
+                .platform
+                .command,
+            Some(Command::Split(Split { todo: true }))
         ));
         assert!(matches!(
             Cli::try_parse_from(["tix", "stash"])
@@ -744,6 +758,7 @@ mod tests {
             "new",
             "--index",
             "--allow-empty",
+            "--todo",
             "--author",
             "Agent <agent@example.com>",
             "-m",
@@ -759,6 +774,7 @@ mod tests {
         assert!(!new.worktree);
         assert!(!new.worktree_untracked);
         assert!(new.allow_empty);
+        assert!(new.todo);
         assert_eq!(new.edit.message, ["title"]);
         assert!(Cli::try_parse_from(["tix", "new", "--index", "--worktree", "-m", "title"]).is_err());
         assert!(Cli::try_parse_from(["tix", "new", "--index", "--worktree-untracked", "-m", "title"]).is_err());
@@ -1101,13 +1117,34 @@ mod tests {
         let repository =
             crate::test_repository::open_with(fixture.path(), ["core.editor=sed -i.bak -e 's/^what$/split/'"])?;
         let graph = crate::edit::loaded_view_graph(&repository)?;
-        split(repository, &graph)?;
+        let original = repository.head_id()?.detach();
+        crate::enrich::set_note(&repository, original, Some(b"source marker"))?;
+        split(repository, &graph, Split { todo: true })?;
 
         assert_eq!(git(fixture.path(), &["log", "-1", "--format=%s"])?, b"split\n");
         assert_eq!(git(fixture.path(), &["show", "HEAD^:unstaged"])?, b"worktree\n");
         assert_eq!(git(fixture.path(), &["show", "HEAD:staged"])?, b"staged\n");
         assert!(git(fixture.path(), &["diff", "--exit-code"])?.is_empty());
         assert!(git(fixture.path(), &["diff", "--cached", "--exit-code"])?.is_empty());
+        let repository = crate::test_repository::open(fixture.path())?;
+        let upper = repository.head_id()?.detach();
+        let lower = repository
+            .find_commit(upper)?
+            .parent_ids()
+            .next()
+            .expect("split has a lower commit")
+            .detach();
+        let mut enrichments = crate::enrich::open(&repository)?;
+        assert_eq!(
+            crate::enrich::load(&mut enrichments, crate::change_id::for_commit(&repository, upper)?)?,
+            crate::enrich::Enrichment { todo: true, note: None },
+            "--todo marks only the new upper commit"
+        );
+        assert_eq!(
+            crate::enrich::load(&mut enrichments, crate::change_id::for_commit(&repository, lower)?)?.note,
+            Some("source marker".into()),
+            "the original enrichment remains with the rewritten lower identity"
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index 718d566891a..fb5485e464c 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -14,6 +14,9 @@ pub(super) struct Args {
     /// Create the commit even when the selected tree is unchanged.
     #[arg(long)]
     pub(super) allow_empty: bool,
+    /// Mark the new commit as TODO.
+    #[arg(long)]
+    pub(super) todo: bool,
     #[command(flatten)]
     pub(super) edit: super::reword::MessageArgs,
 }
@@ -43,7 +46,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("author is not valid UTF-8")?;
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
-    let prepared = crate::edit::create::prepare_from(repository, parent, source, author.as_deref())?;
+    let prepared = crate::edit::create::prepare_from(repository, parent, source, author.as_deref(), args.todo)?;
     if prepared.is_empty && !args.allow_empty {
         anyhow::bail!("the new commit would be empty; use --allow-empty to create it anyway");
     }
@@ -92,6 +95,7 @@ mod tests {
             worktree: false,
             worktree_untracked: false,
             allow_empty: false,
+            todo: false,
             edit: super::super::reword::MessageArgs {
                 message: vec!["new title".into(), "new body".into()],
                 file: None,
@@ -134,6 +138,51 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn explicit_message_can_mark_the_new_commit_as_todo() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let mut input = args();
+        input.todo = true;
+        run(crate::test_repository::open(fixture.path())?, input)?;
+
+        let repository = crate::test_repository::open(fixture.path())?;
+        let id = repository.head_id()?.detach();
+        assert!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, id)?,
+            )?
+            .todo,
+            "--todo marks a non-interactive new commit"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn editor_can_clear_the_prefilled_todo() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let mut input = args();
+        input.todo = true;
+        input.edit.message.clear();
+        input.edit.author = None;
+        run(
+            crate::test_repository::open_with(fixture.path(), ["core.editor=sed -i.bak -e 's/^Todo$/;Todo/'"])?,
+            input,
+        )?;
+
+        let repository = crate::test_repository::open(fixture.path())?;
+        let id = repository.head_id()?.detach();
+        assert!(
+            !crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, id)?,
+            )?
+            .todo,
+            "commenting the prefilled header overrides --todo"
+        );
+        Ok(())
+    }
+
     #[test]
     fn index_and_worktree_select_only_their_requested_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 860299d20ee..f3fb7e77bda 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -30,12 +30,12 @@ pub(crate) enum Source {
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
 pub(crate) fn prepare(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
-    prepare_inner(repo, parent, false, Source::Default, None)
+    prepare_inner(repo, parent, false, Source::Default, None, false)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?parent))]
 pub(crate) fn prepare_empty(repo: gix::Repository, parent: Option<ObjectId>) -> Result<Prepared> {
-    prepare_inner(repo, parent, true, Source::Default, None)
+    prepare_inner(repo, parent, true, Source::Default, None, false)
 }
 
 pub(crate) fn prepare_from(
@@ -43,8 +43,9 @@ pub(crate) fn prepare_from(
     parent: Option<ObjectId>,
     source: Source,
     author: Option<&gix::bstr::BStr>,
+    todo: bool,
 ) -> Result<Prepared> {
-    prepare_inner(repo, parent, false, source, author)
+    prepare_inner(repo, parent, false, source, author, todo)
 }
 
 fn prepare_inner(
@@ -53,6 +54,7 @@ fn prepare_inner(
     empty: bool,
     source: Source,
     author_override: Option<&gix::bstr::BStr>,
+    todo: bool,
 ) -> Result<Prepared> {
     repo.workdir().context("creating a commit requires a worktree")?;
     let head = repo.head().context("could not read HEAD before creating a commit")?;
@@ -130,7 +132,10 @@ fn prepare_inner(
         &mut document,
         &author,
         &committer,
-        &crate::enrich::Enrichment::default(),
+        &crate::enrich::Enrichment {
+            todo,
+            ..Default::default()
+        },
     )?;
     document.extend_from_slice(b"\nwhat\n\nwhy\n");
     for trailer in reword::missing_agent_trailers(b"what\n\nwhy\n").into_iter().flatten() {
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index d2c88f506eb..b6143363887 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -14,7 +14,7 @@ pub(crate) struct Prepared {
 }
 
 #[tracing::instrument(skip_all)]
-pub(crate) fn prepare(mut repo: gix::Repository) -> Result<Prepared> {
+pub(crate) fn prepare(mut repo: gix::Repository, todo: bool) -> Result<Prepared> {
     let target = repo
         .head_id()
         .context("splitting requires an existing HEAD commit")?
@@ -36,7 +36,7 @@ pub(crate) fn prepare(mut repo: gix::Repository) -> Result<Prepared> {
         .context("could not decode HEAD commit")?
         .into_owned()
         .context("could not own HEAD commit")?;
-    let mut create = create::prepare(repo.clone(), Some(target))?;
+    let mut create = create::prepare_from(repo.clone(), Some(target), create::Source::Default, None, todo)?;
     repo.objects.set_object_memory(std::mem::take(&mut create.objects));
 
     let head_tree = source.tree;
@@ -142,7 +142,7 @@ mod tests {
             git(fixture.path(), &["update-ref", name, &old.to_string()])?;
         }
         let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let prepared = prepare(open(fixture.path())?)?;
+        let prepared = prepare(open(fixture.path())?, false)?;
         assert_eq!(
             prepared
                 .document
@@ -271,7 +271,7 @@ mod tests {
             b"one\nworktree conflict\nmiddle\nbase worktree\nend\n",
         )?;
         let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let err = match prepare(open(fixture.path())?) {
+        let err = match prepare(open(fixture.path())?, false) {
             Ok(_) => return Err("overlapping staged and worktree hunks should conflict".into()),
             Err(err) => err,
         };
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 1002b02eb4d..a2b35a1be42 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -4095,7 +4095,7 @@ fn split_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before splitting HEAD")?;
     repository.object_cache_size(None);
-    let prepared = edit::split::prepare(repository)?;
+    let prepared = edit::split::prepare(repository, false)?;
     let Some(edited) = edit::edit_document(
         terminal,
         &prepared.editor,

From 4bf056d02dc1495a10a02da211459b66cd385a5c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 10:49:41 +0200
Subject: [PATCH 212/282] feat: edit and preserve Git notes in tix

Expose the configured default Git note in the enrichment menu for every selected commit, including immutable history boundaries. Empty editor content removes the note and unchanged content leaves the repository untouched.

Record only actual predecessor-to-successor rewrites so notes follow rewritten commits without leaking through synthetic insert or drop mappings. Concatenate converging squash notes, keep split notes on the lower identity, and update the notes ref atomically with the existing rebase transaction and rollback.
---
 gix-tix/spec.md            |  13 ++-
 gix-tix/src/app.rs         |  28 ++++-
 gix-tix/src/edit/rebase.rs | 214 +++++++++++++++++++++++++++++++++++--
 gix-tix/src/edit/split.rs  |  27 +++++
 gix-tix/src/lib.rs         | 137 ++++++++++++++++++++++++
 gix-tix/src/ui.rs          |  21 ++--
 6 files changed, 419 insertions(+), 21 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b2eaff4744f..6315341a958 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -221,6 +221,16 @@ without trading responsiveness for metadata that is not visible.
   purple `[A]` before its title.
 - A commit with notes in the configured notes ref receives a matching `[N]`.
   Notes are loaded lazily for visible commits.
+- `n g` edits the selected commit's note in `core.notesRef`, or
+  `refs/notes/commits` when it is unset. The action is available on every
+  selected commit, including immutable hidden boundaries. Empty content removes
+  the note and unchanged content is a no-op.
+- Every operation that actually rewrites a commit copies its default-ref Git
+  note to the successor while retaining the predecessor note. Notes that converge
+  through a squash are concatenated in source order with a blank line. A split
+  copies the source note only to its rewritten lower identity; inserted and
+  dropped commits do not propagate notes. The notes ref changes atomically with
+  the other rebase refs and participates in rollback.
 - Tix enrichments are stored separately as Git notes headed at the worktree-local
   `refs/worktree/tix/enrich` ref. Enrichments are keyed by the commit's effective
   change ID and use human-readable Git config. Independent `[commit]` keys store
@@ -979,7 +989,8 @@ space first; changes blocks adapt within the remaining history width.
 - The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
   `n t` toggles `[commit] todo`, preserving a saved note, and `n o` opens
   `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
-  the todo flag, and toggling todo preserves the note. The group is mutually
+  the todo flag, and toggling todo preserves the note. `n g` edits the real Git
+  note and remains available when the Tix-specific actions are not. The group is mutually
   exclusive with the view, edit, and information groups and otherwise follows
   their closing behavior.
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 6d785076f8d..d68e2a50654 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -356,6 +356,7 @@ pub(crate) enum Action {
     ToggleEnrich,
     ToggleTodo,
     EditNote,
+    EditGitNote,
     ToggleInformation,
     ToggleAlign,
     ToggleCommit,
@@ -424,6 +425,7 @@ pub(crate) enum Effect {
     Unpin(ObjectId),
     ToggleTodo(ObjectId),
     EditNote(ObjectId),
+    EditGitNote(ObjectId),
     VerifySignatures(Vec<ObjectId>),
     Quit,
 }
@@ -942,6 +944,10 @@ impl App {
         self.notes.insert(id, notes);
     }
 
+    pub(crate) fn clear_notes(&mut self, id: ObjectId) {
+        self.notes.remove(&id);
+    }
+
     pub(crate) fn notes(&self, id: ObjectId) -> &[BString] {
         self.notes.get(&id).map(Vec::as_slice).unwrap_or_default()
     }
@@ -1032,7 +1038,10 @@ impl App {
         ) {
             self.edit_expanded = false;
         }
-        if !matches!(&action, Action::ToggleEnrich | Action::ToggleTodo | Action::EditNote) {
+        if !matches!(
+            &action,
+            Action::ToggleEnrich | Action::ToggleTodo | Action::EditNote | Action::EditGitNote
+        ) {
             self.enrich_expanded = false;
         }
         if !matches!(
@@ -1377,6 +1386,11 @@ impl App {
                     self.rows[self.selected.expect("note requires a selection")].id,
                 )];
             }
+            Action::EditGitNote => {
+                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                    return vec![Effect::EditGitNote(id)];
+                }
+            }
             Action::VerifySignatures if !self.signature_verification_running => {
                 let start = self.offset.min(self.rows.len());
                 let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
@@ -3974,7 +3988,7 @@ mod tests {
     }
 
     #[test]
-    fn enrich_group_updates_only_mutable_commits() {
+    fn enrich_group_keeps_git_notes_available_on_immutable_commits() {
         let mut app = App::new(1);
         app.extend_commits(vec![row(1)]);
         complete(&mut app);
@@ -3991,6 +4005,11 @@ mod tests {
             vec![Effect::EditNote(id(1))],
             "note uses the same eligibility"
         );
+        assert_eq!(
+            app.update(Action::EditGitNote),
+            vec![Effect::EditGitNote(id(1))],
+            "Git notes are available on every selection"
+        );
         assert!(app.enrich_expanded, "the grouped actions keep enrich open");
 
         app.update(Action::MoveDown);
@@ -4006,6 +4025,11 @@ mod tests {
             "hidden boundaries are immutable"
         );
         assert!(app.update(Action::EditNote).is_empty());
+        assert_eq!(
+            app.update(Action::EditGitNote),
+            vec![Effect::EditGitNote(id(1))],
+            "immutable boundaries still accept Git notes"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index df3f8a6ee96..530a57a85d3 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -384,6 +384,7 @@ struct Prepared {
     skip_worktree_transitions: bool,
     selected: Option<ObjectId>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
+    note_rewrites: Vec<(ObjectId, ObjectId)>,
     stash_rewritten: HashMap<ObjectId, Option<ObjectId>>,
     removed: HashSet<ObjectId>,
     committer: gix::actor::Signature,
@@ -535,6 +536,7 @@ fn perform_inner(
     repo = repo.with_object_memory();
 
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut note_rewrites = Vec::new();
     let mut selected = None;
     let mut conflict = None;
     if inserted || forked {
@@ -653,6 +655,9 @@ fn perform_inner(
         };
         let new_id = write_commit(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
         report(old_id);
+        if new_id != old_id {
+            note_rewrites.push((old_id, new_id));
+        }
         rewritten.insert(old_id, Some(new_id));
         if let Some((tree, conflicts)) = new_conflict {
             conflict = Some((old_id, tree, conflicts, new_id));
@@ -688,6 +693,7 @@ fn perform_inner(
             || forked
             || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
         selected,
+        note_rewrites,
         stash_rewritten: rewritten.clone(),
         rewritten,
         removed: if removed {
@@ -761,6 +767,7 @@ pub(super) fn finish_review(
     }
 
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut note_rewrites = Vec::new();
     let mut finished_review = None;
     for old in &review_ids {
         let old_parents = graph.parents_of(*old).context("a review descendant is incomplete")?;
@@ -789,6 +796,9 @@ pub(super) fn finish_review(
             CommitState::Unmarked(Signature::RedoIfNeeded),
             signing.clone(),
         )?;
+        if new != *old {
+            note_rewrites.push((*old, new));
+        }
         rewritten.insert(*old, Some(new));
         if *old == review {
             finished_review = Some(new);
@@ -836,6 +846,9 @@ pub(super) fn finish_review(
             },
             signing.clone(),
         )?;
+        if new != old {
+            note_rewrites.push((old, new));
+        }
         rewritten.insert(old, Some(new));
     }
 
@@ -849,6 +862,7 @@ pub(super) fn finish_review(
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected: Some(selected),
+        note_rewrites,
         stash_rewritten: rewritten.clone(),
         rewritten,
         removed: HashSet::new(),
@@ -923,6 +937,7 @@ pub(crate) fn perform_plan_with_progress(
     }
 
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
+    let mut note_rewrites = Vec::new();
     let mut produced = Vec::with_capacity(plan.steps.len());
     let mut delete_refs = Vec::new();
     let mut conflict = None;
@@ -1045,8 +1060,8 @@ pub(crate) fn perform_plan_with_progress(
             );
             squashed.push((*id, source, replay_parents));
         }
+        let mut applied_squash = 0;
         if !squashed.is_empty() && conflict.is_none() && step_conflict.is_none() {
-            let mut applied = 0;
             for (squash_index, (id, source, replay_parents)) in squashed.iter().enumerate() {
                 let old_base = parent_tree(&repo, replay_parents.first().copied())?;
                 let started = Instant::now();
@@ -1061,7 +1076,7 @@ pub(crate) fn perform_plan_with_progress(
                         ours
                     }
                 };
-                applied += 1;
+                applied_squash += 1;
                 if step_conflict.is_some() {
                     break;
                 }
@@ -1071,7 +1086,7 @@ pub(crate) fn perform_plan_with_progress(
                 report(progress);
                 delete_refs.extend(super::review::deletions(&repo, source)?);
             }
-            squash_message(&repo, &mut commit, &squashed[..applied])?;
+            squash_message(&repo, &mut commit, &squashed[..applied_squash])?;
         }
         commit.parents = [parent].into_iter().collect();
         let state = if step_conflict.is_some() {
@@ -1100,8 +1115,17 @@ pub(crate) fn perform_plan_with_progress(
         report(progress);
         if let PlanCommit::Pick(old_id) | PlanCommit::Resolved(old_id) = step.commit {
             rewritten.insert(old_id, Some(new_id));
+            if old_id != new_id {
+                note_rewrites.push((old_id, new_id));
+            }
         }
-        for old_id in &step.squash {
+        for old_id in step.squash.iter().take(applied_squash) {
+            rewritten.insert(*old_id, Some(new_id));
+            if *old_id != new_id {
+                note_rewrites.push((*old_id, new_id));
+            }
+        }
+        for old_id in step.squash.iter().skip(applied_squash) {
             rewritten.insert(*old_id, Some(new_id));
         }
         produced.push(new_id);
@@ -1206,6 +1230,7 @@ pub(crate) fn perform_plan_with_progress(
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected,
+        note_rewrites,
         rewritten: rewritten.clone(),
         stash_rewritten: rewritten.clone(),
         removed,
@@ -1296,7 +1321,10 @@ impl Prepared {
     }
 
     fn finish(&mut self) -> Result<Outcome> {
-        let stash_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
+        let mut resource_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
+        let note_edits = note_rewrite_edits(&self.repo, &self.note_rewrites, &self.committer)?;
+        resource_edits.forward.extend(note_edits.forward);
+        resource_edits.rollback.extend(note_edits.rollback);
         self.persist_objects()?;
         let _ = self
             .repo
@@ -1348,7 +1376,7 @@ impl Prepared {
             &self.committer,
             self.expected_refs.take(),
             (&self.pins, &self.delete_refs),
-            stash_edits,
+            resource_edits,
         )?;
         for (transitioned, transition) in transitions.iter().enumerate() {
             if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
@@ -1383,6 +1411,83 @@ impl Prepared {
     }
 }
 
+fn note_rewrite_edits(
+    repo: &gix::Repository,
+    rewrites: &[(ObjectId, ObjectId)],
+    committer: &gix::actor::Signature,
+) -> Result<super::stash::RewriteEdits> {
+    let empty = || super::stash::RewriteEdits {
+        forward: Vec::new(),
+        rollback: Vec::new(),
+    };
+    if rewrites.is_empty() {
+        return Ok(empty());
+    }
+    let notes = repo.notes().map_err(gix::Exn::into_error)?;
+    let Some(name) = notes.default_ref().map(ToOwned::to_owned) else {
+        return Ok(empty());
+    };
+    let (original_root, parent) = match repo.try_find_reference(name.as_ref())? {
+        Some(mut reference) => {
+            let parent = reference
+                .try_id()
+                .context("the default Git notes reference must be direct")?
+                .detach();
+            let root = reference
+                .peel_to_tree()
+                .context("could not read the default Git notes tree")?
+                .id;
+            (root, Some(parent))
+        }
+        None => (ObjectId::empty_tree(repo.object_hash()), None),
+    };
+    let mut root = original_root;
+    let mut cache = gix::note::Cache::default();
+    for &(old, new) in rewrites {
+        let Some(source) = gix::note::get(original_root, &old, repo, &mut cache)
+            .map_err(gix::Exn::into_error)
+            .context("could not find a Git note to copy")?
+        else {
+            continue;
+        };
+        let source = repo.find_blob(source).context("could not read a Git note to copy")?;
+        let destination = gix::note::get(root, &new, repo, &mut cache)
+            .map_err(gix::Exn::into_error)
+            .context("could not inspect the successor Git note")?;
+        let data = match destination {
+            Some(destination) => {
+                let destination = repo
+                    .find_blob(destination)
+                    .context("could not read the successor Git note")?;
+                let mut data = destination.data.clone();
+                data.extend_from_slice(b"\n\n");
+                data.extend_from_slice(&source.data);
+                data
+            }
+            None => source.data.clone(),
+        };
+        let note = repo.write_blob(data)?.detach();
+        root = gix::note::add(root, new, note, repo, &mut cache)
+            .map_err(gix::Exn::into_error)
+            .context("could not copy a Git note onto its successor")?
+            .tree;
+    }
+    if root == original_root {
+        return Ok(empty());
+    }
+
+    let mut time = gix::date::parse::TimeBuf::default();
+    let actor = committer.to_ref(&mut time);
+    let commit = repo
+        .new_commit_as(actor, actor, "Notes copied by tix", root, parent)
+        .context("could not prepare the rewritten Git notes commit")?
+        .id;
+    Ok(super::stash::RewriteEdits {
+        forward: vec![ref_edit(name.clone(), parent, Some(commit))],
+        rollback: vec![ref_edit(name, Some(commit), parent)],
+    })
+}
+
 fn rollback<T>(
     repo: &gix::Repository,
     committer: &gix::actor::Signature,
@@ -2160,10 +2265,40 @@ mod tests {
     fn open(path: &Path) -> gix_testtools::Result<gix::Repository> {
         Ok(crate::test_repository::open_with(
             path,
-            ["user.name=rebasing committer", "user.email=rebasing@example.com"],
+            [
+                "user.name=rebasing committer",
+                "user.email=rebasing@example.com",
+                "core.notesRef=refs/notes/review",
+            ],
         )?)
     }
 
+    fn set_git_note(repo: &gix::Repository, id: ObjectId, data: &[u8]) -> gix_testtools::Result {
+        let mut notes = repo.notes().map_err(gix::Exn::into_error)?;
+        let reference = notes
+            .default_ref()
+            .expect("the test repository has a default notes ref")
+            .to_owned();
+        notes
+            .add_to_ref(reference.as_ref(), id, data)
+            .map_err(gix::Exn::into_error)?;
+        Ok(())
+    }
+
+    fn git_note(repo: &gix::Repository, id: ObjectId) -> gix_testtools::Result<Option<Vec<u8>>> {
+        let notes = repo.notes().map_err(gix::Exn::into_error)?;
+        let reference = notes
+            .default_ref()
+            .expect("the test repository has a default notes ref")
+            .to_owned();
+        let mut notes = notes.with_refs([reference.as_bstr()]).map_err(gix::Exn::into_error)?;
+        Ok(notes
+            .get(id)
+            .map_err(gix::Exn::into_error)?
+            .first()
+            .map(|note| note.blob.data.clone()))
+    }
+
     #[test]
     fn rewords_a_middle_commit_and_reparents_all_linear_descendants() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -2229,6 +2364,50 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn git_notes_follow_each_actual_rewritten_successor() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+        set_git_note(&repo, middle, b"middle note")?;
+        set_git_note(&repo, old_tip, b"tip note")?;
+        let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+        commit.message = "rewritten middle".into();
+
+        let outcome = perform(
+            &repo,
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIs,
+        )?
+        .complete()?;
+        let new_middle = outcome.selected.context("the replacement is selected")?;
+        let new_tip = repo.head_id()?.detach();
+        for (old, new, note) in [
+            (middle, new_middle, b"middle note".as_slice()),
+            (old_tip, new_tip, b"tip note".as_slice()),
+        ] {
+            assert_eq!(
+                git_note(&repo, old)?.as_deref(),
+                Some(note),
+                "the predecessor retains its Git note"
+            );
+            assert_eq!(
+                git_note(&repo, new)?.as_deref(),
+                Some(note),
+                "the rewritten successor receives the Git note"
+            );
+        }
+        assert!(
+            repo.try_find_reference("refs/notes/review")?.is_some(),
+            "the configured default notes ref is updated"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rewriting_a_stashed_commit_moves_its_stash_association() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -2268,6 +2447,7 @@ mod tests {
         let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let old_tip_tree = repo.find_commit(repo.head_id()?)?.tree_id()?.detach();
+        set_git_note(&repo, middle, b"removed note")?;
 
         let outcome = perform(
             &repo,
@@ -2289,6 +2469,12 @@ mod tests {
             old_tip_tree,
             "the removed commit's tree contribution is absent"
         );
+        assert_eq!(git_note(&repo, middle)?.as_deref(), Some(b"removed note".as_slice()));
+        assert_eq!(
+            git_note(&repo, tip)?,
+            None,
+            "a dropped commit does not donate its Git note"
+        );
         Ok(())
     }
 
@@ -2843,6 +3029,8 @@ mod tests {
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let tip = repo.head_id()?.detach();
         let tip_tree = repo.find_commit(tip)?.tree_id()?.detach();
+        set_git_note(&repo, middle, b"middle note")?;
+        set_git_note(&repo, tip, b"tip note")?;
 
         let mut progress = Vec::new();
         let outcome = perform_plan_with_progress(
@@ -2895,6 +3083,11 @@ mod tests {
             combined,
             "a ref on the first source follows the combined commit"
         );
+        assert_eq!(
+            git_note(&repo, combined)?.as_deref(),
+            Some(b"middle note\n\ntip note".as_slice()),
+            "squashed Git notes concatenate in source order"
+        );
         Ok(())
     }
 
@@ -3181,6 +3374,8 @@ mod tests {
         let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
         let tip = repo.head_id()?.detach();
+        set_git_note(&repo, tip, b"atomic note")?;
+        let notes_before = repo.find_reference("refs/notes/review")?.id().detach();
         let expected_refs = capture_refs(&repo, &[middle, tip], &[tip])?;
         assert!(
             Command::new("git")
@@ -3215,6 +3410,11 @@ mod tests {
             base,
             "a concurrent branch update wins"
         );
+        assert_eq!(
+            repo.find_reference("refs/notes/review")?.id().detach(),
+            notes_before,
+            "a failed branch transaction cannot partially advance the notes ref"
+        );
         assert!(
             format!("{err:#}").contains("reference"),
             "the failure identifies reference persistence: {err:#}"
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index b6143363887..d884766ea21 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -177,6 +177,15 @@ mod tests {
             .replacen(b"what\n\nwhy", b"upper\n\nreason", 1)
             .replacen(b";Todo\n;Message:", b"Todo\nMessage: split enrichment", 1);
         let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let repository = open(fixture.path())?;
+        let mut notes = repository.notes().map_err(gix::Exn::into_error)?;
+        let notes_ref = notes
+            .default_ref()
+            .expect("the test repository has a default notes ref")
+            .to_owned();
+        notes
+            .add_to_ref(notes_ref.as_ref(), old, b"source Git note")
+            .map_err(gix::Exn::into_error)?;
         let upper = apply(open(fixture.path())?, &graph, prepared, &edited)?;
         let repository = open(fixture.path())?;
         assert_eq!(
@@ -228,6 +237,24 @@ mod tests {
             old.into(),
             "the rewritten lower commit inherits the original identity"
         );
+        let mut notes = repository
+            .notes()
+            .map_err(gix::Exn::into_error)?
+            .with_refs([notes_ref.as_bstr()])
+            .map_err(gix::Exn::into_error)?;
+        assert_eq!(
+            notes
+                .get(source)
+                .map_err(gix::Exn::into_error)?
+                .first()
+                .map(|note| note.blob.data.as_slice()),
+            Some(b"source Git note".as_slice()),
+            "the rewritten lower commit receives the source Git note"
+        );
+        assert!(
+            notes.get(upper).map_err(gix::Exn::into_error)?.is_empty(),
+            "the newly inserted upper commit receives no source Git note"
+        );
         assert_eq!(
             repository
                 .find_commit(upper)?
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a2b35a1be42..e46b102df4a 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2682,6 +2682,18 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("note: {err:#}")),
                     }
                 }
+                Effect::EditGitNote(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit_git_note(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
+                        Ok(Some(saved)) => {
+                            app.clear_notes(id);
+                            app.leave_success(if saved { "saved Git note" } else { "cleared Git note" });
+                        }
+                        Ok(None) => {}
+                        Err(err) => app.leave_error(format!("Git note: {err:#}")),
+                    }
+                }
                 Effect::VerifySignatures(ids) => {
                     verification_receiver = Some(start_signature_verification(
                         repository_path.clone(),
@@ -3743,6 +3755,79 @@ fn edit_note(
     enrich::set_note(&repository, id, desired_note.map(AsRef::as_ref)).map(Some)
 }
 
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
+fn edit_git_note(
+    terminal: &mut ratatui::DefaultTerminal,
+    repository_path: &Path,
+    bare: bool,
+    id: gix::ObjectId,
+    enhanced_keyboard: bool,
+) -> Result<Option<bool>> {
+    let (editor, reference, document) = {
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not open repository before editing Git note")?;
+        let editor = repository.editor().context("no Git editor is available")?;
+        let notes = repository.notes().map_err(gix::Exn::into_error)?;
+        let reference = notes
+            .default_ref()
+            .context("no default Git notes reference is configured")?
+            .to_owned();
+        let mut notes = notes.with_refs([reference.as_bstr()]).map_err(gix::Exn::into_error)?;
+        let document = notes
+            .get(id)
+            .map_err(gix::Exn::into_error)?
+            .first()
+            .map(|note| note.blob.data.clone())
+            .unwrap_or_default();
+        (editor, reference, document)
+    };
+    let edited = edit::edit_document(
+        terminal,
+        &editor,
+        &document,
+        &format!("tix-git-note-{}.md", std::process::id()),
+        enhanced_keyboard,
+    )?;
+    let cleaned = edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
+    if cleaned == document {
+        return Ok(None);
+    }
+
+    let repository =
+        open_repository(repository_path, bare, false).context("could not reopen repository after editing Git note")?;
+    set_git_note(
+        &repository,
+        reference.as_ref(),
+        id,
+        (!cleaned.is_empty()).then_some(cleaned.as_ref()),
+    )?;
+    Ok(Some(!cleaned.is_empty()))
+}
+
+fn set_git_note(
+    repository: &gix::Repository,
+    reference: &gix::refs::FullNameRef,
+    id: gix::ObjectId,
+    data: Option<&[u8]>,
+) -> Result<()> {
+    let mut notes = repository.notes().map_err(gix::Exn::into_error)?;
+    match data {
+        Some(data) => {
+            notes
+                .add_to_ref(reference, id, data)
+                .map_err(gix::Exn::into_error)
+                .context("could not save Git note")?;
+        }
+        None => {
+            notes
+                .remove(reference.as_bstr(), id)
+                .map_err(gix::Exn::into_error)
+                .context("could not remove Git note")?;
+        }
+    }
+    Ok(())
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn reword_commit(
     terminal: &mut ratatui::DefaultTerminal,
@@ -4939,6 +5024,7 @@ fn action_with_shortcut_groups(
         KeyCode::PageUp => Some(Action::PageUp),
         KeyCode::PageDown => Some(Action::PageDown),
         KeyCode::Char('g') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Last),
+        KeyCode::Char('g') if enrich_expanded => Some(Action::EditGitNote),
         KeyCode::Home | KeyCode::Char('g') => Some(Action::First),
         KeyCode::End | KeyCode::Char('G') => Some(Action::Last),
         KeyCode::Char('d') if history_display_expanded => Some(Action::ToggleDate),
@@ -5237,6 +5323,48 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn creates_replaces_and_removes_a_git_note() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let id = repository.rev_parse_single("topic")?.detach();
+        let notes = repository.notes().map_err(gix::Exn::into_error)?;
+        let reference = notes
+            .default_ref()
+            .expect("the test repository has a default notes ref")
+            .to_owned();
+
+        for expected in [b"first".as_slice(), b"second".as_slice()] {
+            set_git_note(&repository, reference.as_ref(), id, Some(expected))?;
+            let mut notes = repository
+                .notes()
+                .map_err(gix::Exn::into_error)?
+                .with_refs([reference.as_bstr()])
+                .map_err(gix::Exn::into_error)?;
+            assert_eq!(
+                notes
+                    .get(id)
+                    .map_err(gix::Exn::into_error)?
+                    .first()
+                    .map(|note| note.blob.data.as_slice()),
+                Some(expected),
+                "the default note is created or replaced"
+            );
+        }
+
+        set_git_note(&repository, reference.as_ref(), id, None)?;
+        let mut notes = repository
+            .notes()
+            .map_err(gix::Exn::into_error)?
+            .with_refs([reference.as_bstr()])
+            .map_err(gix::Exn::into_error)?;
+        assert!(
+            notes.get(id).map_err(gix::Exn::into_error)?.is_empty(),
+            "empty editor content removes the note"
+        );
+        Ok(())
+    }
+
     #[test]
     fn selection_relation_prefers_tracking_counts_and_handles_missing_upstreams() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
@@ -6007,6 +6135,15 @@ mod tests {
             ),
             Some(Action::EditNote)
         );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE),
+                false,
+                false,
+                true
+            ),
+            Some(Action::EditGitNote)
+        );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 602dd47324a..48512ccb7b2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1119,15 +1119,14 @@ pub(crate) fn draw_with_worktree(
     ordered.extend(shortcut("enrich", 'n', true));
     if app.enrich_expanded {
         ordered.push(Span::raw(" ("));
-        if app.can_reword() {
-            let (todo, note) = app
-                .selected
-                .and_then(|index| app.rows.get(index))
-                .map(|row| (app.todo(row.id), app.note(row.id).is_some()))
-                .unwrap_or_default();
-            ordered.extend(shortcut("todo", 't', todo));
-            ordered.push(Span::raw(" · "));
-            ordered.extend(shortcut("note", 'o', note));
+        if let Some(row) = app.selected.and_then(|index| app.rows.get(index)) {
+            if app.can_reword() {
+                ordered.extend(shortcut("todo", 't', app.todo(row.id)));
+                ordered.push(Span::raw(" · "));
+                ordered.extend(shortcut("note", 'o', app.note(row.id).is_some()));
+                ordered.push(Span::raw(" · "));
+            }
+            ordered.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
         } else {
             ordered.push(Span::raw("no actions"));
         }
@@ -2653,8 +2652,8 @@ mod tests {
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).contains("enrich (todo · note)"),
-            "the enrich group advertises both actions"
+            rendered_line(&terminal, 1).contains("enrich (todo · note · git note)"),
+            "the enrich group advertises all note actions"
         );
         app.enrich_expanded = false;
 

From b39e659a3f5e2119ebd03218fda2acc841b19d58 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 11:47:18 +0200
Subject: [PATCH 213/282] Avoid parallel editor collisions in the --todo test

The --todo editor-override regression opened the same PID-derived temporary message path as another parallel command test, making the crate suite order-dependent.

Assert the prepared editable Todo header directly instead. The shared parser already covers commenting that header out, so no second editor process is needed.
---
 gix-tix/src/command/new.rs | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index fb5485e464c..54d54cf262b 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -159,26 +159,23 @@ mod tests {
     }
 
     #[test]
-    fn editor_can_clear_the_prefilled_todo() -> gix_testtools::Result {
+    fn todo_prefills_the_editable_header() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
-        let mut input = args();
-        input.todo = true;
-        input.edit.message.clear();
-        input.edit.author = None;
-        run(
-            crate::test_repository::open_with(fixture.path(), ["core.editor=sed -i.bak -e 's/^Todo$/;Todo/'"])?,
-            input,
-        )?;
-
         let repository = crate::test_repository::open(fixture.path())?;
-        let id = repository.head_id()?.detach();
+        let parent = repository.head_id()?.detach();
+        let prepared = crate::edit::create::prepare_from(
+            repository,
+            Some(parent),
+            crate::edit::create::Source::Default,
+            None,
+            true,
+        )?;
         assert!(
-            !crate::enrich::load(
-                &mut crate::enrich::open(&repository)?,
-                crate::change_id::for_commit(&repository, id)?,
-            )?
-            .todo,
-            "commenting the prefilled header overrides --todo"
+            prepared
+                .document
+                .windows(b"\nTodo\n".len())
+                .any(|window| window == b"\nTodo\n"),
+            "--todo activates the existing editable header"
         );
         Ok(())
     }

From 202bb0f62bc0210a2272ac89910a2b3f1bb96c65 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 12:31:01 +0200
Subject: [PATCH 214/282] feat: print change IDs with tix commit hashes

Make primary command output identify commits by both their abbreviated object ID and equally sized reverse-hex change ID. This covers mutation results, rewritten refs, pins, notices, raw ref-tree tips, and CLI rebase documents while leaving diagnostics, serialized todo state, and TUI editor output unchanged.
---
 gix-tix/spec.md                 |   6 ++
 gix-tix/src/change_id.rs        |  21 +++++
 gix-tix/src/command.rs          | 132 +++++++++++++++++++-------------
 gix-tix/src/command/new.rs      |  15 ++--
 gix-tix/src/command/rebase.rs   |  19 +++--
 gix-tix/src/command/reword.rs   |  43 +++++++----
 gix-tix/src/command/travel.rs   |  22 ++++--
 gix-tix/src/edit/time_travel.rs |   7 +-
 gix-tix/src/edit/todo.rs        |  89 +++++++++++++++------
 gix-tix/src/lib.rs              |   1 +
 gix-tix/src/ref_tree.rs         |  46 ++++++++---
 11 files changed, 277 insertions(+), 124 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6315341a958..351a2106c53 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -67,6 +67,12 @@ without trading responsiveness for metadata that is not visible.
   line. Editing that title preserves an existing message body byte-for-byte,
   while commenting, deleting, or emptying the header removes the whole message.
   Explicit `-m` and `-f` messages preserve enrichments.
+- Primary command output follows every displayed abbreviated commit hash with
+  its reverse-hex change ID. The two abbreviations have equal widths. This
+  applies to mutation results, rewritten-ref mappings, pins, stash and travel
+  notices, raw commit labels in `ref-tree`, and visible commit identifiers in
+  rebase todos. Diagnostics on stderr and the full object IDs in the hidden
+  `tix-rebase-state-v2` block remain unchanged.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index a708a41b21b..05d29e3f911 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -9,6 +9,7 @@ use gix::{
     ObjectId,
     bstr::{BStr, BString},
     hash::ChangeId,
+    prelude::ObjectIdExt,
 };
 
 pub(crate) const HEADER: &str = "change-id";
@@ -27,6 +28,26 @@ pub(crate) fn for_commit(repo: &gix::Repository, id: ObjectId) -> Result<ChangeI
     Ok(effective(id, commit.extra_headers().find_all(HEADER)))
 }
 
+pub(crate) fn display(repo: &gix::Repository, id: ObjectId, len: usize) -> Result<String> {
+    Ok(format!(
+        "{} {}",
+        id.to_hex_with_len(len),
+        for_commit(repo, id)?.to_reverse_hex_with_len(len)
+    ))
+}
+
+pub(crate) fn display_short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+    let hash = id
+        .attach(repo)
+        .shorten()
+        .context("could not shorten commit ID")?
+        .to_string();
+    Ok(format!(
+        "{hash} {}",
+        for_commit(repo, id)?.to_reverse_hex_with_len(hash.len())
+    ))
+}
+
 pub(crate) fn abbreviations(
     repo: &gix::Repository,
     ids: impl IntoIterator<Item = ObjectId>,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 485afa8f425..9d1afec1d1f 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -7,7 +7,7 @@ use std::{
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use gix::prelude::{ObjectIdExt, ReferenceExt};
+use gix::prelude::ReferenceExt;
 use ratatui::text::Line;
 
 mod new;
@@ -148,6 +148,7 @@ impl Platform {
             Command::RefTree(_) | Command::Show(_) => unreachable!("display commands return before logging"),
             Command::Amend(args) => {
                 let graph = crate::edit::loaded_view_graph(&repository)?;
+                let output_repository = repository.clone();
                 let amended = if args.index {
                     crate::edit::head::amend_index_reporting(repository, &graph)?
                 } else {
@@ -155,14 +156,9 @@ impl Platform {
                 };
                 match amended {
                     Some(outcome) => {
-                        println!(
-                            "{}",
-                            outcome
-                                .selected
-                                .context("amending did not produce a selection")?
-                                .to_hex_with_len(7)
-                        );
-                        print_ref_rewrites(&outcome.ref_rewrites);
+                        let selected = outcome.selected.context("amending did not produce a selection")?;
+                        println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
+                        print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
                     }
                     None => println!("nothing to amend"),
                 }
@@ -180,10 +176,8 @@ impl Platform {
                     .head_id()
                     .context("stashing changes requires a born HEAD")?
                     .detach();
-                println!(
-                    "{}",
-                    crate::edit::stash::save_manual(repository.git_dir(), repository.is_bare(), id)?
-                );
+                let notice = crate::edit::stash::save_manual(repository.git_dir(), repository.is_bare(), id)?;
+                println!("{}", notice_with_change_id(&repository, &notice, id)?);
             }
             Command::Pin(args) => pin(&repository, args)?,
             Command::Travel(args) => return travel::run(repository, args),
@@ -462,10 +456,7 @@ fn display_pin(repository: &gix::Repository, pin: &crate::history::Pin) -> Resul
     Ok(format!(
         "{} {}",
         crate::edit::time_travel::pin_label(pin),
-        pin.id
-            .attach(repository)
-            .shorten()
-            .context("could not shorten pinned commit ID")?
+        crate::change_id::display_short(repository, pin.id)?
     ))
 }
 
@@ -475,16 +466,12 @@ fn edit_head(
     kind: crate::edit::head::Kind,
     verb: &str,
 ) -> Result<()> {
+    let output_repository = repository.clone();
     match crate::edit::head::perform_reporting(repository, graph, kind)? {
         Some(outcome) => {
-            println!(
-                "{}",
-                outcome
-                    .selected
-                    .context("editing HEAD did not produce a selection")?
-                    .to_hex_with_len(7)
-            );
-            print_ref_rewrites(&outcome.ref_rewrites);
+            let selected = outcome.selected.context("editing HEAD did not produce a selection")?;
+            println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
+            print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
         }
         None => println!("nothing to {verb}"),
     }
@@ -508,40 +495,46 @@ fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph, args
         .context("could not reopen repository after editing split")?;
     repository.object_cache_size(None);
     let outcome = crate::edit::split::apply_reporting(repository, graph, prepared, &edited)?;
-    println!(
-        "{}",
-        outcome
-            .selected
-            .context("splitting did not produce a selection")?
-            .to_hex_with_len(7)
-    );
-    print_ref_rewrites(&outcome.ref_rewrites);
+    let output_repository =
+        crate::open_repository(&repository_path, bare, false).context("could not reopen repository after splitting")?;
+    let selected = outcome.selected.context("splitting did not produce a selection")?;
+    println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
+    print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
     Ok(())
 }
 
-fn print_ref_rewrites(rewrites: &[crate::edit::rebase::RefRewrite]) {
-    for line in ref_rewrite_lines(rewrites) {
+fn print_ref_rewrites(repository: &gix::Repository, rewrites: &[crate::edit::rebase::RefRewrite]) -> Result<()> {
+    for line in ref_rewrite_lines(repository, rewrites)? {
         println!("{line}");
     }
+    Ok(())
 }
 
-fn ref_rewrite_lines(rewrites: &[crate::edit::rebase::RefRewrite]) -> Vec<String> {
+fn ref_rewrite_lines(
+    repository: &gix::Repository,
+    rewrites: &[crate::edit::rebase::RefRewrite],
+) -> Result<Vec<String>> {
     let mut rewrites = rewrites.to_vec();
     rewrites.sort_by(|a, b| a.name.cmp(&b.name));
     rewrites.dedup();
     rewrites
         .into_iter()
         .map(|rewrite| {
-            format!(
+            Ok(format!(
                 "{}: {} -> {}",
                 rewrite.name,
-                rewrite.old.to_hex_with_len(7),
-                rewrite.new.to_hex_with_len(7)
-            )
+                crate::change_id::display(repository, rewrite.old, 7)?,
+                crate::change_id::display(repository, rewrite.new, 7)?
+            ))
         })
         .collect()
 }
 
+fn notice_with_change_id(repository: &gix::Repository, notice: &str, id: gix::ObjectId) -> Result<String> {
+    let hash = id.to_hex_with_len(7).to_string();
+    Ok(notice.replacen(&hash, &crate::change_id::display(repository, id, 7)?, 1))
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command as ProcessCommand};
@@ -551,13 +544,11 @@ mod tests {
     use super::*;
 
     #[test]
-    fn rewritten_ref_lines_are_sorted_and_show_the_commit_mapping() {
-        let old: gix::ObjectId = "1111111111111111111111111111111111111111"
-            .parse()
-            .expect("valid object ID");
-        let new: gix::ObjectId = "2222222222222222222222222222222222222222"
-            .parse()
-            .expect("valid object ID");
+    fn rewritten_ref_lines_are_sorted_and_show_the_commit_mapping() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let old = repository.rev_parse_single("main~1")?.detach();
+        let new = repository.rev_parse_single("main")?.detach();
         let branch = crate::edit::rebase::RefRewrite {
             name: "refs/heads/z".try_into().expect("valid ref name"),
             old,
@@ -569,11 +560,44 @@ mod tests {
             new,
         };
         assert_eq!(
-            ref_rewrite_lines(&[branch.clone(), first, branch]),
-            ["refs/heads/a: 1111111 -> 2222222", "refs/heads/z: 1111111 -> 2222222"],
+            ref_rewrite_lines(&repository, &[branch.clone(), first, branch])?,
+            [
+                format!(
+                    "refs/heads/a: {} -> {}",
+                    crate::change_id::display(&repository, old, 7)?,
+                    crate::change_id::display(&repository, new, 7)?
+                ),
+                format!(
+                    "refs/heads/z: {} -> {}",
+                    crate::change_id::display(&repository, old, 7)?,
+                    crate::change_id::display(&repository, new, 7)?
+                )
+            ],
             "ref mappings are stable and duplicate-free"
         );
-        assert!(ref_rewrite_lines(&[]).is_empty(), "unchanged refs add no output");
+        assert!(
+            ref_rewrite_lines(&repository, &[])?.is_empty(),
+            "unchanged refs add no output"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn commit_notices_pair_their_hash_with_the_change_id() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let id = repository.head_id()?.detach();
+        let notice = format!("stashed changes at {}; retained warning", id.to_hex_with_len(7));
+
+        assert_eq!(
+            notice_with_change_id(&repository, &notice, id)?,
+            format!(
+                "stashed changes at {}; retained warning",
+                crate::change_id::display(&repository, id, 7)?
+            ),
+            "the change ID stays adjacent to the hash without disturbing later text"
+        );
+        Ok(())
     }
 
     #[test]
@@ -955,12 +979,12 @@ mod tests {
         assert_eq!(repeated[0].name, pins[0].name, "an existing symbolic pin is reused");
         assert_eq!(crate::history::all_pins(&repository)?.len(), 4);
         let display = display_pin(&repository, &pins[0])?;
-        let (label, short_id) = display.split_once(' ').context("pin output has a label and ID")?;
+        let (label, ids) = display.split_once(' ').context("pin output has a label and IDs")?;
         assert!(label.starts_with("pin:"), "output names the pin");
         assert_eq!(
-            short_id,
-            main.attach(&repository).shorten()?.to_string(),
-            "output uses the repository's abbreviated ID"
+            ids,
+            crate::change_id::display_short(&repository, main)?,
+            "output uses matching repository-abbreviated commit and change IDs"
         );
         repository.reference(
             "refs/heads/main",
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index 54d54cf262b..3d6f21ed96d 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -72,14 +72,13 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         repository.object_cache_size(None);
         crate::edit::create::apply_reporting(repository, &graph, prepared, &edited)?
     };
-    println!(
-        "{}",
-        outcome
-            .selected
-            .context("creating a commit did not produce a selection")?
-            .to_hex_with_len(7)
-    );
-    super::print_ref_rewrites(&outcome.ref_rewrites);
+    let repository = crate::open_repository(&repository_path, bare, false)
+        .context("could not reopen repository after creating commit")?;
+    let selected = outcome
+        .selected
+        .context("creating a commit did not produce a selection")?;
+    println!("{}", crate::change_id::display(&repository, selected, 7)?);
+    super::print_ref_rewrites(&repository, &outcome.ref_rewrites)?;
     Ok(())
 }
 
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index daaa223887a..6dde6a81109 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -214,7 +214,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
             })
         })
         .collect::<Result<Vec<_>>>()?;
-    todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind)
+    todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind, true)
 }
 
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
@@ -263,13 +263,14 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
     match rebase::perform_plan(&repo, &graph, parsed.plan)? {
         rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
-            if outcome.selected.is_some() {
+            if let Some(selected) = outcome.selected {
                 let notice = edit::time_travel::checkout_plan(&repository_path, bare, &outcome, &revisions, false)?;
-                println!("{}", notice.unwrap_or_else(|| "rebased history".into()));
+                let notice = notice.unwrap_or_else(|| "rebased history".into());
+                println!("{}", super::notice_with_change_id(&repo, &notice, selected)?);
             } else {
                 println!("rebased history");
             }
-            super::print_ref_rewrites(&outcome.ref_rewrites);
+            super::print_ref_rewrites(&repo, &outcome.ref_rewrites)?;
             Ok(())
         }
         rebase::PlanPerform::Conflict(mut conflict) => {
@@ -287,7 +288,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
             conflict.persist_objects()?;
             let plan = conflict.continuation_plan();
             let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
-            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips)?.document;
+            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips, true)?.document;
             let revisions = mapped_revisions(&tips, |id| conflict.map(id));
             if destination == Path::new("-") {
                 let mut stdout = std::io::stdout().lock();
@@ -318,7 +319,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
                     return Err(err);
                 }
             };
-            super::print_ref_rewrites(&ref_rewrites);
+            super::print_ref_rewrites(&repo, &ref_rewrites)?;
             eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
             anyhow::bail!("rebase stopped at a materialized conflict")
         }
@@ -487,7 +488,10 @@ mod tests {
             "moving to the updated base makes an unchanged todo actionable"
         );
         assert!(
-            document.contains(&format!("{} (updated-base)", updated.to_hex_with_len(7))),
+            document.contains(&format!(
+                "{} (updated-base)",
+                crate::change_id::display_short(&repo, updated)?
+            )),
             "the TUI-selected hidden tip is labelled as the updated base: {document}"
         );
 
@@ -560,6 +564,7 @@ mod tests {
             ],
             &[after],
             todo::OntoKind::Onto,
+            true,
         )?;
         let generated = std::str::from_utf8(&prepared.document)?;
         let state = &generated[generated
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 6682aff38b5..362ed458abf 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -59,13 +59,17 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("author is not valid UTF-8")?;
 
     if let Some(message) = explicit_message(&args.edit, std::io::stdin())? {
-        return finish(crate::edit::reword::apply_message_reporting(
-            repository,
-            &graph,
-            target,
-            &message,
-            author.map(AsRef::as_ref),
-        )?);
+        let output_repository = repository.clone();
+        return finish(
+            &output_repository,
+            crate::edit::reword::apply_message_reporting(
+                repository,
+                &graph,
+                target,
+                &message,
+                author.map(AsRef::as_ref),
+            )?,
+        );
     }
 
     let repository_path = repository.git_dir().to_owned();
@@ -89,7 +93,12 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    finish_editor(crate::edit::reword::apply(repository, &graph, target, &edited)?, target)
+    let output_repository = repository.clone();
+    finish_editor(
+        &output_repository,
+        crate::edit::reword::apply(repository, &graph, target, &edited)?,
+        target,
+    )
 }
 
 pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
@@ -122,22 +131,26 @@ pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Resu
     }
 }
 
-fn finish(outcome: crate::edit::reword::Outcome) -> Result<()> {
+fn finish(repository: &gix::Repository, outcome: crate::edit::reword::Outcome) -> Result<()> {
     match outcome.commit {
-        Some(id) => println!("{}", id.to_hex_with_len(7)),
+        Some(id) => println!("{}", crate::change_id::display(repository, id, 7)?),
         None => println!("no reword performed: the edited commit was unchanged"),
     }
-    super::print_ref_rewrites(&outcome.ref_rewrites);
+    super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
     Ok(())
 }
 
-fn finish_editor(outcome: crate::edit::reword::Outcome, original: gix::ObjectId) -> Result<()> {
+fn finish_editor(
+    repository: &gix::Repository,
+    outcome: crate::edit::reword::Outcome,
+    original: gix::ObjectId,
+) -> Result<()> {
     match (outcome.commit, outcome.enrichment) {
-        (Some(id), _) => println!("{}", id.to_hex_with_len(7)),
-        (None, Some(_)) => println!("{}", original.to_hex_with_len(7)),
+        (Some(id), _) => println!("{}", crate::change_id::display(repository, id, 7)?),
+        (None, Some(_)) => println!("{}", crate::change_id::display(repository, original, 7)?),
         (None, None) => println!("no reword performed: the edited commit was unchanged"),
     }
-    super::print_ref_rewrites(&outcome.ref_rewrites);
+    super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
     Ok(())
 }
 
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 44d41a290fd..1d98dd47ef2 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -22,7 +22,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let detached = head.is_detached();
     drop(head);
     if selected == head_id {
-        println!("already at {}", selected.to_hex_with_len(7));
+        println!("already at {}", crate::change_id::display(&repository, selected, 7)?);
         return Ok(());
     }
 
@@ -51,16 +51,28 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let bare = repository.is_bare();
     drop(repository);
     match crate::edit::time_travel::perform(&repository_path, bare, selected, &graph, &reviews, &[], false)? {
-        crate::edit::time_travel::Perform::Complete { notice, ref_rewrites } => {
+        crate::edit::time_travel::Perform::Complete {
+            notice,
+            selected,
+            ref_rewrites,
+        } => {
+            let repository = crate::open_repository(&repository_path, bare, false)
+                .context("could not reopen repository after time-travel")?;
             println!(
                 "{}",
-                notice.unwrap_or_else(|| format!("already at {}", selected.to_hex_with_len(7)))
+                super::notice_with_change_id(
+                    &repository,
+                    &notice.unwrap_or_else(|| format!("already at {}", selected.to_hex_with_len(7))),
+                    selected,
+                )?
             );
-            super::print_ref_rewrites(&ref_rewrites);
+            super::print_ref_rewrites(&repository, &ref_rewrites)?;
         }
         crate::edit::time_travel::Perform::Conflict(conflict) if args.materialize_conflicts => {
             let (notice, _, ref_rewrites) = conflict.accept()?;
-            super::print_ref_rewrites(&ref_rewrites);
+            let repository = crate::open_repository(&repository_path, bare, false)
+                .context("could not reopen repository after materializing time-travel")?;
+            super::print_ref_rewrites(&repository, &ref_rewrites)?;
             anyhow::bail!("{notice}");
         }
         crate::edit::time_travel::Perform::Conflict(_) => {
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index fd634dc3718..6fabcf7391c 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -24,6 +24,7 @@ use super::stash::SavedStash;
 pub(crate) enum Perform {
     Complete {
         notice: Option<String>,
+        selected: ObjectId,
         ref_rewrites: Vec<super::rebase::RefRewrite>,
     },
     Conflict(Conflict),
@@ -477,7 +478,11 @@ pub(crate) fn perform_reporting_rebased(
             super::stash::apply(repository_path, bare, &workdir, stash)?,
         );
     }
-    Ok(Perform::Complete { notice, ref_rewrites })
+    Ok(Perform::Complete {
+        notice,
+        selected,
+        ref_rewrites,
+    })
 }
 
 #[derive(Clone, Debug, Eq, PartialEq)]
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 8940626a1b4..d1f069f2eaf 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -84,6 +84,7 @@ pub(crate) fn prepare(
     commits: &[Commit],
     resolved_tips: &[ObjectId],
     onto_kind: OntoKind,
+    show_change_ids: bool,
 ) -> Result<Prepared> {
     repo.find_commit(base)
         .context("could not find the selected rebase base")?;
@@ -160,11 +161,14 @@ pub(crate) fn prepare(
     ref_points.dedup();
     let expected_refs = rebase::capture_refs(repo, &ref_points, &tips)?;
 
-    let source = short(repo, base)?;
+    let source = short(repo, base, show_change_ids)?;
     let title = if base == onto {
         format!("# Rebase from `{source}`")
     } else {
-        format!("# Rebase from `{source}` onto `{}`", short(repo, onto)?)
+        format!(
+            "# Rebase from `{source}` onto `{}`",
+            short(repo, onto, show_change_ids)?
+        )
     };
     let state = State {
         base,
@@ -206,6 +210,7 @@ pub(crate) fn prepare(
             repo,
             section.parent,
             (section.parent == onto).then_some((anchor_kind, anchor_title.as_str())),
+            show_change_ids,
         )?;
         if !scope_set.contains(&section.parent) {
             write_refs_at(&mut body, &state.expected_refs, section.parent)?;
@@ -218,12 +223,25 @@ pub(crate) fn prepare(
                 "pick"
             };
             let states = commit_states(repo, *id)?;
-            body.extend_from_slice(format!("`{verb} {}` {states}{}\n", short(repo, *id)?, &commit.info).as_bytes());
+            body.extend_from_slice(
+                format!(
+                    "`{verb} {}` {states}{}\n",
+                    short(repo, *id, show_change_ids)?,
+                    &commit.info
+                )
+                .as_bytes(),
+            );
             write_refs_at(&mut body, &state.expected_refs, *id)?;
         }
     }
     if sections.is_empty() {
-        write_fork_heading(&mut body, repo, onto, Some((anchor_kind, anchor_title.as_str())))?;
+        write_fork_heading(
+            &mut body,
+            repo,
+            onto,
+            Some((anchor_kind, anchor_title.as_str())),
+            show_change_ids,
+        )?;
         write_refs_at(&mut body, &state.expected_refs, onto)?;
     }
     write_bottom_up(&mut document, &body)?;
@@ -239,6 +257,7 @@ pub(crate) fn prepare_continuation(
     repo: &gix::Repository,
     plan: &rebase::Plan,
     tips: Vec<ObjectId>,
+    show_change_ids: bool,
 ) -> Result<Prepared> {
     let resolved = plan.steps.iter().find_map(|step| match step.commit {
         rebase::PlanCommit::Resolved(id) => Some(id),
@@ -283,6 +302,7 @@ pub(crate) fn prepare_continuation(
                 repo,
                 parent,
                 (parent == plan.base).then_some(("base", base_title.as_str())),
+                show_change_ids,
             )?;
             if matches!(step.parent, rebase::PlanParent::Existing(_)) {
                 write_plan_refs_at(&mut body, &plan.expected_refs, step.parent)?;
@@ -300,9 +320,17 @@ pub(crate) fn prepare_continuation(
         match step.commit {
             rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => {
                 let value = if matches!(step.commit, rebase::PlanCommit::Resolved(_)) {
-                    ObjectId::null(id.kind()).to_string()
+                    let hash = ObjectId::null(id.kind()).to_string();
+                    if show_change_ids {
+                        format!(
+                            "{hash} {}",
+                            crate::change_id::for_commit(repo, id)?.to_reverse_hex_with_len(hash.len())
+                        )
+                    } else {
+                        hash
+                    }
                 } else {
-                    short(repo, id)?
+                    short(repo, id, show_change_ids)?
                 };
                 let title = anchor_title(repo, id)?;
                 body.extend_from_slice(
@@ -318,7 +346,7 @@ pub(crate) fn prepare_continuation(
             body.extend_from_slice(
                 format!(
                     "`squash {}` {}{}\n",
-                    short(repo, *id)?,
+                    short(repo, *id, show_change_ids)?,
                     commit_states(repo, *id)?,
                     title
                 )
@@ -528,8 +556,9 @@ fn write_fork_heading(
     repo: &gix::Repository,
     id: ObjectId,
     annotation: Option<(&str, &str)>,
+    show_change_ids: bool,
 ) -> Result<()> {
-    out.extend_from_slice(format!("fork {}", short(repo, id)?).as_bytes());
+    out.extend_from_slice(format!("fork {}", short(repo, id, show_change_ids)?).as_bytes());
     if let Some((kind, title)) = annotation {
         out.extend_from_slice(format!(" ({kind}) {title}").as_bytes());
     }
@@ -580,12 +609,16 @@ fn walk(id: ObjectId, children: &HashMap<ObjectId, Vec<ObjectId>>, section: &mut
     }
 }
 
-fn short(repo: &gix::Repository, id: ObjectId) -> Result<String> {
-    Ok(id
-        .attach(repo)
-        .shorten()
-        .context("could not shorten a rebase todo ID")?
-        .to_string())
+fn short(repo: &gix::Repository, id: ObjectId, show_change_id: bool) -> Result<String> {
+    if show_change_id {
+        crate::change_id::display_short(repo, id).context("could not format a rebase todo ID")
+    } else {
+        Ok(id
+            .attach(repo)
+            .shorten()
+            .context("could not shorten a rebase todo ID")?
+            .to_string())
+    }
 }
 
 fn parse_state(repo: &gix::Repository, input: &str) -> Result<Option<State>> {
@@ -1185,7 +1218,7 @@ mod tests {
         commits: &[Commit],
         _head: Option<ObjectId>,
     ) -> Result<Prepared> {
-        prepare(repo, base, onto, commits, &[], OntoKind::UpdatedBase)
+        prepare(repo, base, onto, commits, &[], OntoKind::UpdatedBase, true)
     }
 
     fn parse_plan(repo: &gix::Repository, document: &[u8]) -> Result<rebase::Plan> {
@@ -1220,8 +1253,14 @@ mod tests {
             "the first line explains that saving unchanged is a no-op"
         );
         assert!(document.contains(STATE_START), "the todo carries its transaction state");
-        assert!(document.contains(&format!("# Rebase from `{}`", base.to_hex_with_len(7))));
-        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!(
+            "# Rebase from `{}`",
+            crate::change_id::display_short(&repo, base)?
+        )));
+        assert!(document.contains(&format!(
+            "fork {} (base) base",
+            crate::change_id::display_short(&repo, base)?
+        )));
         let middle = document.find("`pick ").expect("the oldest pick is shown");
         let tip = document.find("`@pick ").expect("HEAD is marked");
         let base = document.find("fork ").expect("the base separator is shown");
@@ -1457,9 +1496,12 @@ mod tests {
 
         let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
         let document = String::from_utf8(prepared.document.clone())?;
-        assert!(document.contains(&format!("fork {} (base) base", base.to_hex_with_len(7))));
+        assert!(document.contains(&format!(
+            "fork {} (base) base",
+            crate::change_id::display_short(&repo, base)?
+        )));
         assert!(
-            document.contains(&format!("fork {} ", middle.to_hex_with_len(7))),
+            document.contains(&format!("fork {} ", crate::change_id::display_short(&repo, middle)?)),
             "a fork within the editable tree has no external-anchor annotation"
         );
         let plan = parse_plan(&repo, document.as_bytes())?;
@@ -1493,15 +1535,15 @@ mod tests {
         assert!(
             document.contains(&format!(
                 "# Rebase from `{}` onto `{}`",
-                base.to_hex_with_len(7),
-                onto.to_hex_with_len(7)
+                crate::change_id::display_short(&repo, base)?,
+                crate::change_id::display_short(&repo, onto)?
             )),
             "the update target is explicit in the document title"
         );
         assert!(
             document.contains(&format!(
                 "fork {} (updated-base) [A] [N] updated * _ [hidden] <base> `raw` \\ base",
-                onto.to_hex_with_len(7)
+                crate::change_id::display_short(&repo, onto)?
             )),
             "the unfamiliar fork target carries its raw UI title"
         );
@@ -1637,6 +1679,7 @@ mod tests {
                 }],
             },
             vec![middle],
+            true,
         )?;
         assert!(
             prepared
@@ -1652,7 +1695,7 @@ mod tests {
         );
         assert!(document.contains(&"0".repeat(40)), "the conflict uses the full null ID");
         assert!(
-            document.contains(&format!("`squash {}`", tip.to_hex_with_len(7))),
+            document.contains(&format!("`squash {}`", crate::change_id::display_short(&repo, tip)?)),
             "unapplied squash sources remain editable"
         );
         let plan = parse_plan(&repo, &prepared.document)?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index e46b102df4a..398719458c9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3887,6 +3887,7 @@ fn rebase_history(
             &commits,
             &[],
             edit::todo::OntoKind::UpdatedBase,
+            false,
         )?;
         (prepared, editor)
     };
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 525ed14533a..0be3eedd967 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1512,13 +1512,17 @@ pub(crate) fn render_full(
     )?;
     let graph = graph.ok_or_else(|| anyhow::anyhow!("history traversal did not produce a graph"))?;
     let decorations = decorations.unwrap_or_default();
-    Ok(render_overview(
-        &Overview::new(&graph, &refs, &decorations, show_tags),
-        unicode,
-    ))
+    let overview = Overview::new(&graph, &refs, &decorations, show_tags);
+    let labels = overview
+        .nodes
+        .iter()
+        .filter(|node| node.raw_tip && node.decorations.is_empty())
+        .map(|node| Ok((node.id, crate::change_id::display(repository, node.id, 7)?)))
+        .collect::<anyhow::Result<HashMap<_, _>>>()?;
+    Ok(render_overview(&overview, unicode, &labels))
 }
 
-fn render_overview(overview: &Overview, unicode: bool) -> String {
+fn render_overview(overview: &Overview, unicode: bool, commit_labels: &HashMap<ObjectId, String>) -> String {
     if overview.nodes.is_empty() {
         return String::new();
     }
@@ -1548,7 +1552,11 @@ fn render_overview(overview: &Overview, unicode: bool) -> String {
         out.push_str(&lane);
         out.extend(std::iter::repeat_n(' ', placed.rail_width.saturating_sub(width)));
         if let Some(node) = node {
-            let label = rail_label(&overview.nodes[node], None);
+            let node = &overview.nodes[node];
+            let label = commit_labels
+                .get(&node.id)
+                .cloned()
+                .unwrap_or_else(|| rail_label(node, None));
             if unicode {
                 out.push_str(&label);
             } else {
@@ -2046,8 +2054,8 @@ mod tests {
             !overview.nodes.iter().any(|node| node.id == id(5)),
             "ordinary pin-only tips are absent"
         );
-        let unicode = render_overview(overview, true);
-        let ascii = render_overview(overview, false);
+        let unicode = render_overview(overview, true, &HashMap::new());
+        let ascii = render_overview(overview, false, &HashMap::new());
         assert_eq!(unicode.matches('📌').count(), 1, "detached HEAD has one marker");
         assert!(
             unicode.contains("★main"),
@@ -2417,7 +2425,7 @@ mod tests {
     fn full_rendering_is_unstyled_ascii() {
         let (graph, refs, decorations) = fixture();
         let overview = Overview::new(&graph, &refs, &decorations, true);
-        let rendered = render_overview(&overview, false);
+        let rendered = render_overview(&overview, false, &HashMap::new());
 
         assert!(rendered.contains("main"), "HEAD is rendered without selection state");
         assert!(rendered.contains("topic"), "ordinary nodes retain their label");
@@ -2427,12 +2435,28 @@ mod tests {
         assert!(!rendered.contains('\u{1b}'), "plain output has no terminal styles");
     }
 
+    #[test]
+    fn full_rendering_pairs_raw_commit_tips_with_change_ids() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let mut commit = repo.head_commit()?.decode()?.into_owned()?;
+        commit.message = "unreferenced raw tip".into();
+        let id = repo.write_object(&commit)?.detach();
+        let rendered = render_full(&repo, &[id.to_string().into()], &[], true, false)?;
+
+        assert!(
+            rendered.contains(&crate::change_id::display(&repo, id, 7)?),
+            "a displayed raw hash is immediately followed by its change ID: {rendered:?}"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rail_layout_uses_rounded_unicode_connections_and_ascii_fallbacks() {
         let (graph, refs, decorations) = fixture();
         let overview = Overview::new(&graph, &refs, &decorations, true);
-        let unicode = render_overview(&overview, true);
-        let ascii = render_overview(&overview, false);
+        let unicode = render_overview(&overview, true, &HashMap::new());
+        let ascii = render_overview(&overview, false, &HashMap::new());
 
         assert!(
             unicode.contains("│ ● topic"),

From a4fd6e4d01aff23a404088a2b1bbcf297ae7917f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 13:17:58 +0200
Subject: [PATCH 215/282] fix: distinguish lazy-rebased commits with grey
 markers

Pending lazy-rebase commits previously used bright cyan, which could be confused with the blue unsigned state. Render them grey and document the palette distinction.
---
 gix-tix/spec.md   | 2 +-
 gix-tix/src/ui.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 351a2106c53..1bcc9a567b5 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -714,7 +714,7 @@ space first; changes blocks adapt within the remaining history width.
   has its final tree and unchanged parent, so an empty signature field alone keeps
   a formerly signed commit pending. Reparented descendants additionally carry
   `tix-rebase-parent`, retaining the original parent needed for later replay. Both
-  pending forms use a bright-cyan commit marker.
+  pending forms use a grey commit marker so they remain distinct from unsigned blue.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
 - Time travel toward a pending destination cherry-picks and signs only the pending
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 48512ccb7b2..c665b8c5b15 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -2430,7 +2430,7 @@ fn signature_color(signature: SignatureState) -> Color {
         SignatureState::Unverified | SignatureState::Verifying => Color::Rgb(255, 165, 0),
         SignatureState::Verified => Color::Green,
         SignatureState::Failed => Color::LightRed,
-        SignatureState::PendingRebase => Color::LightCyan,
+        SignatureState::PendingRebase => Color::Gray,
     }
 }
 
@@ -4001,7 +4001,7 @@ mod tests {
             (SignatureState::Unverified, Color::Rgb(255, 165, 0)),
             (SignatureState::Verified, Color::Green),
             (SignatureState::Failed, Color::LightRed),
-            (SignatureState::PendingRebase, Color::LightCyan),
+            (SignatureState::PendingRebase, Color::Gray),
         ];
         let mut terminal = Terminal::new(TestBackend::new(4, states.len() as u16))?;
         terminal.draw(|frame| {

From 08f2b3359c49a15160ebf71e512a7b57f93c1da5 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 14:57:38 +0200
Subject: [PATCH 216/282] feat: toggle pins from the TUI edit menu

Make e i create a direct current-worktree pin for an unpinned selection and remove every ordinary pin when the selection is already pinned. Preserve the special HEAD pin, retain selection across refresh, and report the operation through the existing TUI notices.

The edit menu now always exposes the context-sensitive pin or unpin action, making pinned comparison histories available without leaving the TUI.
---
 gix-tix/spec.md                 |  6 ++--
 gix-tix/src/app.rs              | 12 ++++----
 gix-tix/src/edit/time_travel.rs | 51 +++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs              | 18 +++++++-----
 gix-tix/src/ui.rs               | 19 ++++++------
 5 files changed, 80 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1bcc9a567b5..f94e473ad57 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -440,8 +440,10 @@ The Enter key is written as `<enter>` throughout.
 - The HEAD pin instead marks its target branch as `★branch` in the local-branch
   style. It has no `📌`, is never selected as a return destination, and does not
   offer `unpin`; its branch keeps normal tracking-relation behavior.
-- The edit menu offers `unpin` on a pinned row. It atomically removes every pin
-  for that commit in the current worktree and retains that row's selection.
+- The edit menu offers `pin` on an unpinned row and `unpin` on a pinned row,
+  both on `e i`. Pin creates or reuses a direct current-worktree pin for the
+  selected commit. Unpin atomically removes every non-HEAD pin for that commit;
+  both operations retain that row's selection.
 - `tix pin <REVSPEC>...` resolves every argument before writing and deduplicates
   pin targets in argument order. A direct reference name creates or reuses a
   symbolic current-worktree pin so it follows later reference updates; derived
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index d68e2a50654..7c3d3ffd56d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -377,7 +377,7 @@ pub(crate) enum Action {
     RebaseUpdate,
     Review,
     TimeTravel,
-    Unpin,
+    TogglePin,
     VerifySignatures,
     Cancel,
     Copy,
@@ -422,7 +422,7 @@ pub(crate) enum Effect {
         return_to: Option<ObjectId>,
     },
     TimeTravel(ObjectId),
-    Unpin(ObjectId),
+    TogglePin(ObjectId),
     ToggleTodo(ObjectId),
     EditNote(ObjectId),
     EditGitNote(ObjectId),
@@ -1034,7 +1034,7 @@ impl App {
                 | Action::RebaseUpdate
                 | Action::Review
                 | Action::TimeTravel
-                | Action::Unpin
+                | Action::TogglePin
         ) {
             self.edit_expanded = false;
         }
@@ -1371,9 +1371,9 @@ impl App {
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
                 )];
             }
-            Action::Unpin => {
+            Action::TogglePin => {
                 if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
-                    return vec![Effect::Unpin(id)];
+                    return vec![Effect::TogglePin(id)];
                 }
             }
             Action::ToggleTodo if self.can_reword() => {
@@ -3302,7 +3302,7 @@ mod tests {
         assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
         app.set_worktree_changes_available(false);
         assert!(app.update(Action::TimeTravel).is_empty());
-        assert_eq!(app.update(Action::Unpin), vec![Effect::Unpin(id(1))]);
+        assert_eq!(app.update(Action::TogglePin), vec![Effect::TogglePin(id(1))]);
     }
 
     #[test]
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 6fabcf7391c..7763338409d 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -747,6 +747,27 @@ pub(crate) fn remove_pins(repository_path: &Path, bare: bool, selected: ObjectId
     Ok(pins.len())
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum PinToggle {
+    Created,
+    Removed(usize),
+}
+
+pub(crate) fn toggle_pin(repository_path: &Path, bare: bool, selected: ObjectId) -> Result<PinToggle> {
+    let repository =
+        open_repository(repository_path, bare, false).context("could not open repository to toggle a pin")?;
+    let pins: Vec<_> = history::all_pins(&repository)?
+        .into_iter()
+        .filter(|pin| !pin.is_head() && pin.id == selected)
+        .collect();
+    if pins.is_empty() {
+        create_or_reuse_pin(&repository, Target::Object(selected), selected, "tix TUI pin")?;
+        return Ok(PinToggle::Created);
+    }
+    drop(repository);
+    remove_pins(repository_path, bare, selected).map(PinToggle::Removed)
+}
+
 fn delete_pin_edit(pin: &history::Pin) -> RefEdit {
     RefEdit {
         change: Change::Delete {
@@ -1371,6 +1392,36 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn toggles_one_direct_pin_without_touching_the_head_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let selected = repository.rev_parse_single("main")?.detach();
+        let main = repository.find_reference("refs/heads/main")?.name().to_owned();
+        create_or_update_head_pin(&repository, &main, selected)?;
+        drop(repository);
+
+        assert_eq!(toggle_pin(&repository_path, false, selected)?, PinToggle::Created);
+        let repository = crate::test_repository::open(fixture.path())?;
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(
+            pins.iter().filter(|pin| !pin.is_head() && pin.id == selected).count(),
+            1,
+            "pin creates one direct pin for the selected commit"
+        );
+        drop(repository);
+
+        assert_eq!(toggle_pin(&repository_path, false, selected)?, PinToggle::Removed(1));
+        let pins = history::all_pins(&crate::test_repository::open(fixture.path())?)?;
+        assert!(pins.iter().any(history::Pin::is_head), "unpin preserves the HEAD pin");
+        assert!(
+            pins.iter().all(|pin| pin.is_head() || pin.id != selected),
+            "unpin removes every ordinary pin at the selected commit"
+        );
+        Ok(())
+    }
+
     #[test]
     fn explicitly_created_pins_have_independent_lifetimes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 398719458c9..bfae3567433 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2635,17 +2635,21 @@ fn event_loop(
                         }
                     }
                 }
-                Effect::Unpin(id) => {
+                Effect::TogglePin(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    match edit::time_travel::remove_pins(&repository_path, repository_is_bare, id) {
-                        Ok(0) => app.leave_attention("no pins removed"),
-                        Ok(count) => {
+                    match edit::time_travel::toggle_pin(&repository_path, repository_is_bare, id) {
+                        Ok(edit::time_travel::PinToggle::Removed(count)) => {
                             app.leave_success(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
                             app.select_commit_after_refresh(id);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_error(format!("unpin: {err:#}")),
+                        Ok(edit::time_travel::PinToggle::Created) => {
+                            app.leave_success("pinned selected commit");
+                            app.select_commit_after_refresh(id);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_error(format!("toggle pin: {err:#}")),
                     }
                 }
                 Effect::ToggleTodo(id) => {
@@ -5043,7 +5047,7 @@ fn action_with_shortcut_groups(
         KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
         KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
-        KeyCode::Char('i') if edit_expanded => Some(Action::Unpin),
+        KeyCode::Char('i') if edit_expanded => Some(Action::TogglePin),
         KeyCode::Char('v') if edit_expanded => Some(Action::Review),
         KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
@@ -6255,7 +6259,7 @@ mod tests {
             ('s', Action::Spill),
             ('p', Action::Split),
             ('d', Action::Forget),
-            ('i', Action::Unpin),
+            ('i', Action::TogglePin),
         ] {
             assert_eq!(
                 action_with_shortcut_groups(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index c665b8c5b15..c02461a4509 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1014,17 +1014,14 @@ pub(crate) fn draw_with_worktree(
                 options.push(("d forget", 'd'));
             }
             if app.changes_focus.is_none()
-                && app
-                    .selected
-                    .and_then(|index| app.rows.get(index))
-                    .and_then(|row| decorations.get(&row.id))
-                    .is_some_and(|decorations| {
-                        decorations
-                            .iter()
-                            .any(|decoration| decoration.kind == DecorationKind::Pin)
-                    })
+                && let Some(selected) = app.selected.and_then(|index| app.rows.get(index))
             {
-                options.push(("unpin", 'i'));
+                let pinned = decorations.get(&selected.id).is_some_and(|decorations| {
+                    decorations
+                        .iter()
+                        .any(|decoration| decoration.kind == DecorationKind::Pin)
+                });
+                options.push((if pinned { "unpin" } else { "pin" }, 'i'));
             }
             edit_prefix_spans.push(Span::raw(" · "));
             edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
@@ -5960,7 +5957,7 @@ mod tests {
         let mut actions = Terminal::new(TestBackend::new(120, 3))?;
         actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&actions, 2).contains("edit (rebase · rebase-update · fork)"),
+            rendered_line(&actions, 2).contains("edit (rebase · rebase-update · fork · pin)"),
             "the selected hidden base offers independent edits: {:?}",
             rendered_line(&actions, 2)
         );

From 67380a4719238b90c6ebf777ec2e947eb0829ab7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 18:12:25 +0200
Subject: [PATCH 217/282] feat: add attached TUI time travel

Add # beside detached time travel to move the current worktree branch, or the branch remembered by its HEAD pin, to the selected commit while ending with HEAD attached.

Reuse the existing replay animation, conflict, stash, and pin behavior. Preflight worktree changes, update the branch and HEAD atomically, reject branches owned by another worktree, and roll references back if applying the tree transition fails.

# b998fbb705 fix: recognize the current linked worktree during attached travel

fix: recognize the current linked worktree during attached travel

The attached-travel ownership guard compared reopened Git-directory paths, which can differ for the same linked worktree. This made the current branch look checked out elsewhere and rejected # travel.

Use Git worktree IDs to exclude the current linked worktree while retaining strict checks for the main and all other linked worktrees. Cover the complete pinned-HEAD detach and reattach flow in a linked worktree.
---
 gix-tix/spec.md                 |   28 +-
 gix-tix/src/app.rs              |   84 ++-
 gix-tix/src/edit/time_travel.rs | 1157 ++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs              |   82 ++-
 gix-tix/src/ui.rs               |   52 +-
 5 files changed, 1287 insertions(+), 116 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index f94e473ad57..a5295158563 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -376,6 +376,7 @@ without trading responsiveness for metadata that is not visible.
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
 | `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
+| `#` | Time-travel to the selected commit while keeping the current or remembered branch attached. Terminals reporting the base key as `Shift-3` are also accepted. |
 | `x` | Select the next visible commit with the same change ID, wrapping at the end. |
 
 Alignment uses only rows in the current viewport to determine widths and starts
@@ -394,8 +395,9 @@ terminal-theme-independent cue. While active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v` prefix and the `e` prefix when it is addressable. Remaining history-level
-actions end at the information prefix while it is closed. An available direct
-time-travel action follows the edit group, duplicate cycling follows time travel when
+actions end at the information prefix while it is closed. Available direct
+detached and attached time-travel actions follow the edit group beside each other,
+and duplicate cycling follows them when
 the selected commit has duplicates, and copy follows these actions; the reference toggle immediately precedes
 the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
@@ -406,6 +408,24 @@ The Enter key is written as `<enter>` throughout.
 
 - On a completed, focused history in a worktree repository, `@` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
+- On a completed, focused history in a worktree repository, `#` moves the
+  current attached local branch, or the local branch named by a detached
+  `refs/worktree/tix/pins/HEAD`, to the selected commit and checks it out so
+  `HEAD` ends attached. The action is unavailable and does nothing without such
+  a branch. It is also a no-op when `HEAD` is already attached there.
+- Attached travel refuses a remembered branch checked out by another worktree.
+  Its checkout preflights local changes, atomically moves the branch and
+  `HEAD`, and rolls those references back if applying the worktree transition
+  fails. Newly created recovery pins are removed only when the move did not
+  commit or reference rollback succeeded. It otherwise reuses ordinary time
+  travel's pending-rebase animation and conflict acceptance, including
+  review-tree stash transitions.
+- Attached travel uses normal pin reconciliation. Its actual departure and,
+  when starting detached, the remembered branch's old tip are deduplicated as
+  candidate direct pins; the destination and its ancestors are omitted, and
+  provisional pins still reachable from another view tip are removed after
+  success. Both pins may remain when the histories are unrelated. Successful
+  travel consumes an ordinary destination pin and removes the HEAD pin.
 - When tix detaches an attached local branch, it records that branch symbolically
   in the singleton `refs/worktree/tix/pins/HEAD` ref. Git stores this HEAD pin
   privately for the current worktree, and later branch advances move its tip.
@@ -984,8 +1004,8 @@ space first; changes blocks adapt within the remaining history width.
   `e o` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
   and `e d d` confirms forgetting a top commit when each action is available.
-- `@` invokes time travel directly, outside the edit group. Invoking it leaves an
-  already expanded edit group open.
+- `@` and `#` invoke detached and attached time travel directly, outside the edit
+  group. Invoking either leaves an already expanded edit group open.
 - Edit shortcuts keep the group open. Navigation or another recognized command
   closes it, matching the `v` display shortcut group. Plain `r` does not mutate
   the repository, and plain `t` has no action.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7c3d3ffd56d..be12e70a0e6 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -377,6 +377,7 @@ pub(crate) enum Action {
     RebaseUpdate,
     Review,
     TimeTravel,
+    AttachedTimeTravel,
     TogglePin,
     VerifySignatures,
     Cancel,
@@ -421,7 +422,10 @@ pub(crate) enum Effect {
         review: ObjectId,
         return_to: Option<ObjectId>,
     },
-    TimeTravel(ObjectId),
+    TimeTravel {
+        id: ObjectId,
+        mode: crate::edit::time_travel::TravelMode,
+    },
     TogglePin(ObjectId),
     ToggleTodo(ObjectId),
     EditNote(ObjectId),
@@ -523,6 +527,7 @@ pub(crate) struct App {
     pending_initial_selection: Option<ObjectId>,
     selection_after_refresh: Option<ObjectId>,
     worktree_head: Option<ObjectId>,
+    worktree_branch: Option<(ObjectId, bool)>,
     worktree_head_has_descendants: bool,
     worktree_head_unborn: bool,
     pending_rebase_conflict: Option<ObjectId>,
@@ -620,6 +625,7 @@ impl App {
             pending_initial_selection: None,
             selection_after_refresh: None,
             worktree_head: None,
+            worktree_branch: None,
             worktree_head_has_descendants: false,
             worktree_head_unborn: false,
             pending_rebase_conflict: None,
@@ -741,6 +747,10 @@ impl App {
         self.update_worktree_head_descendants();
     }
 
+    pub(crate) fn set_worktree_branch(&mut self, branch: Option<(ObjectId, bool)>) {
+        self.worktree_branch = branch;
+    }
+
     pub(crate) fn set_worktree_head_unborn(&mut self, unborn: bool) {
         self.worktree_head_unborn = unborn;
     }
@@ -1034,6 +1044,7 @@ impl App {
                 | Action::RebaseUpdate
                 | Action::Review
                 | Action::TimeTravel
+                | Action::AttachedTimeTravel
                 | Action::TogglePin
         ) {
             self.edit_expanded = false;
@@ -1367,9 +1378,16 @@ impl App {
                 }
             }
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
-                return vec![Effect::TimeTravel(
-                    self.rows[self.selected.expect("time-travel requires a selection")].id,
-                )];
+                return vec![Effect::TimeTravel {
+                    id: self.rows[self.selected.expect("time-travel requires a selection")].id,
+                    mode: crate::edit::time_travel::TravelMode::Detached,
+                }];
+            }
+            Action::AttachedTimeTravel if self.attached_time_travel_shortcut_visible() => {
+                return vec![Effect::TimeTravel {
+                    id: self.rows[self.selected.expect("attached time-travel requires a selection")].id,
+                    mode: crate::edit::time_travel::TravelMode::Attached,
+                }];
             }
             Action::TogglePin => {
                 if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
@@ -2191,6 +2209,13 @@ impl App {
             && self.selected.and_then(|index| self.rows.get(index)).is_some()
     }
 
+    pub(crate) fn attached_time_travel_shortcut_visible(&self) -> bool {
+        self.time_travel_shortcut_visible()
+            && self.worktree_branch.is_some_and(|(tip, detached)| {
+                detached || self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) != Some(tip)
+            })
+    }
+
     fn last_selectable(&self) -> Option<usize> {
         self.rows.len().checked_sub(1)
     }
@@ -3298,10 +3323,44 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row(1)]);
         assert!(app.update(Action::TimeTravel).is_empty());
+        assert!(app.update(Action::AttachedTimeTravel).is_empty());
         complete(&mut app);
-        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
+        assert_eq!(
+            app.update(Action::TimeTravel),
+            vec![Effect::TimeTravel {
+                id: id(1),
+                mode: crate::edit::time_travel::TravelMode::Detached,
+            }]
+        );
+        assert!(
+            app.update(Action::AttachedTimeTravel).is_empty(),
+            "attached travel requires a current-worktree branch"
+        );
+        app.set_worktree_branch(Some((id(2), false)));
+        assert_eq!(
+            app.update(Action::AttachedTimeTravel),
+            vec![Effect::TimeTravel {
+                id: id(1),
+                mode: crate::edit::time_travel::TravelMode::Attached,
+            }]
+        );
+        app.set_worktree_branch(Some((id(1), false)));
+        assert!(
+            app.update(Action::AttachedTimeTravel).is_empty(),
+            "moving the branch to its current tip is not offered"
+        );
+        app.set_worktree_branch(Some((id(1), true)));
+        assert_eq!(
+            app.update(Action::AttachedTimeTravel),
+            vec![Effect::TimeTravel {
+                id: id(1),
+                mode: crate::edit::time_travel::TravelMode::Attached,
+            }],
+            "a detached worktree may reattach without moving its remembered branch"
+        );
         app.set_worktree_changes_available(false);
         assert!(app.update(Action::TimeTravel).is_empty());
+        assert!(app.update(Action::AttachedTimeTravel).is_empty());
         assert_eq!(app.update(Action::TogglePin), vec![Effect::TogglePin(id(1))]);
     }
 
@@ -3310,23 +3369,29 @@ mod tests {
         let mut app = App::new(2);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
+        app.set_worktree_branch(Some((id(2), false)));
         complete(&mut app);
         app.update(Action::MoveDown);
         assert!(app.time_travel_shortcut_visible());
+        assert!(app.attached_time_travel_shortcut_visible());
 
         app.set_worktree_conflicted(true);
         assert!(!app.time_travel_shortcut_visible());
+        assert!(!app.attached_time_travel_shortcut_visible());
         assert!(app.update(Action::TimeTravel).is_empty());
+        assert!(app.update(Action::AttachedTimeTravel).is_empty());
         app.set_worktree_conflicted(false);
         assert!(app.changes_visible(), "changes are normally shown while enabled");
         app.arm_rebase_conflict(id(1));
         assert!(!app.time_travel_shortcut_visible());
+        assert!(!app.attached_time_travel_shortcut_visible());
         assert!(
             !app.changes_visible(),
             "an in-memory conflict preview cannot be loaded by an on-disk changes view"
         );
         app.clear_rebase_conflict();
         assert!(app.time_travel_shortcut_visible());
+        assert!(app.attached_time_travel_shortcut_visible());
         assert!(app.changes_visible(), "clearing the preview restores the changes view");
     }
 
@@ -3648,7 +3713,13 @@ mod tests {
         assert!(!app.can_forget());
         assert!(app.can_fork_commit());
         assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(4))]);
-        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(4))]);
+        assert_eq!(
+            app.update(Action::TimeTravel),
+            vec![Effect::TimeTravel {
+                id: id(4),
+                mode: crate::edit::time_travel::TravelMode::Detached,
+            }]
+        );
         assert!(
             app.update(Action::VerifySignatures).is_empty(),
             "hidden signatures are not actionable"
@@ -3967,6 +4038,7 @@ mod tests {
         app.update(Action::Rebase);
         app.update(Action::RebaseUpdate);
         app.update(Action::TimeTravel);
+        app.update(Action::AttachedTimeTravel);
         assert!(app.edit_expanded, "grouped edit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 7763338409d..bae2fe256f0 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -30,6 +30,19 @@ pub(crate) enum Perform {
     Conflict(Conflict),
 }
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum TravelMode {
+    Detached,
+    Attached,
+}
+
+#[derive(Clone, Debug)]
+struct AttachedTravel {
+    branch: gix::refs::FullName,
+    branch_tip: ObjectId,
+    head: ObjectId,
+}
+
 impl Perform {
     #[cfg(test)]
     pub(crate) fn complete(self) -> Result<Option<String>> {
@@ -47,6 +60,7 @@ pub(crate) struct Conflict {
     revisions: Vec<OsString>,
     include_worktrees: bool,
     ref_rewrites: Vec<super::rebase::RefRewrite>,
+    attached: Option<AttachedTravel>,
 }
 
 impl Conflict {
@@ -56,18 +70,41 @@ impl Conflict {
 
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
     pub(crate) fn accept(self) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
+        if let Some(attached) = self.attached.as_ref() {
+            let repository = open_repository(&self.repository_path, self.bare, false)
+                .context("could not reopen repository before accepting attached time-travel")?;
+            validate_attached_travel(&repository, attached)?;
+        }
         let mut conflict = self.rebase.persist()?;
         let mut ref_rewrites = self.ref_rewrites;
         ref_rewrites.append(&mut conflict.ref_rewrites);
-        let notice = move_head_to(
-            &self.repository_path,
-            self.bare,
-            conflict.commit,
-            None,
-            &self.revisions,
-            self.include_worktrees,
-            |id| conflict.map(id),
-        )?
+        let notice = match self.attached {
+            Some(mut attached) => {
+                attached.head = conflict
+                    .map(attached.head)
+                    .context("HEAD disappeared while preparing the time-travel conflict")?;
+                attached.branch_tip = conflict
+                    .map(attached.branch_tip)
+                    .context("the worktree branch disappeared while preparing the time-travel conflict")?;
+                move_attached_head_to(
+                    &self.repository_path,
+                    self.bare,
+                    conflict.commit,
+                    attached,
+                    &self.revisions,
+                    self.include_worktrees,
+                )?
+            }
+            None => move_head_to(
+                &self.repository_path,
+                self.bare,
+                conflict.commit,
+                None,
+                &self.revisions,
+                self.include_worktrees,
+                |id| conflict.map(id),
+            )?,
+        }
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
         conflict.materialize()?;
@@ -312,6 +349,326 @@ where
     Ok(Some(notice))
 }
 
+fn resolve_attached_travel(
+    repository: &gix::Repository,
+    head_reference: Option<gix::refs::FullName>,
+    head: ObjectId,
+) -> Result<AttachedTravel> {
+    match head_reference {
+        Some(branch) => {
+            if !branch.as_bstr().starts_with(b"refs/heads/") {
+                anyhow::bail!("attached time-travel requires HEAD to point to a local branch");
+            }
+            Ok(AttachedTravel {
+                branch,
+                branch_tip: head,
+                head,
+            })
+        }
+        None => {
+            let pin = history::all_pins(repository)?
+                .into_iter()
+                .find(history::Pin::is_head)
+                .context("attached time-travel from detached HEAD requires a valid HEAD pin")?;
+            let branch = pin
+                .target
+                .try_name()
+                .context("the HEAD pin must point to a local branch")?
+                .to_owned();
+            if !branch.as_bstr().starts_with(b"refs/heads/") {
+                anyhow::bail!("the HEAD pin must point to a local branch");
+            }
+            Ok(AttachedTravel {
+                branch,
+                branch_tip: pin.id,
+                head,
+            })
+        }
+    }
+}
+
+fn validate_attached_travel(repository: &gix::Repository, attached: &AttachedTravel) -> Result<bool> {
+    if !attached.branch.as_bstr().starts_with(b"refs/heads/") {
+        anyhow::bail!("attached time-travel requires a local branch");
+    }
+    let head = repository
+        .head()
+        .context("could not read HEAD before attached time-travel")?;
+    let head_id = head
+        .id()
+        .map(gix::Id::detach)
+        .context("cannot time-travel from an unborn HEAD")?;
+    if head_id != attached.head {
+        anyhow::bail!("HEAD changed while preparing attached time-travel");
+    }
+    let head_reference = head.referent_name().map(ToOwned::to_owned);
+    drop(head);
+    let head_is_detached = match head_reference {
+        Some(reference) if reference == attached.branch => false,
+        Some(reference) => anyhow::bail!(
+            "HEAD changed from {} to {} while preparing attached time-travel",
+            attached.branch.shorten(),
+            reference.shorten()
+        ),
+        None => {
+            let pin = history::all_pins(repository)?
+                .into_iter()
+                .find(history::Pin::is_head)
+                .context("the HEAD pin disappeared while preparing attached time-travel")?;
+            if pin.target.try_name() != Some(attached.branch.as_ref()) || pin.id != attached.branch_tip {
+                anyhow::bail!("the HEAD pin changed while preparing attached time-travel");
+            }
+            true
+        }
+    };
+    let branch_id = repository
+        .find_reference(attached.branch.as_ref())
+        .context("the worktree branch disappeared while preparing attached time-travel")?
+        .try_id()
+        .context("the worktree branch must be a direct reference")?
+        .detach();
+    if branch_id != attached.branch_tip {
+        anyhow::bail!("the worktree branch changed while preparing attached time-travel");
+    }
+    ensure_branch_is_available(repository, attached.branch.as_ref())?;
+    Ok(head_is_detached)
+}
+
+fn move_attached_head_to(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    attached: AttachedTravel,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<Option<String>> {
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not open repository for attached time-travel checkout")?;
+    let workdir = repository
+        .workdir()
+        .context("time-travel requires a worktree")?
+        .to_owned();
+    let head_is_detached = validate_attached_travel(&repository, &attached)?;
+    if !head_is_detached && selected == attached.head {
+        return Ok(None);
+    }
+
+    let destination_pin = selected_pin(&repository, selected)?;
+    let old_tree = repository
+        .find_commit(attached.head)
+        .context("could not find the attached time-travel departure")?
+        .tree_id()
+        .context("could not read the attached time-travel departure tree")?
+        .detach();
+    let new_tree = repository
+        .find_commit(selected)
+        .context("could not find the attached time-travel destination")?
+        .tree_id()
+        .context("could not read the attached time-travel destination tree")?
+        .detach();
+    if old_tree != new_tree {
+        super::forget::preflight_tree_transition(&repository, &workdir, old_tree, new_tree)
+            .context("local changes conflict with attached time-travel")?;
+    }
+
+    let mut provisional = Vec::new();
+    for departure in [attached.head, attached.branch_tip] {
+        if departure == selected
+            || provisional
+                .iter()
+                .any(|(pin, _): &(history::Pin, bool)| pin.id == departure)
+            || contains(&repository, departure, selected)
+        {
+            continue;
+        }
+        match create_or_reuse_pin(
+            &repository,
+            Target::Object(departure),
+            departure,
+            "tix attached time-travel",
+        ) {
+            Ok(pin) => provisional.push(pin),
+            Err(err) => {
+                return Err(cleanup_new_pins(&repository, &provisional, err));
+            }
+        }
+    }
+
+    let mut forward = Vec::new();
+    let mut rollback = Vec::new();
+    if attached.branch_tip != selected {
+        forward.push(attached_ref_edit(
+            attached.branch.clone(),
+            Target::Object(attached.branch_tip),
+            Target::Object(selected),
+        ));
+        rollback.push(attached_ref_edit(
+            attached.branch.clone(),
+            Target::Object(selected),
+            Target::Object(attached.branch_tip),
+        ));
+    }
+    if head_is_detached {
+        let head: gix::refs::FullName = "HEAD".try_into().expect("valid reference name");
+        forward.push(attached_ref_edit(
+            head.clone(),
+            Target::Object(attached.head),
+            Target::Symbolic(attached.branch.clone()),
+        ));
+        rollback.push(attached_ref_edit(
+            head,
+            Target::Symbolic(attached.branch.clone()),
+            Target::Object(attached.head),
+        ));
+    }
+    if let Err(err) = repository
+        .edit_references(forward)
+        .context("could not move the worktree branch for attached time-travel")
+    {
+        return Err(cleanup_new_pins(&repository, &provisional, err));
+    }
+    if old_tree != new_tree
+        && let Err(err) = super::forget::apply_tree_transition(&workdir, old_tree, new_tree)
+            .context("could not update the worktree for attached time-travel")
+    {
+        if let Err(rollback_err) = repository
+            .edit_references(rollback)
+            .context("could not roll back attached time-travel references")
+        {
+            return Err(err.context(format!(
+                "reference rollback failed: {rollback_err:#}; provisional pins retained"
+            )));
+        }
+        return Err(cleanup_new_pins(&repository, &provisional, err));
+    }
+
+    let mut notice = if attached.branch_tip == selected {
+        format!("reattached HEAD to {}", attached.branch.shorten())
+    } else {
+        format!("moved {} to {}", attached.branch.shorten(), selected.to_hex_with_len(7))
+    };
+    if let Some(pin) = destination_pin
+        && let Err(err) = delete_pin(&repository, &pin)
+    {
+        notice = format!("{notice}; destination pin remains: {err:#}");
+    }
+    match reconcile_head_pin(&repository, &workdir) {
+        Ok(Some(addition)) => notice = format!("{notice}; {addition}"),
+        Ok(None) => {}
+        Err(err) => notice = format!("{notice}; HEAD pin reconciliation failed: {err:#}"),
+    }
+    for (pin, _) in provisional {
+        let snapshot = match history::snapshot_ignoring_pin(
+            &repository,
+            revisions,
+            &[],
+            include_worktrees,
+            Some(pin.name.as_bstr()),
+        ) {
+            Ok(snapshot) => snapshot,
+            Err(err) => {
+                notice = format!(
+                    "{notice}; kept {} because reachability could not be checked: {err:#}",
+                    pin_label(&pin)
+                );
+                continue;
+            }
+        };
+        if snapshot
+            .view_tips
+            .iter()
+            .copied()
+            .any(|tip| contains(&repository, pin.id, tip))
+        {
+            if let Err(err) = delete_pin(&repository, &pin) {
+                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
+            }
+        } else {
+            notice = format!("{notice}; saved {}", pin_label(&pin));
+        }
+    }
+    Ok(Some(notice))
+}
+
+fn attached_ref_edit(name: gix::refs::FullName, old: Target, new: Target) -> RefEdit {
+    RefEdit {
+        name,
+        deref: false,
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: "tix attached time-travel".into(),
+            },
+            expected: PreviousValue::MustExistAndMatch(old),
+            new,
+        },
+    }
+}
+
+fn cleanup_new_pins(
+    repository: &gix::Repository,
+    pins: &[(history::Pin, bool)],
+    mut cause: anyhow::Error,
+) -> anyhow::Error {
+    let edits: Vec<_> = pins
+        .iter()
+        .filter(|(_, created)| *created)
+        .map(|(pin, _)| delete_pin_edit(pin))
+        .collect();
+    if !edits.is_empty()
+        && let Err(err) = repository
+            .edit_references(edits)
+            .context("could not remove provisional attached time-travel pins")
+    {
+        cause = cause.context(format!("provisional pin cleanup failed: {err:#}"));
+    }
+    cause
+}
+
+fn ensure_branch_is_available(repository: &gix::Repository, branch: &gix::refs::FullNameRef) -> Result<()> {
+    let current = repository
+        .worktree()
+        .context("attached time-travel requires a current worktree")?;
+    let current_id = current.id().map(ToOwned::to_owned);
+    if current_id.is_some() {
+        ensure_worktree_does_not_own_branch(
+            repository
+                .main_repo()
+                .context("could not open the main worktree while checking the attached branch")?,
+            branch,
+        )?;
+    }
+    for proxy in repository
+        .worktrees()
+        .context("could not enumerate worktrees while checking the attached branch")?
+    {
+        if current_id
+            .as_ref()
+            .is_some_and(|current| current.as_slice() == proxy.id().as_bytes())
+        {
+            continue;
+        }
+        ensure_worktree_does_not_own_branch(
+            proxy
+                .into_repo_with_possibly_inaccessible_worktree()
+                .context("could not inspect a linked worktree while checking the attached branch")?,
+            branch,
+        )?;
+    }
+    Ok(())
+}
+
+fn ensure_worktree_does_not_own_branch(worktree: gix::Repository, branch: &gix::refs::FullNameRef) -> Result<()> {
+    let head = worktree
+        .head()
+        .context("could not inspect another worktree HEAD while checking the attached branch")?;
+    if head.referent_name() == Some(branch) {
+        anyhow::bail!("{} is checked out in another worktree", branch.shorten());
+    }
+    Ok(())
+}
+
 pub(crate) fn perform(
     repository_path: &Path,
     bare: bool,
@@ -329,6 +686,7 @@ pub(crate) fn perform(
         review_roots,
         revisions,
         include_worktrees,
+        TravelMode::Detached,
         |_| {},
     )
 }
@@ -346,6 +704,7 @@ pub(crate) fn perform_reporting_rebased(
     review_roots: &[ObjectId],
     revisions: &[OsString],
     include_worktrees: bool,
+    mode: TravelMode,
     mut report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     let mut repository =
@@ -356,7 +715,18 @@ pub(crate) fn perform_reporting_rebased(
         anyhow::bail!("cannot time-travel from an unborn HEAD");
     };
     let head_was_detached = head.is_detached();
+    let mut attached = match mode {
+        TravelMode::Detached => None,
+        TravelMode::Attached => Some(resolve_attached_travel(
+            &repository,
+            head.referent_name().map(ToOwned::to_owned),
+            head_id,
+        )?),
+    };
     drop(head);
+    if let Some(attached) = attached.as_ref() {
+        validate_attached_travel(&repository, attached)?;
+    }
     if repository
         .index_or_empty()
         .context("could not inspect the index before time-travel")?
@@ -397,6 +767,7 @@ pub(crate) fn perform_reporting_rebased(
                     revisions: revisions.to_vec(),
                     include_worktrees,
                     ref_rewrites,
+                    attached,
                 }));
             }
         };
@@ -412,6 +783,14 @@ pub(crate) fn perform_reporting_rebased(
         head_id = outcome
             .map(head_id)
             .context("HEAD disappeared while completing its rebase")?;
+        if let Some(attached) = &mut attached {
+            attached.head = outcome
+                .map(attached.head)
+                .context("HEAD disappeared while completing its attached time-travel rebase")?;
+            attached.branch_tip = outcome
+                .map(attached.branch_tip)
+                .context("the worktree branch disappeared while completing its rebase")?;
+        }
         review_roots = review_roots.into_iter().filter_map(|id| outcome.map(id)).collect();
         repository = open_repository(repository_path, bare, false)
             .context("could not reopen repository after completing a pending rebase")?;
@@ -437,17 +816,22 @@ pub(crate) fn perform_reporting_rebased(
     } else {
         None
     };
-    let moved = move_head_to(
-        repository_path,
-        bare,
-        selected,
-        None,
-        revisions,
-        include_worktrees,
-        |actual| {
-            if head_was_detached { Some(head_id) } else { Some(actual) }
-        },
-    );
+    let moved = match attached {
+        Some(attached) => {
+            move_attached_head_to(repository_path, bare, selected, attached, revisions, include_worktrees)
+        }
+        None => move_head_to(
+            repository_path,
+            bare,
+            selected,
+            None,
+            revisions,
+            include_worktrees,
+            |actual| {
+                if head_was_detached { Some(head_id) } else { Some(actual) }
+            },
+        ),
+    };
     let mut notice = match moved {
         Ok(notice) => notice,
         Err(err) => {
@@ -970,6 +1354,47 @@ mod tests {
         graph.context("history traversal did not produce a graph")
     }
 
+    fn pending_conflict_fixture() -> gix_testtools::Result<(
+        gix_testtools::tempfile::TempDir,
+        PathBuf,
+        ObjectId,
+        ObjectId,
+        history::HistoryGraph,
+    )> {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        git(
+            fixture.path(),
+            &["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000"],
+        )?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        std::fs::write(fixture.path().join("after"), "after\n")?;
+        git(fixture.path(), &["add", "after"])?;
+        let commit = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["commit", "-q", "-m", "after"])
+            .env("GIT_AUTHOR_DATE", "2000-01-04T00:00:00 +0000")
+            .env("GIT_COMMITTER_DATE", "2000-01-04T00:00:00 +0000")
+            .status()?;
+        assert!(commit.success(), "the fixture descendant commit is created");
+        let graph = super::super::loaded_graph(&repository)?;
+        super::super::rebase::perform(
+            &repository,
+            &graph,
+            super::super::rebase::Edit::Remove { target: middle },
+            super::super::rebase::Signature::RedoIfNeeded,
+            super::super::rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let graph = super::super::loaded_graph(&repository)?;
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let tip = repository.find_reference("refs/heads/main")?.id().detach();
+        drop(repository);
+        Ok((fixture, repository_path, root, tip, graph))
+    }
+
     #[test]
     fn review_state_is_stashed_only_when_crossing_its_tree_boundary() -> gix_testtools::Result {
         let fixture = gix_testtools::tempfile::tempdir()?;
@@ -1263,75 +1688,457 @@ mod tests {
     }
 
     #[test]
-    fn explicit_attachment_clears_the_head_pin() -> gix_testtools::Result {
+    fn attached_travel_moves_the_branch_and_preserves_its_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
-        let topic = repository.rev_parse_single("topic")?.detach();
-        let topic_ref = repository.find_reference("refs/heads/topic")?.name().to_owned();
+        let main = repository.rev_parse_single("main")?.detach();
         let graph = loaded_graph(&repository, &[])?;
+        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
         drop(repository);
 
-        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        move_head_to(&repository_path, false, topic, Some(&topic_ref), &[], false, Some)?;
+        let notice = perform_reporting_rebased(
+            &repository_path,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        .complete()?
+        .context("attached travel changes the branch")?;
+        assert!(notice.contains("moved main"), "{notice}");
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
-            Some(topic_ref.into())
+            Some(b"refs/heads/main".into()),
+            "attached travel keeps HEAD on its local branch"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            root,
+            "attached travel moves the worktree branch to the selected commit"
+        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(
+            pins.len(),
+            1,
+            "the destination pin is consumed and the departure is retained"
         );
+        assert_eq!(pins[0].id, main, "the old branch tip remains reachable");
         assert!(
-            history::all_pins(&repository)?.iter().all(|pin| !pin.is_head()),
-            "an explicit attachment clears the remembered branch"
+            pins[0].target.try_name().is_none(),
+            "a moved branch tip needs a direct pin which does not follow the branch"
+        );
+        assert!(
+            fixture.path().join("root").is_file(),
+            "the destination tree is checked out"
+        );
+        assert!(
+            !fixture.path().join("main").exists(),
+            "files beyond the destination are removed"
         );
         Ok(())
     }
 
     #[test]
-    fn failed_reattachment_keeps_the_head_pin() -> gix_testtools::Result {
+    fn attached_travel_from_detached_head_retains_only_the_outer_departure() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
+        let middle = repository.rev_parse_single("main~1")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let graph = loaded_graph(&repository, &[])?;
         drop(repository);
 
-        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let linked = fixture.path().join("main-wt");
-        let worktree = Command::new("git")
-            .arg("-C")
-            .arg(fixture.path())
-            .args(["worktree", "add", "-q"])
-            .arg(&linked)
-            .arg("main")
-            .status()?;
-        assert!(worktree.success(), "another worktree checks out the remembered branch");
-
-        let notice = perform(&repository_path, false, main, &graph, &[], &[], false)?
-            .complete()?
-            .context("travel reports the failed reattachment")?;
-        assert!(notice.contains("could not reattach HEAD to main"), "{notice}");
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
         let repository = crate::test_repository::open(fixture.path())?;
+        assert!(repository.head()?.is_detached(), "ordinary travel detaches HEAD first");
         assert!(
-            repository.head()?.is_detached(),
-            "the successful detached checkout is retained"
+            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            "ordinary travel remembers the worktree branch"
         );
-        assert_eq!(repository.head_id()?.detach(), main);
+        drop(repository);
+
+        perform_reporting_rebased(
+            &repository_path,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        .complete()?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "attached travel reattaches the remembered branch"
+        );
+        assert_eq!(
+            repository.head_id()?.detach(),
+            root,
+            "HEAD lands at the selected commit"
+        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(
+            pins.len(),
+            1,
+            "the old branch tip makes its ancestor departure redundant"
+        );
+        assert_eq!(pins[0].id, main, "the moved branch tip remains pinned directly");
         assert!(
-            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
-            "the HEAD pin remains available for a later retry"
+            pins.iter().all(|pin| !pin.is_head() && pin.id != middle),
+            "the HEAD pin is consumed and the inner detached departure is removed"
         );
         Ok(())
     }
 
     #[test]
-    fn returning_to_a_commit_restores_its_manual_stash() -> gix_testtools::Result {
+    fn attached_travel_rejects_a_branch_owned_by_another_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
-        let head = repository.head_id()?.detach();
-        let parent = repository
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let middle = repository.rev_parse_single("main~1")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        let linked = fixture.path().join("main-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("main")
+            .status()?;
+        assert!(worktree.success(), "the remembered branch moves to another worktree");
+
+        let err = perform_reporting_rebased(
+            &repository_path,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )
+        .and_then(Perform::complete)
+        .expect_err("a branch cannot become attached in two worktrees");
+        assert!(
+            format!("{err:#}").contains("checked out in another worktree"),
+            "{err:#}"
+        );
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(
+            repository.head()?.is_detached(),
+            "failed attached travel retains detached HEAD"
+        );
+        assert_eq!(
+            repository.head_id()?.detach(),
+            middle,
+            "failed travel retains its departure"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            main,
+            "the other worktree's branch is not moved"
+        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "failure creates no provisional pins");
+        assert!(pins[0].is_head(), "the remembered branch remains available");
+        Ok(())
+    }
+
+    #[test]
+    fn attached_travel_accepts_the_branch_of_the_current_linked_worktree() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let linked = fixture.path().join("topic-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("topic")
+            .status()?;
+        assert!(worktree.success(), "the linked worktree checks out topic");
+        let git_dir = crate::test_repository::open(&linked)?.git_dir().to_owned();
+        let repository = open_repository(&git_dir, false, false)?;
+        let branch = repository.find_reference("refs/heads/topic")?.name().to_owned();
+        let root = repository.rev_parse_single("topic~1")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&git_dir, false, root, &graph, &[], &[], false)?.complete()?;
+        let repository = open_repository(&git_dir, false, false)?;
+        assert!(
+            repository.head()?.is_detached(),
+            "ordinary travel detaches the linked worktree"
+        );
+        assert!(
+            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            "ordinary travel remembers the linked worktree branch"
+        );
+        drop(repository);
+
+        perform_reporting_rebased(
+            &git_dir,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        .complete()?;
+        let repository = open_repository(&git_dir, false, false)?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(branch.as_bstr().to_owned()),
+            "attached travel reattaches the current linked worktree branch"
+        );
+        assert_eq!(
+            repository.find_reference(branch.as_ref())?.id().detach(),
+            root,
+            "attached travel moves the linked worktree branch"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn failed_attached_ref_update_restores_only_new_departure_pins() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let middle = repository.rev_parse_single("main~1")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
+        let index_before = std::fs::read(repository.index_path())?;
+        let snapshot_before = gix_testtools::repository::snapshot(fixture.path())?;
+        let branch_lock = repository.git_dir().join("refs/heads/main.lock");
+        std::fs::write(&branch_lock, b"locked")?;
+        drop(repository);
+
+        let err = perform_reporting_rebased(
+            &repository_path,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )
+        .and_then(Perform::complete)
+        .expect_err("the branch lock rejects the attached ref transaction");
+        std::fs::remove_file(branch_lock)?;
+        assert!(
+            format!("{err:#}").contains("could not move the worktree branch"),
+            "{err:#}"
+        );
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            snapshot_before,
+            "a failed ref transaction leaves repository references and the worktree unchanged"
+        );
+        assert_eq!(
+            std::fs::read(repository.index_path())?,
+            index_before,
+            "a failed ref transaction leaves the index unchanged"
+        );
+        assert!(
+            repository.head()?.is_detached(),
+            "failed attached travel retains detached HEAD"
+        );
+        assert_eq!(
+            repository.head_id()?.detach(),
+            middle,
+            "failed travel retains its departure"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            main,
+            "the locked branch remains unchanged"
+        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 2, "only the HEAD and destination pins remain");
+        assert!(pins.iter().any(history::Pin::is_head), "the HEAD pin survives failure");
+        assert!(
+            pins.iter().any(|pin| !pin.is_head() && pin.id == root),
+            "the destination pin survives failure"
+        );
+        assert!(
+            pins.iter()
+                .all(|pin| pin.is_head() || pin.id != middle && pin.id != main),
+            "new direct departure pins are cleaned up"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn failed_attached_worktree_update_rolls_back_refs_and_new_pins() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let middle = repository.rev_parse_single("main~1")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
+        let index_before = std::fs::read(repository.index_path())?;
+        let snapshot_before = gix_testtools::repository::snapshot(fixture.path())?;
+        let index_lock = repository.index_path().with_file_name("index.lock");
+        std::fs::write(&index_lock, b"locked")?;
+        drop(repository);
+
+        let err = perform_reporting_rebased(
+            &repository_path,
+            false,
+            root,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )
+        .and_then(Perform::complete)
+        .expect_err("the index lock rejects the worktree transition after refs move");
+        std::fs::remove_file(index_lock)?;
+        assert!(format!("{err:#}").contains("could not update the worktree"), "{err:#}");
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            snapshot_before,
+            "a failed worktree transition rolls HEAD, the branch, and worktree back"
+        );
+        assert_eq!(
+            std::fs::read(repository.index_path())?,
+            index_before,
+            "a failed worktree transition leaves the index unchanged"
+        );
+        assert!(repository.head()?.is_detached(), "rollback restores detached HEAD");
+        assert_eq!(
+            repository.head_id()?.detach(),
+            middle,
+            "rollback restores HEAD's commit"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            main,
+            "rollback restores the remembered branch"
+        );
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 2, "only the pre-existing HEAD and destination pins remain");
+        assert!(pins.iter().any(history::Pin::is_head), "the HEAD pin survives rollback");
+        assert!(
+            pins.iter().any(|pin| !pin.is_head() && pin.id == root),
+            "the destination pin survives rollback"
+        );
+        assert!(
+            pins.iter()
+                .all(|pin| pin.is_head() || pin.id != middle && pin.id != main),
+            "new direct departure pins are removed after successful rollback"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn explicit_attachment_clears_the_head_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let topic_ref = repository.find_reference("refs/heads/topic")?.name().to_owned();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        move_head_to(&repository_path, false, topic, Some(&topic_ref), &[], false, Some)?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(topic_ref.into())
+        );
+        assert!(
+            history::all_pins(&repository)?.iter().all(|pin| !pin.is_head()),
+            "an explicit attachment clears the remembered branch"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn failed_reattachment_keeps_the_head_pin() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("main~2")?.detach();
+        let main = repository.rev_parse_single("main")?.detach();
+        let graph = loaded_graph(&repository, &[])?;
+        drop(repository);
+
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let linked = fixture.path().join("main-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("main")
+            .status()?;
+        assert!(worktree.success(), "another worktree checks out the remembered branch");
+
+        let notice = perform(&repository_path, false, main, &graph, &[], &[], false)?
+            .complete()?
+            .context("travel reports the failed reattachment")?;
+        assert!(notice.contains("could not reattach HEAD to main"), "{notice}");
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(
+            repository.head()?.is_detached(),
+            "the successful detached checkout is retained"
+        );
+        assert_eq!(repository.head_id()?.detach(), main);
+        assert!(
+            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            "the HEAD pin remains available for a later retry"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn returning_to_a_commit_restores_its_manual_stash() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let head = repository.head_id()?.detach();
+        let parent = repository
             .find_commit(head)?
             .parent_ids()
             .next()
@@ -1527,51 +2334,63 @@ mod tests {
     }
 
     #[test]
-    fn conflicting_pending_rebases_are_unobservable_until_accepted() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+    fn attached_pending_travel_checks_branch_ownership_before_replay() -> gix_testtools::Result {
+        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let linked = fixture.path().join("main-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("main")
+            .status()?;
+        assert!(worktree.success(), "another worktree checks out the pending branch");
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let linked_before = gix_testtools::repository::snapshot(&linked)?;
+
+        let err = perform_reporting_rebased(
+            &repository_path,
+            false,
+            tip,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )
+        .and_then(Perform::complete)
+        .expect_err("another worktree must be rejected before pending commits are replayed");
         assert!(
-            Command::new("git")
-                .arg("-C")
-                .arg(fixture.path())
-                .args(["config", "gitoxide.commit.committerDate", "2001-01-01T00:00:00 +0000",])
-                .status()?
-                .success()
+            format!("{err:#}").contains("checked out in another worktree"),
+            "{err:#}"
         );
-        let repository = crate::test_repository::open(fixture.path())?;
-        let repository_path = repository.git_dir().to_owned();
-        let middle = repository.rev_parse_single("HEAD~1")?.detach();
-        std::fs::write(fixture.path().join("after"), "after\n")?;
-        assert!(
-            Command::new("git")
-                .arg("-C")
-                .arg(fixture.path())
-                .args(["add", "after"])
-                .status()?
-                .success()
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "branch ownership rejection leaves the detached source untouched"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(&linked)?,
+            linked_before,
+            "branch ownership rejection does not replay the other worktree"
         );
         assert!(
-            Command::new("git")
-                .arg("-C")
-                .arg(fixture.path())
-                .args(["commit", "-q", "-m", "after"])
-                .env("GIT_AUTHOR_DATE", "2000-01-04T00:00:00 +0000")
-                .env("GIT_COMMITTER_DATE", "2000-01-04T00:00:00 +0000")
-                .status()?
-                .success()
+            super::super::rebase::is_pending(
+                &crate::test_repository::open(fixture.path())?
+                    .find_commit(tip)?
+                    .decode()?
+                    .into_owned()?
+            ),
+            "the pending destination remains unchanged"
         );
-        let graph = super::super::loaded_graph(&repository)?;
-        super::super::rebase::perform(
-            &repository,
-            &graph,
-            super::super::rebase::Edit::Remove { target: middle },
-            super::super::rebase::Signature::RedoIfNeeded,
-            super::super::rebase::Tree::LeaveAsIsAndMark,
-        )?
-        .complete()?;
-        let graph = super::super::loaded_graph(&repository)?;
-        let root = repository.rev_parse_single("HEAD~2")?.detach();
-        let tip = repository.find_reference("refs/heads/main")?.id().detach();
-        drop(repository);
+        Ok(())
+    }
+
+    #[test]
+    fn conflicting_pending_rebases_are_unobservable_until_accepted() -> gix_testtools::Result {
+        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
         let repository = crate::test_repository::open(fixture.path())?;
         let graph = super::super::loaded_graph(&repository)?;
@@ -1642,6 +2461,143 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn attached_travel_conflict_moves_and_keeps_the_worktree_branch() -> gix_testtools::Result {
+        let (fixture, repository_path, _root, tip, graph) = pending_conflict_fixture()?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let Perform::Conflict(conflict) = perform_reporting_rebased(
+            &repository_path,
+            false,
+            tip,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        else {
+            return Err("attached travel should suspend at its conflicting cherry-pick".into());
+        };
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "preparing an attached conflict changes no repository state"
+        );
+
+        let (_notice, conflict_id, _) = conflict.accept()?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "materializing an attached conflict keeps HEAD on its worktree branch"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            conflict_id,
+            "the worktree branch moves to the conflicting destination"
+        );
+        assert!(
+            history::all_pins(&repository)?.iter().all(|pin| !pin.is_head()),
+            "an attached conflict leaves no HEAD pin"
+        );
+        assert!(
+            repository
+                .index_or_empty()?
+                .entries()
+                .iter()
+                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted),
+            "the attached conflict materializes unresolved index stages"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn attached_conflict_rechecks_branch_ownership_before_persisting() -> gix_testtools::Result {
+        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
+        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
+        let Perform::Conflict(conflict) = perform_reporting_rebased(
+            &repository_path,
+            false,
+            tip,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        else {
+            return Err("attached travel should suspend at its conflicting cherry-pick".into());
+        };
+        let linked = fixture.path().join("main-wt");
+        let worktree = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["worktree", "add", "-q"])
+            .arg(&linked)
+            .arg("main")
+            .status()?;
+        assert!(
+            worktree.success(),
+            "another worktree claims the branch before acceptance"
+        );
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let linked_before = gix_testtools::repository::snapshot(&linked)?;
+
+        let err = conflict
+            .accept()
+            .expect_err("conflict acceptance must recheck branch ownership before persisting");
+        assert!(
+            format!("{err:#}").contains("checked out in another worktree"),
+            "{err:#}"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "failed acceptance leaves the detached source untouched"
+        );
+        assert_eq!(
+            gix_testtools::repository::snapshot(&linked)?,
+            linked_before,
+            "failed acceptance leaves the owning worktree untouched"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn attached_conflict_rechecks_current_head_before_persisting() -> gix_testtools::Result {
+        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
+        let Perform::Conflict(conflict) = perform_reporting_rebased(
+            &repository_path,
+            false,
+            tip,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Attached,
+            |_| {},
+        )?
+        else {
+            return Err("attached travel should suspend at its conflicting cherry-pick".into());
+        };
+        git(fixture.path(), &["branch", "other", &root.to_string()])?;
+        git(fixture.path(), &["checkout", "-q", "other"])?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let err = conflict
+            .accept()
+            .expect_err("conflict acceptance must recheck HEAD before persisting");
+        assert!(format!("{err:#}").contains("HEAD changed"), "{err:#}");
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "a changed HEAD rejects the stale conflict without rewriting its former branch"
+        );
+        Ok(())
+    }
+
     #[test]
     fn time_travel_materializes_only_the_pending_path_to_the_destination() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
@@ -1728,9 +2684,19 @@ mod tests {
         drop(repository);
 
         let mut rebased = Vec::new();
-        perform_reporting_rebased(&repository_path, false, pending_middle, &graph, &[], &[], false, |id| {
-            rebased.push(id);
-        })?
+        perform_reporting_rebased(
+            &repository_path,
+            false,
+            pending_middle,
+            &graph,
+            &[],
+            &[],
+            false,
+            TravelMode::Detached,
+            |id| {
+                rebased.push(id);
+            },
+        )?
         .complete()?;
         assert_eq!(
             rebased,
@@ -1776,6 +2742,7 @@ mod tests {
             &[],
             &[],
             false,
+            TravelMode::Detached,
             |id| rebased.push(id),
         )?
         .complete()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index bfae3567433..acaa14f5461 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -917,6 +917,7 @@ fn event_loop(
 
     let mut app = App::new(1);
     app.set_worktree_head_unborn(worktree_head_unborn);
+    app.set_worktree_branch(current_worktree_branch(&ref_snapshot));
     app.commit_pane_background = commit_pane_background;
     if recovered_at_startup {
         app.leave_attention("worktree removed; using the common repository without worktree changes");
@@ -1010,6 +1011,7 @@ fn event_loop(
             fill_repository.retain = false;
             fill_repository.retained = None;
             app.set_worktree_changes_available(false);
+            app.set_worktree_branch(None);
             worktree_watcher = None;
             worktree_refresh_deadline = None;
             worktree_watch_set_changed = false;
@@ -1299,6 +1301,11 @@ fn event_loop(
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
                     let result = result?;
+                    app.set_worktree_branch(
+                        (!repository_is_bare)
+                            .then(|| current_worktree_branch(&result.refs))
+                            .flatten(),
+                    );
                     ref_tree.rebuild(&graph, &result.refs, &result.decorations);
                     history_graph = Some(graph);
                     tracing::info!(commit_count = result.commits.rows.len(), "history refresh completed");
@@ -1418,6 +1425,7 @@ fn event_loop(
                 "compared reference snapshot"
             );
             ref_snapshot = next;
+            app.set_worktree_branch(current_worktree_branch(&ref_snapshot));
             refresh_pending = false;
             let hidden = if app.show_hidden { Vec::new() } else { hide.clone() };
             let expand = if refresh_expand_hidden || hidden_changed {
@@ -2561,7 +2569,7 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("finish review: {err:#}")),
                     }
                 }
-                Effect::TimeTravel(id) => {
+                Effect::TimeTravel { id, mode } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let review_roots: Vec<_> = app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
@@ -2579,6 +2587,7 @@ fn event_loop(
                                         &review_roots,
                                         &revisions,
                                         false,
+                                        mode,
                                         report,
                                     )
                                 },
@@ -2983,6 +2992,19 @@ fn decoration_head(decorations: &Decorations) -> Option<gix::ObjectId> {
     })
 }
 
+fn current_worktree_branch(refs: &history::RefSnapshot) -> Option<(gix::ObjectId, bool)> {
+    refs.worktrees
+        .iter()
+        .find(|worktree| {
+            worktree.is_current
+                && worktree
+                    .reference
+                    .as_ref()
+                    .is_some_and(|reference| reference.as_bstr().starts_with(b"refs/heads/"))
+        })
+        .map(|worktree| (worktree.label_id, worktree.is_detached))
+}
+
 fn decoration_successor(selected: gix::ObjectId, current: &Decorations, next: &Decorations) -> Option<gix::ObjectId> {
     let selected = current.get(&selected)?;
     let mut matches = next.iter().filter_map(|(id, decorations)| {
@@ -5053,6 +5075,8 @@ fn action_with_shortcut_groups(
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
         KeyCode::Char('@') => Some(Action::TimeTravel),
         KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::TimeTravel),
+        KeyCode::Char('#') => Some(Action::AttachedTimeTravel),
+        KeyCode::Char('3') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::AttachedTimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
@@ -5172,6 +5196,36 @@ mod tests {
         assert_eq!(decoration_successor(old, &current, &next), Some(new));
     }
 
+    #[test]
+    fn finds_the_current_worktree_branch_in_attached_and_remembered_states() {
+        let id = gix::ObjectId::Sha1([1; 20]);
+        let mut refs = history::RefSnapshot {
+            view: Default::default(),
+            hidden: Default::default(),
+            view_tips: Vec::new(),
+            hidden_tips: Vec::new(),
+            pins: Vec::new(),
+            worktrees: vec![history::WorktreeCheckout {
+                id,
+                label_id: id,
+                checkout_name: "main".into(),
+                reference: Some("refs/heads/main".try_into().expect("valid branch name")),
+                is_current: true,
+                is_detached: false,
+            }],
+        };
+        assert_eq!(current_worktree_branch(&refs), Some((id, false)));
+
+        refs.worktrees[0].is_detached = true;
+        assert_eq!(current_worktree_branch(&refs), Some((id, true)));
+        refs.worktrees[0].reference = None;
+        assert_eq!(
+            current_worktree_branch(&refs),
+            None,
+            "manual detachment has no branch to move"
+        );
+    }
+
     #[test]
     fn reference_watcher_observes_new_loose_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -6185,6 +6239,21 @@ mod tests {
             None,
             "an unshifted 2 has no time-travel behavior"
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('#'), KeyModifiers::NONE)),
+            Some(Action::AttachedTimeTravel),
+            "the terminal's direct hash event invokes attached time travel"
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('3'), KeyModifiers::SHIFT)),
+            Some(Action::AttachedTimeTravel),
+            "terminals which preserve the base character map Shift-3 to attached time travel"
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('3'), KeyModifiers::NONE)),
+            None,
+            "an unshifted 3 has no attached-time-travel behavior"
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
@@ -6292,6 +6361,16 @@ mod tests {
             Some(Action::TimeTravel),
             "the direct time-travel key remains available while edit is expanded"
         );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('#'), KeyModifiers::NONE),
+                false,
+                true,
+                false
+            ),
+            Some(Action::AttachedTimeTravel),
+            "the direct attached-time-travel key remains available while edit is expanded"
+        );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL),
@@ -6446,6 +6525,7 @@ mod tests {
             Action::Amend,
             Action::Rebase,
             Action::TimeTravel,
+            Action::AttachedTimeTravel,
             Action::VerifySignatures,
             Action::Quit,
         ] {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index c02461a4509..96fc2bca996 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -941,13 +941,15 @@ pub(crate) fn draw_with_worktree(
     };
     let mut footer_spans = vec![Span::raw(status)];
     let mut time_travel = None;
+    let mut attached_time_travel = false;
     let mut edit_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
+        let head_visible = decorations
+            .values()
+            .flatten()
+            .any(|decoration| decoration.kind == DecorationKind::Head);
         time_travel = if app.time_travel_shortcut_visible()
-            && decorations
-                .values()
-                .flatten()
-                .any(|decoration| decoration.kind == DecorationKind::Head)
+            && head_visible
             && let Some(selected) = app.selected.and_then(|index| app.rows.get(index))
         {
             let selected_refs = decorations.get(&selected.id).map(Vec::as_slice).unwrap_or_default();
@@ -971,6 +973,7 @@ pub(crate) fn draw_with_worktree(
         } else {
             None
         };
+        attached_time_travel = head_visible && app.attached_time_travel_shortcut_visible();
         if app.edit_expanded {
             let mut options = Vec::new();
             if app.can_rebase() {
@@ -1134,6 +1137,10 @@ pub(crate) fn draw_with_worktree(
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut(label, '@', true));
     }
+    if attached_time_travel {
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("# attach", '#', true));
+    }
     if app.can_cycle_duplicate() {
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("next duplicate", 'x', true));
@@ -3486,7 +3493,7 @@ mod tests {
     }
 
     #[test]
-    fn advertises_travel_and_return_for_non_head_rows() -> Result<(), Box<dyn std::error::Error>> {
+    fn advertises_detached_and_attached_travel() -> Result<(), Box<dyn std::error::Error>> {
         let selected = gix::ObjectId::Sha1([1; 20]);
         let head = gix::ObjectId::Sha1([2; 20]);
         let mut app = App::new(2);
@@ -3505,6 +3512,7 @@ mod tests {
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
+        app.set_worktree_branch(Some((head, false)));
         let mut decorations = Decorations::from([
             (
                 selected,
@@ -3531,7 +3539,7 @@ mod tests {
                 }],
             ),
         ]);
-        let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
         app.edit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
@@ -3569,15 +3577,16 @@ mod tests {
             "hiding refs retains resource markers: {row:?}"
         );
         assert!(
-            rendered_line(&terminal, 1)
-                .contains("edit (reword · new · new-empty · fork · d forget · unpin) · enrich · @ return · copy"),
-            "time travel stays outside the active edit prefix"
+            rendered_line(&terminal, 1).contains(
+                "edit (reword · new · new-empty · fork · d forget · unpin) · enrich · @ return · # attach · copy"
+            ),
+            "both travel actions stay outside the active edit prefix"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
+        assert!(rendered_line(&terminal, 1).contains(" · @ travel · # attach · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         app.ref_mode = RefMode::Default;
@@ -3588,6 +3597,7 @@ mod tests {
                 kind: DecorationKind::HeadPinBranch,
             }],
         );
+        app.set_worktree_branch(Some((selected, false)));
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
         assert!(
@@ -3597,6 +3607,28 @@ mod tests {
         assert!(!row.contains("📌"), "the HEAD pin is not an ordinary pin: {row:?}");
         assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
+
+        app.set_worktree_branch(Some((selected, true)));
+        decorations.remove(&head);
+        decorations.insert(
+            selected,
+            vec![
+                Decoration {
+                    name: "HEAD".into(),
+                    kind: DecorationKind::Head,
+                },
+                Decoration {
+                    name: "main".into(),
+                    kind: DecorationKind::HeadPinBranch,
+                },
+            ],
+        );
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let footer = rendered_line(&terminal, 1);
+        assert!(
+            footer.contains(" · # attach · copy") && !footer.contains("@ travel") && !footer.contains("@ return"),
+            "a detached worktree can reattach at its remembered branch tip: {footer}"
+        );
         Ok(())
     }
 

From b8e73e348784219c92ccfeb99c2eaed06939e665 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 19:36:20 +0200
Subject: [PATCH 218/282] feat: add two-step TUI squash

Add an edit shortcut that selects an eligible ancestor and folds the current commit into it through the existing rebase-plan machinery. Preserve intermediate forks and attached branches, and reuse materialized conflict continuation.
---
 gix-tix/spec.md            |   6 +-
 gix-tix/src/app.rs         | 154 +++++++++++++++++++++-
 gix-tix/src/edit/rebase.rs | 262 +++++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs         |  59 +++++++++
 gix-tix/src/ui.rs          |   3 +
 5 files changed, 476 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a5295158563..061b35d9fac 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1003,7 +1003,11 @@ space first; changes blocks adapt within the remaining history width.
   `e u` rebases it onto the newer hidden branch tip when available,
   `e o` rewords, `e n` creates a rebased child, `e f` forks an independent child,
   `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
-  and `e d d` confirms forgetting a top commit when each action is available.
+  `e q` squashes the selected commit, and `e d d` confirms forgetting a top commit when each action is available.
+- Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
+  target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
+  and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
+  forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
 - `@` and `#` invoke detached and attached time travel directly, outside the edit
   group. Invoking either leaves an already expanded edit group open.
 - Edit shortcuts keep the group open. Navigation or another recognized command
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index be12e70a0e6..598a5a4d593 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -375,6 +375,7 @@ pub(crate) enum Action {
     Forget,
     Rebase,
     RebaseUpdate,
+    Squash,
     Review,
     TimeTravel,
     AttachedTimeTravel,
@@ -414,6 +415,10 @@ pub(crate) enum Effect {
         onto: ObjectId,
         commits: Vec<ObjectId>,
     },
+    Squash {
+        source: ObjectId,
+        target: ObjectId,
+    },
     StartReview {
         tip: ObjectId,
         base: ObjectId,
@@ -508,6 +513,7 @@ pub(crate) struct App {
     reachability_anchor: Option<ObjectId>,
     review_tip: Option<ObjectId>,
     review_return: Option<(ObjectId, ObjectId)>,
+    squash_source: Option<ObjectId>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
@@ -606,6 +612,7 @@ impl App {
             reachability_anchor: None,
             review_tip: None,
             review_return: None,
+            squash_source: None,
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
@@ -713,6 +720,8 @@ impl App {
             Some("review return is missing · j/k select commit · <enter> finish detached · Esc cancel")
         } else if self.review_selection_active() {
             Some("review base · j/k select ancestor · <enter> start · Esc cancel")
+        } else if self.squash_selection_active() {
+            Some("squash target · j/k select ancestor · <enter> squash · Esc cancel")
         } else if self.forget_confirmation_visible() {
             Some("forget commit · d again confirm · any other action cancel")
         } else {
@@ -1042,6 +1051,7 @@ impl App {
                 | Action::Forget
                 | Action::Rebase
                 | Action::RebaseUpdate
+                | Action::Squash
                 | Action::Review
                 | Action::TimeTravel
                 | Action::AttachedTimeTravel
@@ -1261,7 +1271,7 @@ impl App {
                 else {
                     return Vec::new();
                 };
-                self.clear_review_selection();
+                self.clear_reachability_selection();
                 return vec![Effect::FinishReview {
                     review,
                     return_to: Some(return_to),
@@ -1273,10 +1283,23 @@ impl App {
                     return Vec::new();
                 };
                 if base != tip && self.selected.is_some_and(|index| self.is_row_reachable(index)) {
-                    self.clear_review_selection();
+                    self.clear_reachability_selection();
                     return vec![Effect::StartReview { tip, base }];
                 }
             }
+            Action::OpenDiff if self.squash_source.is_some() => {
+                let source = self.squash_source.expect("squash selection has a source");
+                let Some(target) = self
+                    .selected
+                    .filter(|index| self.is_row_reachable(*index) && self.reachable_row_selectable(*index))
+                    .and_then(|index| self.rows.get(index))
+                    .map(|row| row.id)
+                else {
+                    return Vec::new();
+                };
+                self.clear_reachability_selection();
+                return vec![Effect::Squash { source, target }];
+            }
             Action::OpenDiff => {
                 if let Some(target) = self.selected_tree_diff_target() {
                     return vec![Effect::OpenCommitDiff(target)];
@@ -1353,6 +1376,24 @@ impl App {
                     commits: self.hidden_descendants(base),
                 }];
             }
+            Action::Squash if self.can_squash() => {
+                let source = self.rows[self.selected.expect("squash requires a selection")].id;
+                self.squash_source = Some(source);
+                self.reachability_anchor = Some(source);
+                self.compute_reachable_rows();
+                let mut targets = self
+                    .rows
+                    .iter()
+                    .enumerate()
+                    .filter(|(index, row)| {
+                        row.id != source && self.is_row_reachable(*index) && self.reachable_row_selectable(*index)
+                    })
+                    .map(|(_, row)| row.id);
+                if let Some(target) = targets.next().filter(|_| targets.next().is_none()) {
+                    self.clear_reachability_selection();
+                    return vec![Effect::Squash { source, target }];
+                }
+            }
             Action::Review if self.can_finish_review() => {
                 return vec![Effect::FinishReview {
                     review: self.rows[self.selected.expect("finishing review requires a selection")].id,
@@ -1373,7 +1414,7 @@ impl App {
                     })
                     .map(|(_, row)| row.id);
                 if let Some(base) = bases.next().filter(|_| bases.next().is_none()) {
-                    self.clear_review_selection();
+                    self.clear_reachability_selection();
                     return vec![Effect::StartReview { tip, base }];
                 }
             }
@@ -1430,8 +1471,10 @@ impl App {
                 }
             }
             Action::ForceQuit => return vec![Effect::Quit],
-            Action::Cancel if self.review_tip.is_some() || self.review_return.is_some() => {
-                self.clear_review_selection()
+            Action::Cancel
+                if self.review_tip.is_some() || self.review_return.is_some() || self.squash_source.is_some() =>
+            {
+                self.clear_reachability_selection();
             }
             Action::Cancel | Action::Quit if self.changes_focus.is_some() => self.focus_history(),
             Action::Cancel if self.state == State::Loading => {
@@ -1758,7 +1801,7 @@ impl App {
         self.pending_initial_selection = None;
         self.selection_after_refresh = None;
         self.update_worktree_head_descendants();
-        self.clear_review_selection();
+        self.clear_reachability_selection();
         self.signature_failures = 0;
         self.signature_verification_running = false;
     }
@@ -1793,9 +1836,10 @@ impl App {
         self.ensure_changes_visible();
     }
 
-    fn clear_review_selection(&mut self) {
+    fn clear_reachability_selection(&mut self) {
         self.review_tip = None;
         self.review_return = None;
+        self.squash_source = None;
         self.reachability_anchor = None;
         self.reachable_rows = None;
     }
@@ -1951,6 +1995,13 @@ impl App {
     }
 
     fn reachable_row_selectable(&self, index: usize) -> bool {
+        if self.squash_source.is_some() {
+            return self
+                .rows
+                .get(index)
+                .is_some_and(|row| Some(row.id) != self.squash_source)
+                && self.is_squash_target(index);
+        }
         !self.is_row_hidden(index)
             || (self.review_tip.is_some()
                 && self
@@ -1959,6 +2010,12 @@ impl App {
                     .is_some_and(|row| self.hidden_rebase_bases.contains(&row.id)))
     }
 
+    fn is_squash_target(&self, index: usize) -> bool {
+        self.rows.get(index).is_some_and(|row| {
+            !self.is_row_hidden(index) && row.parent_ids.len() == 1 && !self.known_merge_descendants.contains(&row.id)
+        })
+    }
+
     fn select(&mut self, selected: usize) {
         self.pending_initial_selection = None;
         if !self.rows.is_empty() {
@@ -2075,6 +2132,25 @@ impl App {
                 .is_some_and(|row| self.hidden_branch_updates.contains_key(&row.id))
     }
 
+    pub(crate) fn can_squash(&self) -> bool {
+        self.state == State::Complete
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self
+                .selected
+                .and_then(|index| self.rows.get(index))
+                .is_some_and(|source| {
+                    !self.hidden_rows.contains(&source.id)
+                        && source.parent_ids.len() == 1
+                        && !self.known_merge_descendants.contains(&source.id)
+                        && self.rows.iter().enumerate().any(|(index, target)| {
+                            target.id != source.id
+                                && self.is_squash_target(index)
+                                && self.is_known_ancestor(target.id, source.id)
+                        })
+                })
+    }
+
     pub(crate) fn can_review(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -2107,6 +2183,10 @@ impl App {
         self.review_tip.is_some()
     }
 
+    pub(crate) fn squash_selection_active(&self) -> bool {
+        self.squash_source.is_some()
+    }
+
     pub(crate) fn review_return_selection_active(&self) -> bool {
         self.review_return.is_some()
     }
@@ -3595,6 +3675,66 @@ mod tests {
         assert!(!app.review_selection_active());
     }
 
+    #[test]
+    fn squash_selects_a_visible_strict_ancestor_and_can_be_cancelled() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(6, &[1]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(5));
+
+        assert!(app.can_squash());
+        assert!(app.update(Action::Squash).is_empty());
+        assert!(app.squash_selection_active());
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(3)));
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("squash target · j/k select ancestor · <enter> squash · Esc cancel".into())
+        );
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::Squash {
+                source: id(5),
+                target: id(3),
+            }]
+        );
+        assert!(!app.squash_selection_active());
+
+        app.selected = app.rows.iter().position(|row| row.id == id(5));
+        assert!(app.update(Action::Squash).is_empty());
+        assert!(app.update(Action::Cancel).is_empty());
+        assert!(!app.squash_selection_active());
+    }
+
+    #[test]
+    fn squash_starts_immediately_with_one_eligible_target() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(3));
+
+        assert_eq!(
+            app.update(Action::Squash),
+            vec![Effect::Squash {
+                source: id(3),
+                target: id(2),
+            }]
+        );
+        assert!(!app.squash_selection_active());
+
+        app.hidden_rows.insert(id(2));
+        assert!(!app.can_squash(), "hidden commits cannot be squash targets");
+    }
+
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 530a57a85d3..0069d53ff2d 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -431,6 +431,109 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
     Ok(out)
 }
 
+pub(crate) fn squash_plan(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    source: ObjectId,
+    target: ObjectId,
+) -> Result<Plan> {
+    if source == target || !graph.is_ancestor(target, source) {
+        anyhow::bail!("the squash target must be a strict ancestor of the source");
+    }
+    let source_parents = graph
+        .parents_of(source)
+        .context("the squash source is not in the loaded history")?;
+    let [source_parent] = source_parents.as_slice() else {
+        anyhow::bail!("the squash source must have exactly one parent");
+    };
+    let source_parent = *source_parent;
+    let target_parents = graph
+        .parents_of(target)
+        .context("the squash target is not in the loaded history")?;
+    let [base] = target_parents.as_slice() else {
+        anyhow::bail!("the squash target must have exactly one parent");
+    };
+    let base = *base;
+    let scope = graph
+        .descendants_in_parent_order(target)
+        .context("the squash target is not in the loaded history")?;
+    let scope_set: HashSet<_> = scope.iter().copied().collect();
+    let mut non_leaves = HashSet::new();
+    for id in &scope {
+        let parents = graph
+            .parents_of(*id)
+            .context("an affected squash commit is incomplete")?;
+        if parents.len() > 1 {
+            anyhow::bail!("descendant merge commits cannot be squashed");
+        }
+        non_leaves.extend(parents.into_iter().filter(|parent| scope_set.contains(parent)));
+    }
+    let tips: Vec<_> = scope.iter().copied().filter(|id| !non_leaves.contains(id)).collect();
+    let mut steps = Vec::with_capacity(scope.len().saturating_sub(1));
+    let mut step_by_id = HashMap::new();
+    for id in scope.iter().copied().filter(|id| *id != source) {
+        let original_parent = graph
+            .parents_of(id)
+            .and_then(|parents| parents.first().copied())
+            .context("an affected squash commit has no parent")?;
+        let parent = if original_parent == source {
+            source_parent
+        } else {
+            original_parent
+        };
+        let parent = step_by_id
+            .get(&parent)
+            .copied()
+            .map_or(PlanParent::Existing(parent), PlanParent::Step);
+        let index = steps.len();
+        steps.push(PlanStep {
+            parent,
+            commit: PlanCommit::Pick(id),
+            squash: (id == target).then_some(source).into_iter().collect(),
+        });
+        step_by_id.insert(id, index);
+    }
+    let target_step = *step_by_id.get(&target).context("the squash target has no plan step")?;
+    step_by_id.insert(source, target_step);
+
+    let mut expected_refs = capture_refs(repo, &scope, &tips)?;
+    let source_tip_target = PlanParent::Step(step_by_id[&source_parent]);
+    for expected in &mut expected_refs {
+        if expected.target == source && expected.follows_tip {
+            expected.placement = Some(source_tip_target);
+        }
+    }
+    let head = repo.head()?;
+    let checkout = head
+        .id()
+        .map(gix::Id::detach)
+        .filter(|id| scope_set.contains(id))
+        .map(|id| {
+            let reference = head
+                .referent_name()
+                .filter(|name| name.category() == Some(Category::LocalBranch))
+                .map(ToOwned::to_owned);
+            let target = reference
+                .as_ref()
+                .and_then(|name| {
+                    expected_refs
+                        .iter()
+                        .find(|expected| expected.name == *name)
+                        .and_then(|expected| expected.placement)
+                })
+                .unwrap_or(PlanParent::Step(step_by_id[&id]));
+            PlanCheckout { target, reference }
+        });
+
+    Ok(Plan {
+        base,
+        scope,
+        steps,
+        checkout,
+        expected_refs,
+    })
+}
+
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
 pub(crate) fn perform(
     repo: &gix::Repository,
@@ -2806,6 +2909,46 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_conflicting_squash_plan_produces_a_materializable_continuation() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        std::fs::write(fixture.path().join("file"), b"source\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-qam", "source"])
+                .status()?
+                .success()
+        );
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("HEAD~2")?.detach();
+        let source = repo.head_id()?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let PlanPerform::Conflict(conflict) = perform_plan(&repo, &graph, squash_plan(&repo, &graph, source, target)?)?
+        else {
+            return Err("the non-adjacent squash should suspend on its conflicting source delta".into());
+        };
+        assert_eq!(conflict.original(), source);
+        assert!(
+            conflict
+                .continuation_plan()
+                .steps
+                .iter()
+                .any(|step| matches!(step.commit, PlanCommit::Resolved(_))),
+            "the ordinary todo continuation can resume the squash"
+        );
+        drop(conflict);
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "an unmaterialized squash conflict leaves the repository unchanged"
+        );
+        Ok(())
+    }
+
     #[test]
     fn a_todo_rebase_eagerly_replays_only_the_checkout_ancestry_and_keeps_the_branch_at_the_leaf()
     -> gix_testtools::Result {
@@ -3091,6 +3234,125 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn squash_plan_moves_a_non_adjacent_source_into_its_target() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        std::fs::write(fixture.path().join("upper"), b"upper\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "upper"])
+                .status()?
+                .success(),
+            "the extra source file is staged"
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "-m", "upper"])
+                .status()?
+                .success(),
+            "the non-adjacent squash source is committed"
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "-b", "side", "HEAD~2"])
+                .status()?
+                .success(),
+            "a sibling branch starts at the squash target"
+        );
+        std::fs::write(fixture.path().join("side"), b"side\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["add", "side"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "-m", "side"])
+                .status()?
+                .success()
+        );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "main"])
+                .status()?
+                .success()
+        );
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("HEAD~2")?.detach();
+        let intermediate = repo.rev_parse_single("HEAD~1")?.detach();
+        let source = repo.head_id()?.detach();
+        let side = repo.rev_parse_single("side")?.detach();
+
+        let plan = squash_plan(&repo, &graph, source, target)?;
+        assert_eq!(plan.steps.len(), 3, "the source becomes part of the target step");
+        let step_for = |id| {
+            plan.steps
+                .iter()
+                .position(|step| step.commit == PlanCommit::Pick(id))
+                .expect("the retained commit has a plan step")
+        };
+        let target_step = step_for(target);
+        let intermediate_step = step_for(intermediate);
+        let side_step = step_for(side);
+        assert_eq!(plan.steps[target_step].squash, [source]);
+        assert_eq!(plan.steps[intermediate_step].parent, PlanParent::Step(target_step));
+        assert_eq!(plan.steps[side_step].parent, PlanParent::Step(target_step));
+        assert_eq!(
+            plan.checkout.as_ref().map(|checkout| checkout.target),
+            Some(PlanParent::Step(intermediate_step)),
+            "the attached tip follows the reordered stack"
+        );
+
+        let outcome = perform_plan(&repo, &graph, plan)?.complete()?;
+        let combined = outcome.map(target).context("the squash target is retained")?;
+        assert_eq!(
+            outcome.map(source),
+            Some(combined),
+            "the source maps to the combined commit"
+        );
+        let rewritten_intermediate = outcome
+            .map(intermediate)
+            .context("the intermediate commit is retained")?;
+        assert_eq!(
+            repo.find_commit(rewritten_intermediate)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(combined),
+            "the intermediate commit remains above the combined result"
+        );
+        assert_eq!(
+            repo.head_id()?.detach(),
+            rewritten_intermediate,
+            "the attached branch remains at the final reordered tip"
+        );
+        let rewritten_side = outcome.map(side).context("the sibling branch is retained")?;
+        assert_eq!(
+            repo.find_commit(rewritten_side)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(combined),
+            "a sibling fork remains attached to the rewritten target"
+        );
+        assert_eq!(repo.find_reference("refs/heads/side")?.id().detach(), rewritten_side);
+        Ok(())
+    }
+
     #[test]
     fn a_squash_group_reports_one_configured_signature() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index acaa14f5461..73f6426589b 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2504,6 +2504,63 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("rebase: {err:#}")),
                     }
                 }
+                Effect::Squash { source, target } => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = (|| {
+                        let graph = history_graph
+                            .as_ref()
+                            .context("squashing requires a completed history graph")?;
+                        let mut repository = open_repository(&repository_path, repository_is_bare, false)
+                            .context("could not open repository to squash commits")?;
+                        repository.object_cache_size(None);
+                        let plan = edit::rebase::squash_plan(&repository, graph, source, target)?;
+                        run_rebase_plan(terminal, repository.into_sync(), graph, plan)
+                    })();
+                    match result {
+                        Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
+                            let combined = outcome.map(target).unwrap_or(target);
+                            let notice = if outcome.selected.is_some() {
+                                edit::time_travel::checkout_plan(
+                                    &repository_path,
+                                    repository_is_bare,
+                                    &outcome,
+                                    &revisions,
+                                    false,
+                                )
+                            } else {
+                                Ok(None)
+                            };
+                            match notice {
+                                Ok(notice) => app.leave_success(notice.unwrap_or_else(|| {
+                                    format!(
+                                        "squashed {} into {}",
+                                        source.to_hex_with_len(7),
+                                        combined.to_hex_with_len(7)
+                                    )
+                                })),
+                                Err(err) => app.leave_attention(format!("squash applied, checkout failed: {err:#}")),
+                            }
+                            app.select_commit_after_refresh(combined);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Ok(edit::rebase::PlanPerform::Conflict(conflict)) => {
+                            let id = conflict.commit();
+                            preview_todo_rebase_conflict(
+                                &mut app,
+                                &conflict,
+                                &authors,
+                                &ref_snapshot.view_tips,
+                                &ref_snapshot.hidden_tips,
+                            )?;
+                            app.arm_rebase_conflict(id);
+                            app.select_commit(id);
+                            pending_todo_rebase_conflict = Some(conflict);
+                        }
+                        Err(err) => app.leave_error(format!("squash: {err:#}")),
+                    }
+                }
                 Effect::StartReview { tip, base } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -5027,6 +5084,7 @@ fn action_with_shortcut_groups(
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
         KeyCode::Char('c') => Some(Action::ToggleChanges),
         KeyCode::Char('p') if edit_expanded => Some(Action::Split),
+        KeyCode::Char('q') if edit_expanded => Some(Action::Squash),
         KeyCode::Char('b') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
         KeyCode::Char('u') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::RebaseUpdate)
@@ -6327,6 +6385,7 @@ mod tests {
             ('h', Action::Stash),
             ('s', Action::Spill),
             ('p', Action::Split),
+            ('q', Action::Squash),
             ('d', Action::Forget),
             ('i', Action::TogglePin),
         ] {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 96fc2bca996..8f09c0e5a3c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1013,6 +1013,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_split() {
                 options.push(("split", 'p'));
             }
+            if app.can_squash() {
+                options.push(("squash", 'q'));
+            }
             if app.changes_focus.is_none() && app.can_forget() {
                 options.push(("d forget", 'd'));
             }

From b030577e7a44c0804d3ccdbde0e0a2574f286aa5 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 20:24:57 +0200
Subject: [PATCH 219/282] fix: update history change IDs atomically

Scan change IDs after lane computation and before publishing replacement rows. Keep the current projection metadata visible during refresh, then install rows and duplicate markers together.
---
 gix-tix/spec.md          |  5 +--
 gix-tix/src/app.rs       | 25 +++++++++++++-
 gix-tix/src/change_id.rs | 12 +++----
 gix-tix/src/lib.rs       | 74 +++++++++++-----------------------------
 4 files changed, 51 insertions(+), 65 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 061b35d9fac..ef425457af4 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1091,8 +1091,9 @@ space first; changes blocks adapt within the remaining history width.
   must drop their repository when finished. Lane, verification, and line-diff
   workers exist only for active work and do not form persistent pools.
 - Change IDs are scanned only while configured hidden tips are actively excluded.
-  Unrestricted and explicitly expanded views perform no scan; expanding or
-  refreshing a view cancels any scan for its previous projection.
+  Unrestricted and explicitly expanded views perform no scan. A refresh keeps
+  the current projection's IDs until it has synchronously scanned the replacement,
+  then publishes rows, IDs, duplicate markers, and gutter width together.
 - Redraw is reactive and capped at approximately 60 frames per second while
   streaming. Mouse events are drained and coalesced in bounded batches so input
   storms cannot starve the main loop.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 598a5a4d593..231e8417bdf 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -683,6 +683,7 @@ impl App {
         self.duplicate_change_ids = duplicates;
     }
 
+    #[cfg(test)]
     fn clear_change_ids(&mut self) {
         self.change_ids.clear();
         self.duplicate_change_ids.clear();
@@ -1642,7 +1643,6 @@ impl App {
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
         self.forget_confirmation = None;
-        self.clear_change_ids();
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -3002,6 +3002,29 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_keeps_change_ids_until_the_replacement_projection_is_ready() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        let change_id = ChangeId::from(id(9));
+        app.set_change_ids(HashMap::from([(id(2), change_id)]), HashSet::from([id(1), id(2)]));
+
+        let _rows = app
+            .start_refresh(vec![row_with_parents(3, &[2])].into(), &[id(3)], &[], false)
+            .expect("the refresh starts lane computation");
+
+        assert_eq!(
+            app.change_id(id(2)),
+            change_id,
+            "the current frame retains its change ID during refresh"
+        );
+        assert!(
+            app.has_duplicate_change_id(id(1)) && app.has_duplicate_change_id(id(2)),
+            "the duplicate gutter remains stable until rows and IDs are replaced together"
+        );
+    }
+
     #[test]
     fn ref_tree_pin_refresh_adds_cached_branch_ancestry_and_selects_its_tip() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/change_id.rs b/gix-tix/src/change_id.rs
index 05d29e3f911..c317086b767 100644
--- a/gix-tix/src/change_id.rs
+++ b/gix-tix/src/change_id.rs
@@ -1,7 +1,6 @@
 use std::{
     cmp::Ordering as CmpOrdering,
     collections::{HashMap, HashSet},
-    sync::atomic::{AtomicBool, Ordering},
 };
 
 use anyhow::{Context, Result};
@@ -117,19 +116,17 @@ fn store(commit: &mut gix::objs::Commit, change_id: ChangeId) {
         .push((HEADER.into(), BString::from(change_id.to_string())));
 }
 
+#[derive(Default)]
 pub(crate) struct Scan {
     pub overrides: HashMap<ObjectId, ChangeId>,
     pub duplicates: HashSet<ObjectId>,
 }
 
-pub(crate) fn scan(repo: &gix::Repository, ids: &[ObjectId], cancelled: &AtomicBool) -> Result<Option<Scan>> {
+pub(crate) fn scan(repo: &gix::Repository, ids: &[ObjectId]) -> Result<Scan> {
     let mut overrides = HashMap::new();
     let mut first_by_change = HashMap::new();
     let mut duplicates = HashSet::new();
     for &id in ids {
-        if cancelled.load(Ordering::Relaxed) {
-            return Ok(None);
-        }
         let object = repo
             .find_commit(id)
             .context("could not read commit while scanning change IDs")?;
@@ -145,7 +142,7 @@ pub(crate) fn scan(repo: &gix::Repository, ids: &[ObjectId], cancelled: &AtomicB
             duplicates.insert(id);
         }
     }
-    Ok(Some(Scan { overrides, duplicates }))
+    Ok(Scan { overrides, duplicates })
 }
 
 #[cfg(test)]
@@ -243,8 +240,7 @@ mod tests {
             "later rewrites inherit the stored identity from their predecessor"
         );
 
-        let scan =
-            scan(&repo, &[predecessor, duplicate], &AtomicBool::new(false))?.expect("the scan was not cancelled");
+        let scan = scan(&repo, &[predecessor, duplicate])?;
         assert_eq!(
             scan.duplicates,
             HashSet::from([predecessor, duplicate]),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 73f6426589b..25c7c0cdbe3 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -74,17 +74,6 @@ struct FillRepository {
     retain: bool,
 }
 
-struct ChangeIdWorker {
-    cancelled: Arc<AtomicBool>,
-    results: mpsc::Receiver<Result<Option<change_id::Scan>>>,
-}
-
-impl Drop for ChangeIdWorker {
-    fn drop(&mut self) {
-        self.cancelled.store(true, Ordering::Relaxed);
-    }
-}
-
 struct WorktreeWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
@@ -922,7 +911,7 @@ fn event_loop(
     if recovered_at_startup {
         app.leave_attention("worktree removed; using the common repository without worktree changes");
     }
-    let mut lane_receiver = None;
+    let mut lane_receiver: Option<mpsc::Receiver<(Vec<SharedCommitRow>, app::Graph, Duration)>> = None;
     let mut refresh_receiver: Option<mpsc::Receiver<(RefreshKind, HistoryGraph, Result<history::Refresh>)>> = None;
     let mut refresh_pending = false;
     let mut ref_tree_refresh_pending = false;
@@ -931,7 +920,6 @@ fn event_loop(
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
-    let mut change_id_worker: Option<ChangeIdWorker> = None;
     let mut commit_message = None;
     let mut tree_changes = TreeChangesCache::default();
     let mut worktree_changes = None;
@@ -1240,29 +1228,17 @@ fn event_loop(
                 }
             }
         }
-        if let Some(result) = change_id_worker.as_ref().map(|worker| worker.results.try_recv()) {
-            match result {
-                Ok(Ok(Some(scan))) => {
-                    app.set_change_ids(scan.overrides, scan.duplicates);
-                    change_id_worker = None;
-                    dirty = true;
-                }
-                Ok(Ok(None)) => change_id_worker = None,
-                Ok(Err(err)) => {
-                    tracing::warn!(error = %err, "change ID scan failed");
-                    change_id_worker = None;
-                }
-                Err(mpsc::TryRecvError::Empty) => {}
-                Err(mpsc::TryRecvError::Disconnected) => {
-                    tracing::warn!("change ID scan worker stopped unexpectedly");
-                    change_id_worker = None;
-                }
-            }
-        }
         if let Some(result) = lane_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
                 Ok((rows, graph, lane_time)) => {
+                    let scan =
+                        scan_change_ids(&repository_path, repository_is_bare, change_id_scan_needed(&app), &rows)
+                            .unwrap_or_else(|err| {
+                                tracing::warn!(error = %err, "change ID scan failed");
+                                change_id::Scan::default()
+                            });
                     app.finish_lane_computation(rows, graph, lane_time);
+                    app.set_change_ids(scan.overrides, scan.duplicates);
                     ref_tree.set_history_commits(app.rows.iter().map(|row| row.id));
                     if return_to_history_after_refresh.take().is_some() {
                         ref_tree.leave();
@@ -1281,13 +1257,6 @@ fn event_loop(
                     if quit_on_finish {
                         return Ok(app.lane_time);
                     }
-                    if change_id_scan_needed(&app) {
-                        change_id_worker = Some(start_change_id_scan(
-                            repository_path.clone(),
-                            repository_is_bare,
-                            app.rows.iter().map(|row| row.id).collect(),
-                        ));
-                    }
                 }
                 Err(mpsc::TryRecvError::Empty) => {}
                 Err(mpsc::TryRecvError::Disconnected) => {
@@ -1376,7 +1345,6 @@ fn event_loop(
             && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
-            change_id_worker = None;
             ref_tree_refresh_pending = false;
             refresh_receiver = Some(start_history_refresh(
                 repository_path.clone(),
@@ -1400,7 +1368,6 @@ fn event_loop(
             && history_graph.is_some()
             && matches!(app.state, State::Complete | State::Cancelled)
         {
-            change_id_worker = None;
             let refresh_started = Instant::now();
             let response_ids = filesystem_responses.begin_reference_refresh();
             let repository = match open_repository(&repository_path, repository_is_bare, true) {
@@ -2090,7 +2057,6 @@ fn event_loop(
                     execute!(terminal.backend_mut(), CopyToClipboard::to_clipboard_from(actor))?;
                 }
                 Effect::Reload(show_hidden) => {
-                    change_id_worker = None;
                     app.show_hidden = show_hidden;
                     refresh_pending = true;
                     refresh_expand_hidden = true;
@@ -2786,18 +2752,18 @@ fn start_lane_worker(rows: Vec<SharedCommitRow>) -> mpsc::Receiver<(Vec<SharedCo
     receiver
 }
 
-fn start_change_id_scan(repository_path: PathBuf, bare: bool, ids: Vec<gix::ObjectId>) -> ChangeIdWorker {
-    let cancelled = Arc::new(AtomicBool::new(false));
-    let worker_cancelled = Arc::clone(&cancelled);
-    let (sender, results) = mpsc::channel();
-    std::thread::spawn(move || {
-        let result = open_repository(&repository_path, bare, false).and_then(|mut repository| {
-            repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
-            change_id::scan(&repository, &ids, &worker_cancelled)
-        });
-        let _ = sender.send(result);
-    });
-    ChangeIdWorker { cancelled, results }
+fn scan_change_ids(
+    repository_path: &Path,
+    bare: bool,
+    enabled: bool,
+    rows: &[SharedCommitRow],
+) -> Result<change_id::Scan> {
+    if !enabled {
+        return Ok(change_id::Scan::default());
+    }
+    let mut repository = open_repository(repository_path, bare, false)?;
+    repository.object_cache_size_if_unset(OBJECT_CACHE_SIZE);
+    change_id::scan(&repository, &rows.iter().map(|row| row.id).collect::<Vec<_>>())
 }
 
 fn change_id_scan_needed(app: &App) -> bool {

From eed27246444f1beb6da2ca3ddde421930b979f02 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 21:35:27 +0200
Subject: [PATCH 220/282] change!: reorganize TUI commit and action prefixes

Use c for commit-producing and commit-editing operations, and move review and squash into a separate a actions group. Scope the changes toggle to the information prefix and remove the obsolete independent fork-commit action and its unused implementation.
---
 gix-tix/spec.md            |  87 +++++++--------
 gix-tix/src/app.rs         |  82 ++++++--------
 gix-tix/src/edit/create.rs | 148 --------------------------
 gix-tix/src/edit/rebase.rs |  50 +++------
 gix-tix/src/lib.rs         | 213 ++++++++++++++++++-------------------
 gix-tix/src/ui.rs          | 141 +++++++++++++++---------
 6 files changed, 276 insertions(+), 445 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ef425457af4..45d7da09fec 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -38,7 +38,7 @@ without trading responsiveness for metadata that is not visible.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
-  worktree-safety rules as `e n`. By default a changed index wins and tracked
+  worktree-safety rules as `c n`. By default a changed index wins and tracked
   worktree changes are used only when the index is unchanged. `--index` uses
   only the index delta; `--worktree` applies only unstaged tracked-worktree
   changes to the `HEAD` tree and omits staged-only changes. `--worktree-untracked`
@@ -357,7 +357,7 @@ without trading responsiveness for metadata that is not visible.
 | `Ctrl-u`/`Ctrl-d` | Move half a page. |
 | `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
-| `?` | Toggle the information key group. Its actions remain direct shortcuts. |
+| `?` | Toggle the information key group. |
 | `t` | Toggle the rounded ref-tree overview. |
 | `[` | Cycle viewport-local title alignment, full-column alignment, and no alignment. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
@@ -370,7 +370,7 @@ without trading responsiveness for metadata that is not visible.
 | `v h` | Show or hide configured hidden ancestry. |
 | `r` | Hide reference labels or restore the mode visible when they were hidden. |
 | `m`/`]` | Toggle the commit-message view. |
-| `c` | Cycle the tree/worktree changes display. |
+| `? c` | Cycle the tree/worktree changes display. |
 | `Shift-R` | Explicitly refresh the revision view and visible worktree status. |
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
@@ -385,8 +385,7 @@ full-column alignment so clipped fields can be reached.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
-for signature verification, alignment, message, and changes actions, but these
-actions retain their direct shortcuts while the group is closed. While expanded,
+for signature verification, alignment, message, and changes actions. While expanded,
 the group visually contains every following status action through `<enter> diff`,
 including pane switching and navigation; none of those hints is visible while
 the group is closed, and quit remains outside it. The footer underlines the `v`
@@ -394,9 +393,9 @@ in `view`; an open prefix reverses its complete expanded group for a strong,
 terminal-theme-independent cue. While active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
-`v` prefix and the `e` prefix when it is addressable. Remaining history-level
+`v`, `c`, and `a` prefixes when they are addressable. Remaining history-level
 actions end at the information prefix while it is closed. Available direct
-detached and attached time-travel actions follow the edit group beside each other,
+detached and attached time-travel actions follow the shortcut groups beside each other,
 and duplicate cycling follows them when
 the selected commit has duplicates, and copy follows these actions; the reference toggle immediately precedes
 the `?` group; quit is always last.
@@ -461,7 +460,7 @@ The Enter key is written as `<enter>` throughout.
   style. It has no `📌`, is never selected as a return destination, and does not
   offer `unpin`; its branch keeps normal tracking-relation behavior.
 - The edit menu offers `pin` on an unpinned row and `unpin` on a pinned row,
-  both on `e i`. Pin creates or reuses a direct current-worktree pin for the
+  both on `c i`. Pin creates or reuses a direct current-worktree pin for the
   selected commit. Unpin atomically removes every non-HEAD pin for that commit;
   both operations retain that row's selection.
 - `tix pin <REVSPEC>...` resolves every argument before writing and deduplicates
@@ -638,12 +637,12 @@ space first; changes blocks adapt within the remaining history width.
 
 ### New commits
 
-- `e n` creates a child of the selected commit from tracked changes, or a root
+- `c n` creates a child of the selected commit from tracked changes, or a root
   commit for an unborn `HEAD`. A changed index wins; otherwise, tracked worktree
   changes are used. Untracked files never enter an implicit new commit and remain
   untracked. It is available only with a live worktree, after history completion,
   and when the selected parent has no known merge descendant.
-- `e m` creates an explicit empty commit which reuses the selected parent's tree,
+- `c m` creates an explicit empty commit which reuses the selected parent's tree,
   or the empty tree for an unborn history. Existing index and worktree state is
   preserved exactly. Both forms reject unresolved index conflicts.
 - A current worktree-changes cache controls which actions are advertised without
@@ -670,24 +669,10 @@ space first; changes blocks adapt within the remaining history width.
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
   inaccessible or conflicting affected worktrees abort safely.
 
-### Fork commits
-
-- `e f` creates an independent child of any selected commit, including a hidden
-  boundary or merge commit. It requires completed history and a live,
-  conflict-free worktree, but unlike `e n` it is not restricted by descendants
-  because it rewrites none of them. It is unavailable for unborn history.
-- Fork preparation reuses the new-commit editor, candidate-tree, identity,
-  signing, and enrichment-header rules. Saving writes only the new commit and a temporary direct
-  `refs/worktree/tix/pins/*` ref; existing refs, descendants, indexes, and
-  worktrees do not move during creation.
-- Tix immediately time-travels to the new fork. A successful checkout consumes
-  its temporary pin and reconciles the departed `HEAD` through the standard pin
-  primitive. If checkout fails, the fork remains pinned and visible.
-
 ### Amend, spill, and split
 
-- `e a` amends the current worktree's `@` commit with the changed index, or
-  worktree changes when the index already matches `HEAD`. `e s` spills that
+- `c a` amends the current worktree's `@` commit with the changed index, or
+  worktree changes when the index already matches `HEAD`. `c s` spills that
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
   unavailable and report a no-op through `tix amend|spill`.
@@ -704,17 +689,17 @@ space first; changes blocks adapt within the remaining history width.
   IDs use the same seven-character display as other command results. Ref
   creations, deletions, unchanged refs, and unreferenced replayed commits add no
   mapping line.
-- With a path selected in the focused tree-changes block, the main `e` prefix
-  offers `spill` and `e s` spills only that path against the displayed parent.
+- With a path selected in the focused tree-changes block, the main `c` prefix
+  offers `spill` and `c s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
-- With a path selected in the focused worktree-changes block, the main `e`
-  prefix offers `amend` and `e a` amends only that path. A staged row uses its
+- With a path selected in the focused worktree-changes block, the main `c`
+  prefix offers `amend` and `c a` amends only that path. A staged row uses its
   index version; an unstaged row uses its filtered worktree version. If both
   rows exist for one path, the selected row determines the version. Review
   commits accept only staged rows, and unresolved indexes cannot be amended.
   Unrelated staged entries retain their index state. The CLI intentionally
   supports only whole-commit amending.
-- `e p` is offered at `@` only when both staged and unstaged changes exist. It
+- `c p` is offered at `@` only when both staged and unstaged changes exist. It
   amends the unstaged changes into the source commit, then creates a new upper
   commit from the staged delta using the standard Markdown editor buffer. Both
   deltas are three-way applied in memory before the editor opens, so overlapping
@@ -766,7 +751,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Reviews
 
-- `e v` starts a review from any non-boundary commit without merge descendants.
+- `a r` starts a review from any non-boundary commit without merge descendants.
   If exactly one selectable strict ancestor can be the review base, review starts
   with it immediately. Otherwise tix limits navigation to the selected commit's
   ancestry; the connected hidden base remains selectable, `<enter>` confirms it,
@@ -796,7 +781,7 @@ space first; changes blocks adapt within the remaining history width.
 - At a checked-out review commit, amend is offered only for staged changes and
   consumes only the index tree. It leaves worktree bytes and the review header
   intact, removes signatures, and marks only affected descendants for lazy replay.
-- `e v` finishes a selected review when status is completely clean and the current
+- `a r` finishes a selected review when status is completely clean and the current
   worktree HEAD is the review commit or one of its successors. The
   review commit is inserted after its reviewed tip with its exact tree, review
   header removed, updated committer, and configured signature. Review-side
@@ -871,7 +856,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### History rebase editor
 
-- Selecting an eligible hidden boundary and pressing `e b` opens a Markdown
+- Selecting an eligible hidden boundary and pressing `c b` opens a Markdown
   `.md` todo. Its editable plan is read bottom-to-top like the history view:
   newest commands and refs are highest, and each stack ends in a centered
   `──── fork <id> ────` separator below its oldest command.
@@ -881,7 +866,7 @@ space first; changes blocks adapt within the remaining history width.
   exactly as displayed in history without Markdown escaping. Fork points within the editable tree
   remain plain `fork <id>` separators. Every separator is centered with at least
   four `─` characters per side, and all span the widest editable line.
-- When that boundary shows `⇣N`, `e u` opens the same editor with each base-level
+- When that boundary shows `⇣N`, `c u` opens the same editor with each base-level
   stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
   separator is `fork <id> (updated-base) <title>`, with the raw title exactly as
   shown in history, including `[A]` and `[N]`. The hidden branch
@@ -997,25 +982,27 @@ space first; changes blocks adapt within the remaining history width.
   the file or removing the `tix-rebase-state-v2` comment cancels. Continuation
   todos likewise state that saving unchanged continues the materialized rebase.
 
-### Editing shortcuts
+### Commit and action shortcuts
 
-- `e` toggles the edit shortcut group. `e b` rebases an eligible hidden base and
-  `e u` rebases it onto the newer hidden branch tip when available,
-  `e o` rewords, `e n` creates a rebased child, `e f` forks an independent child,
-  `e a` amends `@`, `e h` stashes changes at `@`, `e s` spills `@`, `e p` splits staged from unstaged changes,
-  `e q` squashes the selected commit, and `e d d` confirms forgetting a top commit when each action is available.
+- `c` toggles the commit shortcut group. `c b` rebases an eligible hidden base and
+  `c u` rebases it onto the newer hidden branch tip when available,
+  `c o` rewords, `c n` creates a rebased child, `c a` amends `@`, `c h` stashes
+  changes at `@`, `c s` spills `@`, `c p` splits staged from unstaged changes,
+  and `c d d` confirms forgetting a top commit when each action is available.
+- `a` toggles the actions shortcut group. `a r` starts or finishes a review and
+  `a s` squashes the selected commit when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
   forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
-- `@` and `#` invoke detached and attached time travel directly, outside the edit
-  group. Invoking either leaves an already expanded edit group open.
-- Edit shortcuts keep the group open. Navigation or another recognized command
-  closes it, matching the `v` display shortcut group. Plain `r` does not mutate
-  the repository, and plain `t` has no action.
-- The footer underlines the `e` in `edit`; while active, `edit (` contains only the
-  actions available for the current selection, followed by `)`. An empty group
-  says `no actions`.
+- `@` and `#` invoke detached and attached time travel directly, outside both
+  groups. Invoking either leaves an already expanded commit group open.
+- Commit and action shortcuts keep their respective group open. Navigation or
+  another recognized command closes it, matching the `v` display shortcut group.
+  Plain `r` does not mutate the repository, and plain `t` has no action.
+- The footer underlines `c` in `commit` and `a` in `actions`; an expanded group
+  contains only the operations available for the current selection. An empty
+  group says `no actions`.
 - While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
   meanings for dates, emails, references, and trailers.
 - The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
@@ -1023,7 +1010,7 @@ space first; changes blocks adapt within the remaining history width.
   `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
   the todo flag, and toggling todo preserves the note. `n g` edits the real Git
   note and remains available when the Tix-specific actions are not. The group is mutually
-  exclusive with the view, edit, and information groups and otherwise follows
+  exclusive with the view, commit, actions, and information groups and otherwise follows
   their closing behavior.
 
 ## Refresh, focus, and diagnostics
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 231e8417bdf..db3a00fbb80 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -352,7 +352,8 @@ pub(crate) enum Action {
     ToggleHidden,
     ToggleHistoryDisplay,
     ToggleRefTree,
-    ToggleEdit,
+    ToggleCommitGroup,
+    ToggleActions,
     ToggleEnrich,
     ToggleTodo,
     EditNote,
@@ -367,7 +368,6 @@ pub(crate) enum Action {
     Reword,
     NewCommit,
     NewEmptyCommit,
-    ForkCommit,
     Amend,
     Stash,
     Spill,
@@ -403,7 +403,6 @@ pub(crate) enum Effect {
         parent: Option<ObjectId>,
         empty: bool,
     },
-    ForkCommit(ObjectId),
     Amend(ObjectId),
     Stash(ObjectId),
     Unstash(ObjectId),
@@ -520,7 +519,8 @@ pub(crate) struct App {
     notice: Option<Notice>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
-    pub(crate) edit_expanded: bool,
+    pub(crate) commit_expanded: bool,
+    pub(crate) actions_expanded: bool,
     pub(crate) enrich_expanded: bool,
     pub(crate) information_expanded: bool,
     forget_confirmation: Option<ObjectId>,
@@ -619,7 +619,8 @@ impl App {
             notice: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
-            edit_expanded: false,
+            commit_expanded: false,
+            actions_expanded: false,
             enrich_expanded: false,
             information_expanded: false,
             forget_confirmation: None,
@@ -1040,11 +1041,10 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleEdit
+            Action::ToggleCommitGroup
                 | Action::Reword
                 | Action::NewCommit
                 | Action::NewEmptyCommit
-                | Action::ForkCommit
                 | Action::Amend
                 | Action::Stash
                 | Action::Spill
@@ -1052,13 +1052,14 @@ impl App {
                 | Action::Forget
                 | Action::Rebase
                 | Action::RebaseUpdate
-                | Action::Squash
-                | Action::Review
                 | Action::TimeTravel
                 | Action::AttachedTimeTravel
                 | Action::TogglePin
         ) {
-            self.edit_expanded = false;
+            self.commit_expanded = false;
+        }
+        if !matches!(&action, Action::ToggleActions | Action::Squash | Action::Review) {
+            self.actions_expanded = false;
         }
         if !matches!(
             &action,
@@ -1191,7 +1192,8 @@ impl App {
             Action::ToggleTrailers => self.show_trailers = !self.show_trailers,
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
-            Action::ToggleEdit => self.edit_expanded = !self.edit_expanded,
+            Action::ToggleCommitGroup => self.commit_expanded = !self.commit_expanded,
+            Action::ToggleActions => self.actions_expanded = !self.actions_expanded,
             Action::ToggleEnrich => self.enrich_expanded = !self.enrich_expanded,
             Action::ToggleInformation => self.information_expanded = !self.information_expanded,
             Action::CycleRefs => {
@@ -1323,11 +1325,6 @@ impl App {
                     empty: true,
                 }];
             }
-            Action::ForkCommit if self.can_fork_commit() => {
-                return vec![Effect::ForkCommit(
-                    self.rows[self.selected.expect("fork requires a selection")].id,
-                )];
-            }
             Action::Amend if self.can_amend() => {
                 return vec![Effect::Amend(
                     self.rows[self.selected.expect("amend requires a selection")].id,
@@ -2092,16 +2089,6 @@ impl App {
         }
     }
 
-    pub(crate) fn can_fork_commit(&self) -> bool {
-        self.state == State::Complete
-            && self.worktree_changes_available
-            && !self.worktree_conflicted
-            && self.pending_rebase_conflict.is_none()
-            && self.changes_focus.is_none()
-            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
-            && self.selected.and_then(|index| self.rows.get(index)).is_some()
-    }
-
     pub(crate) fn can_forget(&self) -> bool {
         self.state == State::Complete
             && self.changes_focus.is_none()
@@ -3356,8 +3343,6 @@ mod tests {
             !app.can_create_commit(),
             "a merge descendant outside the visible projection prevents a child"
         );
-        assert!(app.can_fork_commit(), "a fork does not rewrite merge descendants");
-        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(2))]);
 
         let mut unborn = App::new(10);
         unborn.set_worktree_head_unborn(true);
@@ -3373,7 +3358,6 @@ mod tests {
                 empty: false,
             }]
         );
-        assert!(!unborn.can_fork_commit(), "a fork requires a selected parent");
     }
 
     #[test]
@@ -3874,8 +3858,6 @@ mod tests {
         assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(id(4))]);
         assert!(!app.can_reword());
         assert!(!app.can_forget());
-        assert!(app.can_fork_commit());
-        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(4))]);
         assert_eq!(
             app.update(Action::TimeTravel),
             vec![Effect::TimeTravel {
@@ -4190,11 +4172,11 @@ mod tests {
     }
 
     #[test]
-    fn edit_group_stays_open_only_for_grouped_actions() {
+    fn commit_and_actions_groups_stay_open_only_for_their_actions() {
         let mut app = App::new(1);
 
-        app.update(Action::ToggleEdit);
-        assert!(app.edit_expanded);
+        app.update(Action::ToggleCommitGroup);
+        assert!(app.commit_expanded);
         app.update(Action::Reword);
         app.update(Action::NewCommit);
         app.update(Action::Forget);
@@ -4202,24 +4184,30 @@ mod tests {
         app.update(Action::RebaseUpdate);
         app.update(Action::TimeTravel);
         app.update(Action::AttachedTimeTravel);
-        assert!(app.edit_expanded, "grouped edit commands keep the group open");
+        assert!(app.commit_expanded, "grouped commit commands keep the group open");
 
         app.update(Action::MoveDown);
-        assert!(!app.edit_expanded, "navigation collapses the group");
+        assert!(!app.commit_expanded, "navigation collapses the group");
 
-        app.update(Action::ToggleEdit);
+        app.update(Action::ToggleCommitGroup);
         app.update(Action::ToggleHistoryDisplay);
-        assert!(!app.edit_expanded, "opening the view group closes the edit group");
+        assert!(!app.commit_expanded, "opening the view group closes the commit group");
         assert!(app.history_display_expanded);
 
-        app.update(Action::ToggleEdit);
-        assert!(app.edit_expanded);
+        app.update(Action::ToggleCommitGroup);
+        assert!(app.commit_expanded);
         assert!(
             !app.history_display_expanded,
-            "opening the edit group closes the view group"
+            "opening the commit group closes the view group"
         );
-        app.update(Action::ToggleEdit);
-        assert!(!app.edit_expanded, "the prefix key toggles the group");
+        app.update(Action::ToggleActions);
+        assert!(!app.commit_expanded, "opening actions closes commit");
+        assert!(app.actions_expanded);
+        app.update(Action::Review);
+        app.update(Action::Squash);
+        assert!(app.actions_expanded, "grouped actions keep the group open");
+        app.update(Action::ToggleActions);
+        assert!(!app.actions_expanded, "the prefix key toggles the group");
     }
 
     #[test]
@@ -4250,8 +4238,8 @@ mod tests {
         app.update(Action::MoveDown);
         assert!(!app.enrich_expanded, "navigation closes enrich");
         app.update(Action::ToggleEnrich);
-        app.update(Action::ToggleEdit);
-        assert!(!app.enrich_expanded, "opening edit closes enrich");
+        app.update(Action::ToggleCommitGroup);
+        assert!(!app.enrich_expanded, "opening commit closes enrich");
 
         app.hidden_rows.insert(id(1));
         app.update(Action::ToggleEnrich);
@@ -4292,8 +4280,8 @@ mod tests {
         assert!(!app.information_expanded, "opening view closes information");
         app.update(Action::ToggleInformation);
         assert!(!app.history_display_expanded, "opening information closes view");
-        app.update(Action::ToggleEdit);
-        assert!(!app.information_expanded, "opening edit closes information");
+        app.update(Action::ToggleCommitGroup);
+        assert!(!app.information_expanded, "opening commit closes information");
     }
 
     #[test]
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index f3fb7e77bda..9bcf4870995 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -336,34 +336,6 @@ fn apply_commit(
     Ok(outcome)
 }
 
-#[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
-pub(crate) fn apply_fork(
-    mut repo: gix::Repository,
-    graph: &crate::history::HistoryGraph,
-    mut prepared: Prepared,
-    edited: &[u8],
-) -> Result<ObjectId> {
-    let repository_path = repo.git_dir().to_owned();
-    let bare = repo.is_bare();
-    repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let parent = prepared.parent.context("a fork commit requires a parent")?;
-    let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
-    let id = rebase::perform(
-        &repo,
-        graph,
-        rebase::Edit::Fork { anchor: parent, commit },
-        rebase::Signature::RedoIfNeeded,
-        rebase::Tree::LeaveAsIs,
-    )?
-    .complete()?
-    .selected
-    .context("forking a commit did not produce a selection")?;
-    drop(repo);
-    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
-        .context("the fork was created, but its enrichment could not be saved")?;
-    Ok(id)
-}
-
 pub(super) fn commit_from_edit(
     prepared: &Prepared,
     edited: &[u8],
@@ -568,126 +540,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn fork_creates_an_independent_pinned_child_then_time_travels_to_it() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
-        let repository = open(fixture.path())?;
-        let main = repository.head_id()?.detach();
-        let parent = main;
-        let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let prepared = prepare(open(fixture.path())?, Some(parent))?;
-        let edited = prepared
-            .document
-            .replacen(b"what\n\nwhy", b"fork\n\nreason", 1)
-            .replacen(b";Todo\n;Message:", b"Todo\nMessage: fork enrichment", 1);
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        let fork = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
-
-        let repository = open(fixture.path())?;
-        assert_eq!(
-            crate::enrich::load(
-                &mut crate::enrich::open(&repository)?,
-                crate::change_id::for_commit(&repository, fork)?
-            )?,
-            crate::enrich::Enrichment {
-                todo: true,
-                note: Some("fork enrichment".into()),
-            }
-        );
-        assert_eq!(repository.head_id()?.detach(), main, "forking does not move HEAD");
-        assert_eq!(
-            repository.find_reference("refs/heads/main")?.id().detach(),
-            main,
-            "forking does not move the source branch"
-        );
-        assert_eq!(
-            repository.find_commit(fork)?.parent_ids().next().map(gix::Id::detach),
-            Some(parent),
-            "the fork is a direct child of the selected commit"
-        );
-        let pins = crate::history::all_pins(&repository)?;
-        assert_eq!(pins.len(), 1, "the new leaf is retained until checkout");
-        assert_eq!(pins[0].id, fork);
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?.worktree,
-            before.worktree,
-            "creating the fork leaves worktree files untouched"
-        );
-
-        let repository_path = repository.git_dir().to_owned();
-        let graph = super::super::loaded_graph(&repository)?;
-        drop(repository);
-        super::super::time_travel::perform(&repository_path, false, fork, &graph, &[], &[], false)?.complete()?;
-        let repository = open(fixture.path())?;
-        assert!(repository.head()?.is_detached(), "automatic fork travel detaches HEAD");
-        assert_eq!(repository.head_id()?.detach(), fork);
-        let pins = crate::history::all_pins(&repository)?;
-        assert_eq!(pins.len(), 1, "the checkout consumes the temporary fork pin");
-        assert!(pins[0].is_head(), "the singleton remembers the departed branch");
-        assert_eq!(pins[0].id, main);
-        Ok(())
-    }
-
-    #[test]
-    fn sibling_forks_remain_visible_as_private_pinned_tips() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
-        for args in [
-            ["reset", "--hard", "-q", "HEAD"].as_slice(),
-            ["clean", "-fdq"].as_slice(),
-        ] {
-            assert!(
-                Command::new("git")
-                    .arg("-C")
-                    .arg(fixture.path())
-                    .args(args)
-                    .status()?
-                    .success(),
-                "the fork fixture is cleaned"
-            );
-        }
-        let repository = open(fixture.path())?;
-        let repository_path = repository.git_dir().to_owned();
-        let base = repository.head_id()?.detach();
-        drop(repository);
-
-        let prepared = prepare(open(fixture.path())?, Some(base))?;
-        let edited = prepared.document.replacen(b"what\n\nwhy", b"first fork\n\nreason", 1);
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        let first = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, first, &graph, &[], &[], false)?.complete()?;
-
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, base, &graph, &[], &[], false)?.complete()?;
-        let prepared = prepare(open(fixture.path())?, Some(base))?;
-        let edited = prepared.document.replacen(b"what\n\nwhy", b"second fork\n\nreason", 1);
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        let second = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
-        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
-        super::super::time_travel::perform(&repository_path, false, second, &graph, &[], &[], false)?.complete()?;
-
-        let repository = open(fixture.path())?;
-        let snapshot = crate::history::snapshot(&repository, &[], &[], false)?;
-        assert_eq!(repository.head_id()?.detach(), second);
-        assert!(
-            snapshot.view_tips.contains(&first),
-            "the first review fork remains visible"
-        );
-        assert!(
-            snapshot.view_tips.contains(&second),
-            "the current review fork remains visible"
-        );
-        assert_eq!(
-            crate::history::all_pins(&repository)?
-                .into_iter()
-                .map(|pin| pin.id)
-                .collect::<std::collections::HashSet<_>>(),
-            [first, base].into_iter().collect(),
-            "the first fork and remembered branch have private pins"
-        );
-        Ok(())
-    }
-
     #[test]
     fn creates_an_empty_root_commit_for_an_unborn_head() -> gix_testtools::Result {
         let fixture = gix_testtools::tempfile::tempdir()?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 0069d53ff2d..7fe8cbd88c8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -53,10 +53,6 @@ pub(crate) enum Edit {
         commit: gix::objs::Commit,
         reset_index: bool,
     },
-    Fork {
-        anchor: ObjectId,
-        commit: gix::objs::Commit,
-    },
     Remove {
         target: ObjectId,
     },
@@ -597,29 +593,19 @@ fn perform_inner(
         Edit::Repeat { checkout, .. } => Some(*checkout),
         _ => None,
     };
-    let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
-        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, false, None),
+    let (root, replacement, inserted, reset_index, removed, repeat, mut split_upper) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, None),
         Edit::Insert {
             anchor,
             commit,
             reset_index,
-        } => (anchor, Some(commit), true, reset_index, false, false, false, None),
-        Edit::Fork { anchor, commit } => (Some(anchor), Some(commit), false, false, true, false, false, None),
-        Edit::Remove { target } => (Some(target), None, false, false, false, true, false, None),
-        Edit::Split { target, source, upper } => (
-            Some(target),
-            Some(source),
-            false,
-            false,
-            false,
-            false,
-            false,
-            Some(upper),
-        ),
-        Edit::Repeat { base, .. } => (Some(base), None, false, false, false, false, true, None),
+        } => (anchor, Some(commit), true, reset_index, false, false, None),
+        Edit::Remove { target } => (Some(target), None, false, false, true, false, None),
+        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, false, Some(upper)),
+        Edit::Repeat { base, .. } => (Some(base), None, false, false, false, true, None),
     };
 
-    let affected = match root.filter(|_| !forked) {
+    let affected = match root {
         Some(root) => graph
             .descendants_in_parent_order(root)
             .context("the edited commit is not in the loaded history")?,
@@ -642,7 +628,7 @@ fn perform_inner(
     let mut note_rewrites = Vec::new();
     let mut selected = None;
     let mut conflict = None;
-    if inserted || forked {
+    if inserted {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
         let id = write_commit(
@@ -654,12 +640,10 @@ fn perform_inner(
             signing.clone(),
         )?;
         selected = Some(id);
-        if inserted {
-            if let Some(root) = root {
-                rewritten.insert(root, Some(id));
-            } else {
-                rewritten.insert(id, Some(id));
-            }
+        if let Some(root) = root {
+            rewritten.insert(root, Some(id));
+        } else {
+            rewritten.insert(id, Some(id));
         }
     } else if removed {
         let root = root.context("a removed commit is required")?;
@@ -784,8 +768,7 @@ fn perform_inner(
         }
     }
 
-    let marked = (!forked && matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants))
-        || conflict.is_some();
+    let marked = matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) || conflict.is_some();
     let checkout_after_finish = conflict.is_some();
     let mut prepared = Prepared {
         repo,
@@ -793,7 +776,6 @@ fn perform_inner(
         reset_index: if inserted { reset_index } else { marked },
         reset_index_paths,
         skip_worktree_transitions: inserted
-            || forked
             || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
         selected,
         note_rewrites,
@@ -808,11 +790,7 @@ fn perform_inner(
         expected_refs: None,
         checkout_reference: None,
         checkout_after_finish,
-        pins: if forked {
-            selected.into_iter().collect()
-        } else {
-            Vec::new()
-        },
+        pins: Vec::new(),
         delete_refs,
     };
     match conflict {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 25c7c0cdbe3..d54d4083cb4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1688,8 +1688,10 @@ fn event_loop(
                 let action = action_with_shortcut_groups(
                     key,
                     app.history_display_expanded,
-                    app.edit_expanded,
+                    app.commit_expanded,
+                    app.actions_expanded,
                     app.enrich_expanded,
+                    app.information_expanded,
                 );
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
@@ -2173,70 +2175,6 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("new commit: {err:#}")),
                     }
                 }
-                Effect::ForkCommit(parent) => {
-                    fill_repository.retain = false;
-                    fill_repository.retained = None;
-                    let created = history_graph
-                        .as_ref()
-                        .context("creating a fork requires a completed history graph")
-                        .and_then(|graph| {
-                            create_commit(
-                                terminal,
-                                &repository_path,
-                                repository_is_bare,
-                                graph,
-                                Some(parent),
-                                CreateMode::Fork,
-                                enhanced_keyboard,
-                            )
-                        });
-                    match created {
-                        Ok(Some(new_id)) => {
-                            let review_roots: Vec<_> =
-                                app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
-                            let travel = open_repository(&repository_path, repository_is_bare, false)
-                                .context("could not reopen repository before travelling to fork")
-                                .and_then(|repository| edit::loaded_graph(&repository))
-                                .and_then(|graph| {
-                                    edit::time_travel::perform(
-                                        &repository_path,
-                                        repository_is_bare,
-                                        new_id,
-                                        &graph,
-                                        &review_roots,
-                                        &revisions,
-                                        false,
-                                    )
-                                });
-                            match travel {
-                                Ok(edit::time_travel::Perform::Complete { notice, .. }) => {
-                                    app.leave_success(notice.map_or_else(
-                                        || format!("created fork {}", new_id.to_hex_with_len(7)),
-                                        |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
-                                    ));
-                                    app.select_commit_after_refresh(new_id);
-                                    invalidate_worktree_changes(&mut worktree_changes);
-                                    refresh_pending = true;
-                                }
-                                Ok(edit::time_travel::Perform::Conflict(conflict)) => {
-                                    let original = conflict.original();
-                                    app.arm_rebase_conflict(original);
-                                    app.select_commit(original);
-                                    pending_rebase_conflict = Some(conflict);
-                                }
-                                Err(err) => {
-                                    app.leave_attention(format!(
-                                        "created fork {}, but checkout failed: {err:#}",
-                                        new_id.to_hex_with_len(7)
-                                    ));
-                                    refresh_pending = true;
-                                }
-                            }
-                        }
-                        Ok(None) => app.leave_attention("no fork created: no input was provided"),
-                        Err(err) => app.leave_error(format!("fork: {err:#}")),
-                    }
-                }
                 Effect::Split(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -4175,10 +4113,9 @@ fn todo_progress_visible(elapsed: Duration) -> bool {
 enum CreateMode {
     Insert,
     InsertEmpty,
-    Fork,
 }
 
-#[tracing::instrument(skip_all, fields(parent = ?parent, fork = matches!(mode, CreateMode::Fork)))]
+#[tracing::instrument(skip_all, fields(parent = ?parent))]
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
@@ -4212,10 +4149,7 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    let id = match mode {
-        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited)?,
-        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited)?,
-    };
+    let id = edit::create::apply(repository, graph, prepared, &edited)?;
     Ok(Some(id))
 }
 
@@ -4991,7 +4925,7 @@ fn poll_timeout(
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
-    action_with_shortcut_groups(key, false, false, false)
+    action_with_shortcut_groups(key, false, false, false, false, false)
 }
 
 fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_focused: bool) -> bool {
@@ -5038,8 +4972,10 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
 fn action_with_shortcut_groups(
     key: KeyEvent,
     history_display_expanded: bool,
-    edit_expanded: bool,
+    commit_expanded: bool,
+    actions_expanded: bool,
     enrich_expanded: bool,
+    information_expanded: bool,
 ) -> Option<Action> {
     if key.kind == KeyEventKind::Release {
         return None;
@@ -5048,23 +4984,21 @@ fn action_with_shortcut_groups(
         KeyCode::Tab => Some(Action::ToggleChangesFocus),
         KeyCode::Enter => Some(Action::OpenDiff),
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
-        KeyCode::Char('c') => Some(Action::ToggleChanges),
-        KeyCode::Char('p') if edit_expanded => Some(Action::Split),
-        KeyCode::Char('q') if edit_expanded => Some(Action::Squash),
-        KeyCode::Char('b') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
-        KeyCode::Char('u') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+        KeyCode::Char('c') if information_expanded => Some(Action::ToggleChanges),
+        KeyCode::Char('p') if commit_expanded => Some(Action::Split),
+        KeyCode::Char('b') if commit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
+        KeyCode::Char('u') if commit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::RebaseUpdate)
         }
-        KeyCode::Char('f') if edit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
-            Some(Action::ForkCommit)
-        }
+        KeyCode::Char('r') if actions_expanded => Some(Action::Review),
+        KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
         KeyCode::Down | KeyCode::Char('j') => Some(Action::MoveDown),
         KeyCode::Char('x') => Some(Action::CycleDuplicate),
-        KeyCode::Char('h') if edit_expanded => Some(Action::Stash),
+        KeyCode::Char('h') if commit_expanded => Some(Action::Stash),
         KeyCode::Char('h') if history_display_expanded => Some(Action::ToggleHidden),
         KeyCode::Char('h') => Some(Action::ScrollLeft),
         KeyCode::Char('l') => Some(Action::ScrollRight),
@@ -5087,14 +5021,13 @@ fn action_with_shortcut_groups(
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
-        KeyCode::Char('o') if edit_expanded => Some(Action::Reword),
-        KeyCode::Char('n') if edit_expanded => Some(Action::NewCommit),
-        KeyCode::Char('m') if edit_expanded => Some(Action::NewEmptyCommit),
-        KeyCode::Char('a') if edit_expanded => Some(Action::Amend),
-        KeyCode::Char('s') if edit_expanded => Some(Action::Spill),
-        KeyCode::Char('d') if edit_expanded => Some(Action::Forget),
-        KeyCode::Char('i') if edit_expanded => Some(Action::TogglePin),
-        KeyCode::Char('v') if edit_expanded => Some(Action::Review),
+        KeyCode::Char('o') if commit_expanded => Some(Action::Reword),
+        KeyCode::Char('n') if commit_expanded => Some(Action::NewCommit),
+        KeyCode::Char('m') if commit_expanded => Some(Action::NewEmptyCommit),
+        KeyCode::Char('a') if commit_expanded => Some(Action::Amend),
+        KeyCode::Char('s') if commit_expanded => Some(Action::Spill),
+        KeyCode::Char('d') if commit_expanded => Some(Action::Forget),
+        KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),
         KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
         KeyCode::Char('@') => Some(Action::TimeTravel),
@@ -5106,7 +5039,8 @@ fn action_with_shortcut_groups(
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('t') => Some(Action::ToggleRefTree),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
-        KeyCode::Char('e') => Some(Action::ToggleEdit),
+        KeyCode::Char('c') => Some(Action::ToggleCommitGroup),
+        KeyCode::Char('a') => Some(Action::ToggleActions),
         KeyCode::Char('n') => Some(Action::ToggleEnrich),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
         KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
@@ -6192,9 +6126,14 @@ mod tests {
             "terminals that report shifted letters in lowercase still map Shift-G to the first commit"
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)), None);
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)), None);
         assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)),
-            Some(Action::ToggleEdit)
+            action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)),
+            Some(Action::ToggleCommitGroup)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE)),
+            Some(Action::ToggleActions)
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
@@ -6205,7 +6144,9 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
                 false,
                 false,
-                true
+                false,
+                true,
+                false
             ),
             Some(Action::ToggleTodo)
         );
@@ -6214,7 +6155,9 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE),
                 false,
                 false,
-                true
+                false,
+                true,
+                false
             ),
             Some(Action::EditNote)
         );
@@ -6223,7 +6166,9 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE),
                 false,
                 false,
-                true
+                false,
+                true,
+                false
             ),
             Some(Action::EditGitNote)
         );
@@ -6232,7 +6177,9 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
                 false,
                 false,
-                true
+                false,
+                true,
+                false
             ),
             Some(Action::ToggleEnrich)
         );
@@ -6324,6 +6271,8 @@ mod tests {
                     KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
                     true,
                     false,
+                    false,
+                    false,
                     false
                 ),
                 Some(expected),
@@ -6335,6 +6284,8 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE),
                 true,
                 false,
+                false,
+                false,
                 false
             ),
             Some(Action::ToggleHistoryDisplay),
@@ -6346,12 +6297,10 @@ mod tests {
             ('o', Action::Reword),
             ('n', Action::NewCommit),
             ('m', Action::NewEmptyCommit),
-            ('f', Action::ForkCommit),
             ('a', Action::Amend),
             ('h', Action::Stash),
             ('s', Action::Spill),
             ('p', Action::Split),
-            ('q', Action::Squash),
             ('d', Action::Forget),
             ('i', Action::TogglePin),
         ] {
@@ -6360,10 +6309,26 @@ mod tests {
                     KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
                     false,
                     true,
+                    false,
+                    false,
                     false
                 ),
                 Some(expected),
-                "{key} is available after the edit prefix"
+                "{key} is available after the commit prefix"
+            );
+        }
+        for (key, expected) in [('r', Action::Review), ('s', Action::Squash)] {
+            assert_eq!(
+                action_with_shortcut_groups(
+                    KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
+                    false,
+                    false,
+                    true,
+                    false,
+                    false
+                ),
+                Some(expected),
+                "{key} is available after the actions prefix"
             );
         }
         assert_eq!(
@@ -6371,50 +6336,60 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
             Some(Action::ToggleRefTree),
-            "the direct ref-tree key remains available while edit is expanded"
+            "the direct ref-tree key remains available while commit is expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('@'), KeyModifiers::NONE),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
             Some(Action::TimeTravel),
-            "the direct time-travel key remains available while edit is expanded"
+            "the direct time-travel key remains available while commit is expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('#'), KeyModifiers::NONE),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
             Some(Action::AttachedTimeTravel),
-            "the direct attached-time-travel key remains available while edit is expanded"
+            "the direct attached-time-travel key remains available while commit is expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
             Some(Action::PageUp),
-            "navigation keeps priority over the edit shortcut"
+            "navigation keeps priority over the commit shortcut"
         );
         assert_eq!(
             action_with_shortcut_groups(
-                KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
+                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
-            Some(Action::ToggleEdit),
-            "e closes the edit shortcut group"
+            Some(Action::ToggleCommitGroup),
+            "c closes the commit shortcut group"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)),
@@ -6435,10 +6410,12 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('r'), KeyModifiers::NONE),
                 false,
                 true,
+                false,
+                false,
                 false
             ),
             Some(Action::ToggleRefs),
-            "the old edit shortcut retains its direct reference-toggle behavior"
+            "plain r retains its direct reference-toggle behavior"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
@@ -6446,7 +6423,19 @@ mod tests {
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)),
-            Some(Action::ToggleChanges)
+            Some(Action::ToggleCommitGroup)
+        );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+                false,
+                false,
+                false,
+                false,
+                true
+            ),
+            Some(Action::ToggleChanges),
+            "changes is scoped to the information prefix"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('Y'), KeyModifiers::SHIFT)),
@@ -6466,12 +6455,12 @@ mod tests {
     fn tree_is_direct_while_trailers_remain_scoped_to_the_view_prefix() {
         let key = KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE);
         assert_eq!(
-            action_with_shortcut_groups(key, true, false, false),
+            action_with_shortcut_groups(key, true, false, false, false, false),
             Some(Action::ToggleTrailers),
             "v t retains its trailer action"
         );
         assert_eq!(
-            action_with_shortcut_groups(key, false, false, false),
+            action_with_shortcut_groups(key, false, false, false, false, false),
             Some(Action::ToggleRefTree),
             "plain t toggles the ref-tree"
         );
@@ -6546,7 +6535,7 @@ mod tests {
         }
         for action in [
             Action::Refresh,
-            Action::ToggleEdit,
+            Action::ToggleCommitGroup,
             Action::Amend,
             Action::Rebase,
             Action::TimeTravel,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8f09c0e5a3c..5527f7fb0af 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -942,7 +942,8 @@ pub(crate) fn draw_with_worktree(
     let mut footer_spans = vec![Span::raw(status)];
     let mut time_travel = None;
     let mut attached_time_travel = false;
-    let mut edit_prefix_spans = Vec::new();
+    let mut commit_prefix_spans = Vec::new();
+    let mut actions_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
         let head_visible = decorations
             .values()
@@ -974,7 +975,7 @@ pub(crate) fn draw_with_worktree(
             None
         };
         attached_time_travel = head_visible && app.attached_time_travel_shortcut_visible();
-        if app.edit_expanded {
+        if app.commit_expanded {
             let mut options = Vec::new();
             if app.can_rebase() {
                 options.push(("rebase", 'b'));
@@ -982,11 +983,6 @@ pub(crate) fn draw_with_worktree(
             if app.can_rebase_update() {
                 options.push(("rebase-update", 'u'));
             }
-            if app.can_finish_review() {
-                options.push(("finish-review", 'v'));
-            } else if app.can_review() {
-                options.push(("review", 'v'));
-            }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'o'));
             }
@@ -996,9 +992,6 @@ pub(crate) fn draw_with_worktree(
             if app.changes_focus.is_none() && app.can_create_empty_commit() {
                 options.push(("new-empty", 'm'));
             }
-            if app.can_fork_commit() {
-                options.push(("fork", 'f'));
-            }
             if app.can_amend() {
                 options.push(("amend", 'a'));
             }
@@ -1013,9 +1006,6 @@ pub(crate) fn draw_with_worktree(
             if app.can_split() {
                 options.push(("split", 'p'));
             }
-            if app.can_squash() {
-                options.push(("squash", 'q'));
-            }
             if app.changes_focus.is_none() && app.can_forget() {
                 options.push(("d forget", 'd'));
             }
@@ -1029,25 +1019,55 @@ pub(crate) fn draw_with_worktree(
                 });
                 options.push((if pinned { "unpin" } else { "pin" }, 'i'));
             }
-            edit_prefix_spans.push(Span::raw(" · "));
-            edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
-            edit_prefix_spans.push(Span::raw("dit ("));
+            commit_prefix_spans.push(Span::raw(" · "));
+            commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
+            commit_prefix_spans.push(Span::raw("ommit ("));
+            if options.is_empty() {
+                commit_prefix_spans.push(Span::raw("no actions"));
+            } else {
+                for (index, (label, key)) in options.into_iter().enumerate() {
+                    if index > 0 {
+                        commit_prefix_spans.push(Span::raw(" · "));
+                    }
+                    commit_prefix_spans.extend(shortcut(label, key, true));
+                }
+            }
+            commit_prefix_spans.push(Span::raw(")"));
+            emphasize_prefix(&mut commit_prefix_spans[1..]);
+        } else {
+            commit_prefix_spans.push(Span::raw(" · "));
+            commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
+            commit_prefix_spans.push(Span::raw("ommit"));
+        }
+    }
+    if app.changes_focus.is_none() {
+        actions_prefix_spans.push(Span::raw(" · "));
+        actions_prefix_spans.push(Span::styled("a", Style::default().add_modifier(Modifier::UNDERLINED)));
+        if app.actions_expanded {
+            actions_prefix_spans.push(Span::raw("ctions ("));
+            let mut options = Vec::new();
+            if app.can_finish_review() {
+                options.push(("finish-review", 'r'));
+            } else if app.can_review() {
+                options.push(("review", 'r'));
+            }
+            if app.can_squash() {
+                options.push(("squash", 's'));
+            }
             if options.is_empty() {
-                edit_prefix_spans.push(Span::raw("no actions"));
+                actions_prefix_spans.push(Span::raw("no actions"));
             } else {
                 for (index, (label, key)) in options.into_iter().enumerate() {
                     if index > 0 {
-                        edit_prefix_spans.push(Span::raw(" · "));
+                        actions_prefix_spans.push(Span::raw(" · "));
                     }
-                    edit_prefix_spans.extend(shortcut(label, key, true));
+                    actions_prefix_spans.extend(shortcut(label, key, true));
                 }
             }
-            edit_prefix_spans.push(Span::raw(")"));
-            emphasize_prefix(&mut edit_prefix_spans[1..]);
-        } else if !app.history_display_expanded {
-            edit_prefix_spans.push(Span::raw(" · "));
-            edit_prefix_spans.push(Span::styled("e", Style::default().add_modifier(Modifier::UNDERLINED)));
-            edit_prefix_spans.push(Span::raw("dit"));
+            actions_prefix_spans.push(Span::raw(")"));
+            emphasize_prefix(&mut actions_prefix_spans[1..]);
+        } else {
+            actions_prefix_spans.push(Span::raw("ctions"));
         }
     }
     let focus_feedback = app.focus_feedback.take();
@@ -1116,7 +1136,8 @@ pub(crate) fn draw_with_worktree(
     }
     let mut ordered = vec![Span::raw(history_position(app))];
     ordered.append(&mut view_prefix_spans);
-    ordered.append(&mut edit_prefix_spans);
+    ordered.append(&mut commit_prefix_spans);
+    ordered.append(&mut actions_prefix_spans);
     ordered.push(Span::raw(" · "));
     let enrich_prefix_start = ordered.len();
     ordered.extend(shortcut("enrich", 'n', true));
@@ -2723,7 +2744,8 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · view · edit · enrich · copy") && computing.contains("computing"),
+            computing.contains("1 commits · view · commit · actions · enrich · copy")
+                && computing.contains("computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -3097,8 +3119,8 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
         assert!(
-            !rendered_line(&terminal, 1).contains(" · edit ·"),
-            "the view group keeps e reserved for toggling emails"
+            rendered_line(&terminal, 1).contains(" · commit · actions ·"),
+            "the commit and actions prefixes remain available beside the view group"
         );
 
         let row = rendered_row(&terminal);
@@ -3282,7 +3304,7 @@ mod tests {
             "todo commit metadata uses the author date and excludes separately represented refs"
         );
 
-        let footer_text = "#0 · view · edit · enrich · copy · refs · ? · quit";
+        let footer_text = "#0 · view · commit · actions · enrich · copy · refs · ? · quit";
         let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..11 {
@@ -3308,7 +3330,8 @@ mod tests {
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         for (label, key) in [
             ("view", 'v'),
-            ("edit", 'e'),
+            ("commit", 'c'),
+            ("actions", 'a'),
             ("enrich", 'n'),
             ("copy", 'y'),
             ("refs", 'r'),
@@ -3543,7 +3566,7 @@ mod tests {
             ),
         ]);
         let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
-        app.edit_expanded = true;
+        app.commit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
         assert!(row.contains("📌"), "a pinned commit has an obvious pin marker: {row:?}");
@@ -3581,11 +3604,11 @@ mod tests {
         );
         assert!(
             rendered_line(&terminal, 1).contains(
-                "edit (reword · new · new-empty · fork · d forget · unpin) · enrich · @ return · # attach · copy"
+                "commit (reword · new · new-empty · d forget · unpin) · actions · enrich · @ return · # attach · copy"
             ),
-            "both travel actions stay outside the active edit prefix"
+            "both travel actions stay outside the active commit prefix"
         );
-        assert!(!rendered_line(&terminal, 1).contains(" · edit ·"));
+        assert!(!rendered_line(&terminal, 1).contains(" · commit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
@@ -3648,7 +3671,9 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         let view = "view (author date · ids · emails · names · mailmap · trailers · refs · show hidden)";
         assert!(
-            footer.starts_with(&format!("0 commits · {view} · enrich · copy · refs · ?")),
+            footer.starts_with(&format!(
+                "0 commits · {view} · commit · actions · enrich · copy · refs · ?"
+            )),
             "the active view prefix follows the history position"
         );
         let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
@@ -3663,20 +3688,32 @@ mod tests {
         assert_reversed_group(&terminal, 1, view);
 
         app.history_display_expanded = false;
-        app.edit_expanded = true;
+        app.commit_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(
+            rendered_line(&terminal, 1)
+                .starts_with("0 commits · view · commit (no actions) · actions · enrich · copy · refs · ?"),
+            "the commit prefix follows the view prefix even when no action is available"
+        );
+        assert_reversed_group(&terminal, 1, "commit (no actions)");
+
+        app.commit_expanded = false;
+        app.actions_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit (no actions) · enrich · copy · refs · ?"),
-            "the edit prefix follows the view prefix even when no action is available"
+            rendered_line(&terminal, 1)
+                .starts_with("0 commits · view · commit · actions (no actions) · enrich · copy · refs · ?"),
+            "the actions prefix follows the commit prefix"
         );
-        assert_reversed_group(&terminal, 1, "edit (no actions)");
+        assert_reversed_group(&terminal, 1, "actions (no actions)");
 
-        app.edit_expanded = false;
+        app.actions_expanded = false;
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("0 commits · view · edit · enrich (no actions) · copy · refs · ?"),
-            "the enrich prefix follows the edit prefix"
+            rendered_line(&terminal, 1)
+                .starts_with("0 commits · view · commit · actions · enrich (no actions) · copy · refs · ?"),
+            "the enrich prefix follows the actions prefix"
         );
         assert_reversed_group(&terminal, 1, "enrich (no actions)");
 
@@ -3686,7 +3723,7 @@ mod tests {
         let footer = rendered_line(&terminal, 1);
         assert!(
             footer.starts_with(
-                    "0 commits · view · edit · enrich · copy · refs · ? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+                    "0 commits · view · commit · actions · enrich · copy · refs · ? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
                 ),
             "the information prefix contains every following action except quit: {footer}"
         );
@@ -3718,7 +3755,7 @@ mod tests {
         app.set_worktree_head(Some(id), false);
         complete(&mut app);
         app.changes_focus = Some(ChangePane::Tree);
-        app.edit_expanded = true;
+        app.commit_expanded = true;
         let changes = Changes {
             paths: vec![crate::app::PathChange {
                 kind: ChangeKind::Added,
@@ -3749,7 +3786,7 @@ mod tests {
         })?;
         let footer = rendered_line(&terminal, 7);
         assert!(
-            footer.contains("edit (spill)"),
+            footer.contains("commit (spill)"),
             "tree focus keeps the scoped edit visible: {footer}"
         );
         assert!(!footer.contains("amend"), "tree paths cannot be amended");
@@ -3767,7 +3804,7 @@ mod tests {
         };
         app.set_head_edit_availability(true, false, false, true, false, false, false);
         assert!(app.can_amend(), "the focused worktree path is amendable");
-        assert!(app.edit_expanded, "the edit prefix remains expanded");
+        assert!(app.commit_expanded, "the commit prefix remains expanded");
         terminal.draw(|frame| {
             super::draw_with_worktree(
                 frame,
@@ -3780,10 +3817,10 @@ mod tests {
             );
         })?;
         assert!(app.can_amend(), "drawing retains scoped amend availability");
-        assert!(app.edit_expanded, "drawing retains the expanded edit prefix");
+        assert!(app.commit_expanded, "drawing retains the expanded commit prefix");
         let footer = rendered_line(&terminal, 7);
         assert!(
-            footer.contains("edit (amend)"),
+            footer.contains("commit (amend)"),
             "worktree focus keeps the scoped edit visible: {footer}"
         );
         assert!(!footer.contains("spill"), "worktree paths cannot be spilled");
@@ -3861,7 +3898,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 7).contains("edit (amend)"),
+            rendered_line(&terminal, 7).contains("commit (amend)"),
             "a review may amend its selected staged path"
         );
         Ok(())
@@ -5983,7 +6020,7 @@ mod tests {
         );
 
         let mut narrow = Terminal::new(TestBackend::new(28, 3))?;
-        app.edit_expanded = true;
+        app.commit_expanded = true;
         narrow.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
             rendered_line(&narrow, 1).ends_with(" ⇣2 "),
@@ -5992,7 +6029,7 @@ mod tests {
         let mut actions = Terminal::new(TestBackend::new(120, 3))?;
         actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&actions, 2).contains("edit (rebase · rebase-update · fork · pin)"),
+            rendered_line(&actions, 2).contains("commit (rebase · rebase-update · pin) · actions"),
             "the selected hidden base offers independent edits: {:?}",
             rendered_line(&actions, 2)
         );

From 470266088a879d2de92c247ea11ed8963ed054a7 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 21:43:30 +0200
Subject: [PATCH 221/282] feat: add a ref-only TUI forkpoint action

Forkpoint replaces the former attached-travel shortcut as the only TUI action that moves the remembered branch while attaching HEAD. The actions prefix establishes the current detached HEAD as that forkpoint without checking out files.

Move the remembered branch and attach HEAD atomically while preserving the index and worktree, including dirty state. Keep the symbolic HEAD pin to identify the remembered branch, retain an otherwise-unreachable former tip with an ordinary pin, and reject branches owned by another worktree.
---
 gix-tix/spec.md                 |  42 +-
 gix-tix/src/app.rs              | 100 +---
 gix-tix/src/edit/time_travel.rs | 910 ++++++--------------------------
 gix-tix/src/lib.rs              |  49 +-
 gix-tix/src/ui.rs               |  29 +-
 5 files changed, 234 insertions(+), 896 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 45d7da09fec..ffbcf4ceaf9 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -376,7 +376,6 @@ without trading responsiveness for metadata that is not visible.
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
 | `s` | Verify signed, unverified commits currently visible on screen. |
 | `@` | Time-travel to the selected commit, or return through its tix pin. Terminals reporting the base key as `Shift-2` are also accepted. |
-| `#` | Time-travel to the selected commit while keeping the current or remembered branch attached. Terminals reporting the base key as `Shift-3` are also accepted. |
 | `x` | Select the next visible commit with the same change ID, wrapping at the end. |
 
 Alignment uses only rows in the current viewport to determine widths and starts
@@ -394,9 +393,8 @@ terminal-theme-independent cue. While active, `view (` contains
 every applicable display option and a closing `)` so direct shortcuts remain visibly
 outside the prefix. The history status starts with the history position, then the
 `v`, `c`, and `a` prefixes when they are addressable. Remaining history-level
-actions end at the information prefix while it is closed. Available direct
-detached and attached time-travel actions follow the shortcut groups beside each other,
-and duplicate cycling follows them when
+actions end at the information prefix while it is closed. An available direct
+time-travel action follows the shortcut groups, and duplicate cycling follows it when
 the selected commit has duplicates, and copy follows these actions; the reference toggle immediately precedes
 the `?` group; quit is always last.
 All status lines embed and underline a shortcut character in its action label when
@@ -407,30 +405,23 @@ The Enter key is written as `<enter>` throughout.
 
 - On a completed, focused history in a worktree repository, `@` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
-- On a completed, focused history in a worktree repository, `#` moves the
-  current attached local branch, or the local branch named by a detached
-  `refs/worktree/tix/pins/HEAD`, to the selected commit and checks it out so
-  `HEAD` ends attached. The action is unavailable and does nothing without such
-  a branch. It is also a no-op when `HEAD` is already attached there.
-- Attached travel refuses a remembered branch checked out by another worktree.
-  Its checkout preflights local changes, atomically moves the branch and
-  `HEAD`, and rolls those references back if applying the worktree transition
-  fails. Newly created recovery pins are removed only when the move did not
-  commit or reference rollback succeeded. It otherwise reuses ordinary time
-  travel's pending-rebase animation and conflict acceptance, including
-  review-tree stash transitions.
-- Attached travel uses normal pin reconciliation. Its actual departure and,
-  when starting detached, the remembered branch's old tip are deduplicated as
-  candidate direct pins; the destination and its ancestors are omitted, and
-  provisional pins still reachable from another view tip are removed after
-  success. Both pins may remain when the histories are unrelated. Successful
-  travel consumes an ordinary destination pin and removes the HEAD pin.
+- `a f` is available while `HEAD` is detached with a valid symbolic HEAD pin.
+  It atomically moves the remembered local branch to the current `HEAD` commit
+  and attaches `HEAD` without changing the index or worktree. The symbolic HEAD
+  pin remains and follows the moved branch. The branch's previous tip receives
+  an ordinary pin only when no other normal view tip still reaches it; an
+  ordinary destination pin is consumed normally.
+- Forkpoint refuses a remembered branch checked out by another worktree. It is
+  unavailable during conflicts or incomplete history, but otherwise permits
+  dirty index and worktree state because the operation changes only refs.
 - When tix detaches an attached local branch, it records that branch symbolically
   in the singleton `refs/worktree/tix/pins/HEAD` ref. Git stores this HEAD pin
   privately for the current worktree, and later branch advances move its tip.
   Further detached travel preserves the singleton. After each successful tix
   checkout, landing on the remembered branch tip reattaches `HEAD` to that branch
   and removes the HEAD pin; explicitly attaching another branch also removes it.
+  Forkpoint is the exception: it deliberately retains the symbolic HEAD pin
+  after attaching its remembered branch.
   A failed automatic reattachment leaves both detached `HEAD` and the HEAD pin
   intact and reports a warning. External Git checkouts do not reconcile it.
 - Other departures are provisionally retained with ordinary
@@ -990,13 +981,14 @@ space first; changes blocks adapt within the remaining history width.
   changes at `@`, `c s` spills `@`, `c p` splits staged from unstaged changes,
   and `c d d` confirms forgetting a top commit when each action is available.
 - `a` toggles the actions shortcut group. `a r` starts or finishes a review and
-  `a s` squashes the selected commit when available.
+  `a s` squashes the selected commit, and `a f` establishes the remembered
+  branch's forkpoint at detached `HEAD` when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
   forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
-- `@` and `#` invoke detached and attached time travel directly, outside both
-  groups. Invoking either leaves an already expanded commit group open.
+- `@` invokes time travel directly, outside both groups. Invoking it leaves an
+  already expanded commit group open.
 - Commit and action shortcuts keep their respective group open. Navigation or
   another recognized command closes it, matching the `v` display shortcut group.
   Plain `r` does not mutate the repository, and plain `t` has no action.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index db3a00fbb80..41077a1f296 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -377,8 +377,8 @@ pub(crate) enum Action {
     RebaseUpdate,
     Squash,
     Review,
+    Forkpoint,
     TimeTravel,
-    AttachedTimeTravel,
     TogglePin,
     VerifySignatures,
     Cancel,
@@ -426,10 +426,8 @@ pub(crate) enum Effect {
         review: ObjectId,
         return_to: Option<ObjectId>,
     },
-    TimeTravel {
-        id: ObjectId,
-        mode: crate::edit::time_travel::TravelMode,
-    },
+    Forkpoint,
+    TimeTravel(ObjectId),
     TogglePin(ObjectId),
     ToggleTodo(ObjectId),
     EditNote(ObjectId),
@@ -1053,12 +1051,14 @@ impl App {
                 | Action::Rebase
                 | Action::RebaseUpdate
                 | Action::TimeTravel
-                | Action::AttachedTimeTravel
                 | Action::TogglePin
         ) {
             self.commit_expanded = false;
         }
-        if !matches!(&action, Action::ToggleActions | Action::Squash | Action::Review) {
+        if !matches!(
+            &action,
+            Action::ToggleActions | Action::Squash | Action::Review | Action::Forkpoint
+        ) {
             self.actions_expanded = false;
         }
         if !matches!(
@@ -1416,17 +1416,11 @@ impl App {
                     return vec![Effect::StartReview { tip, base }];
                 }
             }
+            Action::Forkpoint if self.can_forkpoint() => return vec![Effect::Forkpoint],
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
-                return vec![Effect::TimeTravel {
-                    id: self.rows[self.selected.expect("time-travel requires a selection")].id,
-                    mode: crate::edit::time_travel::TravelMode::Detached,
-                }];
-            }
-            Action::AttachedTimeTravel if self.attached_time_travel_shortcut_visible() => {
-                return vec![Effect::TimeTravel {
-                    id: self.rows[self.selected.expect("attached time-travel requires a selection")].id,
-                    mode: crate::edit::time_travel::TravelMode::Attached,
-                }];
+                return vec![Effect::TimeTravel(
+                    self.rows[self.selected.expect("time-travel requires a selection")].id,
+                )];
             }
             Action::TogglePin => {
                 if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
@@ -2166,6 +2160,17 @@ impl App {
             })
     }
 
+    pub(crate) fn can_forkpoint(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && !self.worktree_conflicted
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.worktree_head.is_some()
+            && self.worktree_branch.is_some_and(|(_, detached)| detached)
+    }
+
     pub(crate) fn review_selection_active(&self) -> bool {
         self.review_tip.is_some()
     }
@@ -2276,13 +2281,6 @@ impl App {
             && self.selected.and_then(|index| self.rows.get(index)).is_some()
     }
 
-    pub(crate) fn attached_time_travel_shortcut_visible(&self) -> bool {
-        self.time_travel_shortcut_visible()
-            && self.worktree_branch.is_some_and(|(tip, detached)| {
-                detached || self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) != Some(tip)
-            })
-    }
-
     fn last_selectable(&self) -> Option<usize> {
         self.rows.len().checked_sub(1)
     }
@@ -3410,44 +3408,15 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(vec![row(1)]);
         assert!(app.update(Action::TimeTravel).is_empty());
-        assert!(app.update(Action::AttachedTimeTravel).is_empty());
         complete(&mut app);
-        assert_eq!(
-            app.update(Action::TimeTravel),
-            vec![Effect::TimeTravel {
-                id: id(1),
-                mode: crate::edit::time_travel::TravelMode::Detached,
-            }]
-        );
-        assert!(
-            app.update(Action::AttachedTimeTravel).is_empty(),
-            "attached travel requires a current-worktree branch"
-        );
-        app.set_worktree_branch(Some((id(2), false)));
-        assert_eq!(
-            app.update(Action::AttachedTimeTravel),
-            vec![Effect::TimeTravel {
-                id: id(1),
-                mode: crate::edit::time_travel::TravelMode::Attached,
-            }]
-        );
-        app.set_worktree_branch(Some((id(1), false)));
-        assert!(
-            app.update(Action::AttachedTimeTravel).is_empty(),
-            "moving the branch to its current tip is not offered"
-        );
+        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
         app.set_worktree_branch(Some((id(1), true)));
-        assert_eq!(
-            app.update(Action::AttachedTimeTravel),
-            vec![Effect::TimeTravel {
-                id: id(1),
-                mode: crate::edit::time_travel::TravelMode::Attached,
-            }],
-            "a detached worktree may reattach without moving its remembered branch"
-        );
+        app.set_worktree_head(Some(id(1)), false);
+        assert!(app.can_forkpoint());
+        assert_eq!(app.update(Action::Forkpoint), vec![Effect::Forkpoint]);
         app.set_worktree_changes_available(false);
         assert!(app.update(Action::TimeTravel).is_empty());
-        assert!(app.update(Action::AttachedTimeTravel).is_empty());
+        assert!(app.update(Action::Forkpoint).is_empty());
         assert_eq!(app.update(Action::TogglePin), vec![Effect::TogglePin(id(1))]);
     }
 
@@ -3456,29 +3425,23 @@ mod tests {
         let mut app = App::new(2);
         app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
         app.set_worktree_head(Some(id(2)), false);
-        app.set_worktree_branch(Some((id(2), false)));
         complete(&mut app);
         app.update(Action::MoveDown);
         assert!(app.time_travel_shortcut_visible());
-        assert!(app.attached_time_travel_shortcut_visible());
 
         app.set_worktree_conflicted(true);
         assert!(!app.time_travel_shortcut_visible());
-        assert!(!app.attached_time_travel_shortcut_visible());
         assert!(app.update(Action::TimeTravel).is_empty());
-        assert!(app.update(Action::AttachedTimeTravel).is_empty());
         app.set_worktree_conflicted(false);
         assert!(app.changes_visible(), "changes are normally shown while enabled");
         app.arm_rebase_conflict(id(1));
         assert!(!app.time_travel_shortcut_visible());
-        assert!(!app.attached_time_travel_shortcut_visible());
         assert!(
             !app.changes_visible(),
             "an in-memory conflict preview cannot be loaded by an on-disk changes view"
         );
         app.clear_rebase_conflict();
         assert!(app.time_travel_shortcut_visible());
-        assert!(app.attached_time_travel_shortcut_visible());
         assert!(app.changes_visible(), "clearing the preview restores the changes view");
     }
 
@@ -3858,13 +3821,7 @@ mod tests {
         assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(id(4))]);
         assert!(!app.can_reword());
         assert!(!app.can_forget());
-        assert_eq!(
-            app.update(Action::TimeTravel),
-            vec![Effect::TimeTravel {
-                id: id(4),
-                mode: crate::edit::time_travel::TravelMode::Detached,
-            }]
-        );
+        assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(4))]);
         assert!(
             app.update(Action::VerifySignatures).is_empty(),
             "hidden signatures are not actionable"
@@ -4183,7 +4140,6 @@ mod tests {
         app.update(Action::Rebase);
         app.update(Action::RebaseUpdate);
         app.update(Action::TimeTravel);
-        app.update(Action::AttachedTimeTravel);
         assert!(app.commit_expanded, "grouped commit commands keep the group open");
 
         app.update(Action::MoveDown);
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index bae2fe256f0..f5439959bbf 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -30,17 +30,10 @@ pub(crate) enum Perform {
     Conflict(Conflict),
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub(crate) enum TravelMode {
-    Detached,
-    Attached,
-}
-
 #[derive(Clone, Debug)]
-struct AttachedTravel {
+struct RememberedBranch {
     branch: gix::refs::FullName,
     branch_tip: ObjectId,
-    head: ObjectId,
 }
 
 impl Perform {
@@ -60,7 +53,6 @@ pub(crate) struct Conflict {
     revisions: Vec<OsString>,
     include_worktrees: bool,
     ref_rewrites: Vec<super::rebase::RefRewrite>,
-    attached: Option<AttachedTravel>,
 }
 
 impl Conflict {
@@ -70,41 +62,18 @@ impl Conflict {
 
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
     pub(crate) fn accept(self) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
-        if let Some(attached) = self.attached.as_ref() {
-            let repository = open_repository(&self.repository_path, self.bare, false)
-                .context("could not reopen repository before accepting attached time-travel")?;
-            validate_attached_travel(&repository, attached)?;
-        }
         let mut conflict = self.rebase.persist()?;
         let mut ref_rewrites = self.ref_rewrites;
         ref_rewrites.append(&mut conflict.ref_rewrites);
-        let notice = match self.attached {
-            Some(mut attached) => {
-                attached.head = conflict
-                    .map(attached.head)
-                    .context("HEAD disappeared while preparing the time-travel conflict")?;
-                attached.branch_tip = conflict
-                    .map(attached.branch_tip)
-                    .context("the worktree branch disappeared while preparing the time-travel conflict")?;
-                move_attached_head_to(
-                    &self.repository_path,
-                    self.bare,
-                    conflict.commit,
-                    attached,
-                    &self.revisions,
-                    self.include_worktrees,
-                )?
-            }
-            None => move_head_to(
-                &self.repository_path,
-                self.bare,
-                conflict.commit,
-                None,
-                &self.revisions,
-                self.include_worktrees,
-                |id| conflict.map(id),
-            )?,
-        }
+        let notice = move_head_to(
+            &self.repository_path,
+            self.bare,
+            conflict.commit,
+            None,
+            &self.revisions,
+            self.include_worktrees,
+            |id| conflict.map(id),
+        )?
         .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
         delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
         conflict.materialize()?;
@@ -349,231 +318,126 @@ where
     Ok(Some(notice))
 }
 
-fn resolve_attached_travel(
-    repository: &gix::Repository,
-    head_reference: Option<gix::refs::FullName>,
-    head: ObjectId,
-) -> Result<AttachedTravel> {
-    match head_reference {
-        Some(branch) => {
-            if !branch.as_bstr().starts_with(b"refs/heads/") {
-                anyhow::bail!("attached time-travel requires HEAD to point to a local branch");
-            }
-            Ok(AttachedTravel {
-                branch,
-                branch_tip: head,
-                head,
-            })
-        }
-        None => {
-            let pin = history::all_pins(repository)?
-                .into_iter()
-                .find(history::Pin::is_head)
-                .context("attached time-travel from detached HEAD requires a valid HEAD pin")?;
-            let branch = pin
-                .target
-                .try_name()
-                .context("the HEAD pin must point to a local branch")?
-                .to_owned();
-            if !branch.as_bstr().starts_with(b"refs/heads/") {
-                anyhow::bail!("the HEAD pin must point to a local branch");
-            }
-            Ok(AttachedTravel {
-                branch,
-                branch_tip: pin.id,
-                head,
-            })
-        }
+fn remembered_branch(repository: &gix::Repository) -> Result<RememberedBranch> {
+    let pin = history::all_pins(repository)?
+        .into_iter()
+        .find(history::Pin::is_head)
+        .context("setting a forkpoint requires a valid HEAD pin")?;
+    let branch = pin
+        .target
+        .try_name()
+        .context("the HEAD pin must point to a local branch")?
+        .to_owned();
+    if !branch.as_bstr().starts_with(b"refs/heads/") {
+        anyhow::bail!("the HEAD pin must point to a local branch");
     }
+    Ok(RememberedBranch {
+        branch,
+        branch_tip: pin.id,
+    })
 }
 
-fn validate_attached_travel(repository: &gix::Repository, attached: &AttachedTravel) -> Result<bool> {
-    if !attached.branch.as_bstr().starts_with(b"refs/heads/") {
-        anyhow::bail!("attached time-travel requires a local branch");
-    }
+fn validate_forkpoint(repository: &gix::Repository, head_id: ObjectId, remembered: &RememberedBranch) -> Result<()> {
     let head = repository
         .head()
-        .context("could not read HEAD before attached time-travel")?;
-    let head_id = head
-        .id()
-        .map(gix::Id::detach)
-        .context("cannot time-travel from an unborn HEAD")?;
-    if head_id != attached.head {
-        anyhow::bail!("HEAD changed while preparing attached time-travel");
+        .context("could not read HEAD before setting the forkpoint")?;
+    if !head.is_detached() || head.id().map(gix::Id::detach) != Some(head_id) {
+        anyhow::bail!("HEAD changed while preparing the forkpoint");
     }
-    let head_reference = head.referent_name().map(ToOwned::to_owned);
     drop(head);
-    let head_is_detached = match head_reference {
-        Some(reference) if reference == attached.branch => false,
-        Some(reference) => anyhow::bail!(
-            "HEAD changed from {} to {} while preparing attached time-travel",
-            attached.branch.shorten(),
-            reference.shorten()
-        ),
-        None => {
-            let pin = history::all_pins(repository)?
-                .into_iter()
-                .find(history::Pin::is_head)
-                .context("the HEAD pin disappeared while preparing attached time-travel")?;
-            if pin.target.try_name() != Some(attached.branch.as_ref()) || pin.id != attached.branch_tip {
-                anyhow::bail!("the HEAD pin changed while preparing attached time-travel");
-            }
-            true
-        }
-    };
+    let pin = history::all_pins(repository)?
+        .into_iter()
+        .find(history::Pin::is_head)
+        .context("the HEAD pin disappeared while preparing the forkpoint")?;
+    if pin.target.try_name() != Some(remembered.branch.as_ref()) || pin.id != remembered.branch_tip {
+        anyhow::bail!("the HEAD pin changed while preparing the forkpoint");
+    }
     let branch_id = repository
-        .find_reference(attached.branch.as_ref())
-        .context("the worktree branch disappeared while preparing attached time-travel")?
+        .find_reference(remembered.branch.as_ref())
+        .context("the remembered branch disappeared while preparing the forkpoint")?
         .try_id()
-        .context("the worktree branch must be a direct reference")?
+        .context("the remembered branch must be a direct reference")?
         .detach();
-    if branch_id != attached.branch_tip {
-        anyhow::bail!("the worktree branch changed while preparing attached time-travel");
+    if branch_id != remembered.branch_tip {
+        anyhow::bail!("the remembered branch changed while preparing the forkpoint");
     }
-    ensure_branch_is_available(repository, attached.branch.as_ref())?;
-    Ok(head_is_detached)
+    ensure_branch_is_available(repository, remembered.branch.as_ref())
 }
 
-fn move_attached_head_to(
+pub(crate) fn forkpoint(
     repository_path: &Path,
     bare: bool,
-    selected: ObjectId,
-    attached: AttachedTravel,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<Option<String>> {
-    let repository = open_repository(repository_path, bare, false)
-        .context("could not open repository for attached time-travel checkout")?;
-    let workdir = repository
+) -> Result<String> {
+    let repository =
+        open_repository(repository_path, bare, false).context("could not open repository to set the forkpoint")?;
+    repository
         .workdir()
-        .context("time-travel requires a worktree")?
-        .to_owned();
-    let head_is_detached = validate_attached_travel(&repository, &attached)?;
-    if !head_is_detached && selected == attached.head {
-        return Ok(None);
-    }
-
-    let destination_pin = selected_pin(&repository, selected)?;
-    let old_tree = repository
-        .find_commit(attached.head)
-        .context("could not find the attached time-travel departure")?
-        .tree_id()
-        .context("could not read the attached time-travel departure tree")?
-        .detach();
-    let new_tree = repository
-        .find_commit(selected)
-        .context("could not find the attached time-travel destination")?
-        .tree_id()
-        .context("could not read the attached time-travel destination tree")?
-        .detach();
-    if old_tree != new_tree {
-        super::forget::preflight_tree_transition(&repository, &workdir, old_tree, new_tree)
-            .context("local changes conflict with attached time-travel")?;
-    }
-
-    let mut provisional = Vec::new();
-    for departure in [attached.head, attached.branch_tip] {
-        if departure == selected
-            || provisional
-                .iter()
-                .any(|(pin, _): &(history::Pin, bool)| pin.id == departure)
-            || contains(&repository, departure, selected)
-        {
-            continue;
-        }
-        match create_or_reuse_pin(
-            &repository,
-            Target::Object(departure),
-            departure,
-            "tix attached time-travel",
-        ) {
-            Ok(pin) => provisional.push(pin),
-            Err(err) => {
-                return Err(cleanup_new_pins(&repository, &provisional, err));
-            }
-        }
-    }
-
-    let mut forward = Vec::new();
-    let mut rollback = Vec::new();
-    if attached.branch_tip != selected {
-        forward.push(attached_ref_edit(
-            attached.branch.clone(),
-            Target::Object(attached.branch_tip),
-            Target::Object(selected),
-        ));
-        rollback.push(attached_ref_edit(
-            attached.branch.clone(),
-            Target::Object(selected),
-            Target::Object(attached.branch_tip),
-        ));
+        .context("setting a forkpoint requires a worktree")?;
+    let head = repository
+        .head()
+        .context("could not read HEAD before setting the forkpoint")?;
+    if !head.is_detached() {
+        anyhow::bail!("setting a forkpoint requires detached HEAD");
     }
-    if head_is_detached {
-        let head: gix::refs::FullName = "HEAD".try_into().expect("valid reference name");
-        forward.push(attached_ref_edit(
-            head.clone(),
-            Target::Object(attached.head),
-            Target::Symbolic(attached.branch.clone()),
-        ));
-        rollback.push(attached_ref_edit(
-            head,
-            Target::Symbolic(attached.branch.clone()),
-            Target::Object(attached.head),
+    let head_id = head
+        .id()
+        .map(gix::Id::detach)
+        .context("setting a forkpoint requires an existing HEAD commit")?;
+    drop(head);
+    let remembered = remembered_branch(&repository)?;
+    validate_forkpoint(&repository, head_id, &remembered)?;
+
+    let destination_pin = selected_pin(&repository, head_id)?;
+    let provisional = (remembered.branch_tip != head_id && !contains(&repository, remembered.branch_tip, head_id))
+        .then(|| {
+            create_or_reuse_pin(
+                &repository,
+                Target::Object(remembered.branch_tip),
+                remembered.branch_tip,
+                "tix forkpoint departure",
+            )
+        })
+        .transpose()?;
+    let mut edits = Vec::with_capacity(2);
+    if remembered.branch_tip != head_id {
+        edits.push(checked_ref_edit(
+            remembered.branch.clone(),
+            Target::Object(remembered.branch_tip),
+            Target::Object(head_id),
+            "tix forkpoint",
         ));
     }
+    edits.push(checked_ref_edit(
+        "HEAD".try_into().expect("valid reference name"),
+        Target::Object(head_id),
+        Target::Symbolic(remembered.branch.clone()),
+        "tix forkpoint",
+    ));
     if let Err(err) = repository
-        .edit_references(forward)
-        .context("could not move the worktree branch for attached time-travel")
+        .edit_references(edits)
+        .context("could not move the remembered branch to the forkpoint")
     {
-        return Err(cleanup_new_pins(&repository, &provisional, err));
-    }
-    if old_tree != new_tree
-        && let Err(err) = super::forget::apply_tree_transition(&workdir, old_tree, new_tree)
-            .context("could not update the worktree for attached time-travel")
-    {
-        if let Err(rollback_err) = repository
-            .edit_references(rollback)
-            .context("could not roll back attached time-travel references")
-        {
-            return Err(err.context(format!(
-                "reference rollback failed: {rollback_err:#}; provisional pins retained"
-            )));
-        }
-        return Err(cleanup_new_pins(&repository, &provisional, err));
+        return Err(match provisional.as_ref() {
+            Some(pin) => cleanup_new_pins(&repository, std::slice::from_ref(pin), err),
+            None => err,
+        });
     }
 
-    let mut notice = if attached.branch_tip == selected {
-        format!("reattached HEAD to {}", attached.branch.shorten())
-    } else {
-        format!("moved {} to {}", attached.branch.shorten(), selected.to_hex_with_len(7))
-    };
+    let mut notice = format!(
+        "set {} forkpoint to {}",
+        remembered.branch.shorten(),
+        head_id.to_hex_with_len(7)
+    );
     if let Some(pin) = destination_pin
         && let Err(err) = delete_pin(&repository, &pin)
     {
         notice = format!("{notice}; destination pin remains: {err:#}");
     }
-    match reconcile_head_pin(&repository, &workdir) {
-        Ok(Some(addition)) => notice = format!("{notice}; {addition}"),
-        Ok(None) => {}
-        Err(err) => notice = format!("{notice}; HEAD pin reconciliation failed: {err:#}"),
-    }
-    for (pin, _) in provisional {
-        let snapshot = match history::snapshot_ignoring_pin(
-            &repository,
-            revisions,
-            &[],
-            include_worktrees,
-            Some(pin.name.as_bstr()),
-        ) {
-            Ok(snapshot) => snapshot,
-            Err(err) => {
-                notice = format!(
-                    "{notice}; kept {} because reachability could not be checked: {err:#}",
-                    pin_label(&pin)
-                );
-                continue;
-            }
-        };
+    if let Some((pin, _)) = provisional {
+        let snapshot =
+            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
         if snapshot
             .view_tips
             .iter()
@@ -587,10 +451,10 @@ fn move_attached_head_to(
             notice = format!("{notice}; saved {}", pin_label(&pin));
         }
     }
-    Ok(Some(notice))
+    Ok(notice)
 }
 
-fn attached_ref_edit(name: gix::refs::FullName, old: Target, new: Target) -> RefEdit {
+fn checked_ref_edit(name: gix::refs::FullName, old: Target, new: Target, message: &str) -> RefEdit {
     RefEdit {
         name,
         deref: false,
@@ -598,7 +462,7 @@ fn attached_ref_edit(name: gix::refs::FullName, old: Target, new: Target) -> Ref
             log: LogChange {
                 mode: RefLog::AndReference,
                 force_create_reflog: false,
-                message: "tix attached time-travel".into(),
+                message: message.into(),
             },
             expected: PreviousValue::MustExistAndMatch(old),
             new,
@@ -619,7 +483,7 @@ fn cleanup_new_pins(
     if !edits.is_empty()
         && let Err(err) = repository
             .edit_references(edits)
-            .context("could not remove provisional attached time-travel pins")
+            .context("could not remove provisional forkpoint pins")
     {
         cause = cause.context(format!("provisional pin cleanup failed: {err:#}"));
     }
@@ -629,19 +493,19 @@ fn cleanup_new_pins(
 fn ensure_branch_is_available(repository: &gix::Repository, branch: &gix::refs::FullNameRef) -> Result<()> {
     let current = repository
         .worktree()
-        .context("attached time-travel requires a current worktree")?;
+        .context("setting a forkpoint requires a current worktree")?;
     let current_id = current.id().map(ToOwned::to_owned);
     if current_id.is_some() {
         ensure_worktree_does_not_own_branch(
             repository
                 .main_repo()
-                .context("could not open the main worktree while checking the attached branch")?,
+                .context("could not open the main worktree while checking the remembered branch")?,
             branch,
         )?;
     }
     for proxy in repository
         .worktrees()
-        .context("could not enumerate worktrees while checking the attached branch")?
+        .context("could not enumerate worktrees while checking the remembered branch")?
     {
         if current_id
             .as_ref()
@@ -652,7 +516,7 @@ fn ensure_branch_is_available(repository: &gix::Repository, branch: &gix::refs::
         ensure_worktree_does_not_own_branch(
             proxy
                 .into_repo_with_possibly_inaccessible_worktree()
-                .context("could not inspect a linked worktree while checking the attached branch")?,
+                .context("could not inspect a linked worktree while checking the remembered branch")?,
             branch,
         )?;
     }
@@ -662,7 +526,7 @@ fn ensure_branch_is_available(repository: &gix::Repository, branch: &gix::refs::
 fn ensure_worktree_does_not_own_branch(worktree: gix::Repository, branch: &gix::refs::FullNameRef) -> Result<()> {
     let head = worktree
         .head()
-        .context("could not inspect another worktree HEAD while checking the attached branch")?;
+        .context("could not inspect another worktree HEAD while checking the remembered branch")?;
     if head.referent_name() == Some(branch) {
         anyhow::bail!("{} is checked out in another worktree", branch.shorten());
     }
@@ -686,7 +550,6 @@ pub(crate) fn perform(
         review_roots,
         revisions,
         include_worktrees,
-        TravelMode::Detached,
         |_| {},
     )
 }
@@ -704,7 +567,6 @@ pub(crate) fn perform_reporting_rebased(
     review_roots: &[ObjectId],
     revisions: &[OsString],
     include_worktrees: bool,
-    mode: TravelMode,
     mut report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     let mut repository =
@@ -715,18 +577,7 @@ pub(crate) fn perform_reporting_rebased(
         anyhow::bail!("cannot time-travel from an unborn HEAD");
     };
     let head_was_detached = head.is_detached();
-    let mut attached = match mode {
-        TravelMode::Detached => None,
-        TravelMode::Attached => Some(resolve_attached_travel(
-            &repository,
-            head.referent_name().map(ToOwned::to_owned),
-            head_id,
-        )?),
-    };
     drop(head);
-    if let Some(attached) = attached.as_ref() {
-        validate_attached_travel(&repository, attached)?;
-    }
     if repository
         .index_or_empty()
         .context("could not inspect the index before time-travel")?
@@ -767,7 +618,6 @@ pub(crate) fn perform_reporting_rebased(
                     revisions: revisions.to_vec(),
                     include_worktrees,
                     ref_rewrites,
-                    attached,
                 }));
             }
         };
@@ -783,14 +633,6 @@ pub(crate) fn perform_reporting_rebased(
         head_id = outcome
             .map(head_id)
             .context("HEAD disappeared while completing its rebase")?;
-        if let Some(attached) = &mut attached {
-            attached.head = outcome
-                .map(attached.head)
-                .context("HEAD disappeared while completing its attached time-travel rebase")?;
-            attached.branch_tip = outcome
-                .map(attached.branch_tip)
-                .context("the worktree branch disappeared while completing its rebase")?;
-        }
         review_roots = review_roots.into_iter().filter_map(|id| outcome.map(id)).collect();
         repository = open_repository(repository_path, bare, false)
             .context("could not reopen repository after completing a pending rebase")?;
@@ -816,22 +658,17 @@ pub(crate) fn perform_reporting_rebased(
     } else {
         None
     };
-    let moved = match attached {
-        Some(attached) => {
-            move_attached_head_to(repository_path, bare, selected, attached, revisions, include_worktrees)
-        }
-        None => move_head_to(
-            repository_path,
-            bare,
-            selected,
-            None,
-            revisions,
-            include_worktrees,
-            |actual| {
-                if head_was_detached { Some(head_id) } else { Some(actual) }
-            },
-        ),
-    };
+    let moved = move_head_to(
+        repository_path,
+        bare,
+        selected,
+        None,
+        revisions,
+        include_worktrees,
+        |actual| {
+            if head_was_detached { Some(head_id) } else { Some(actual) }
+        },
+    );
     let mut notice = match moved {
         Ok(notice) => notice,
         Err(err) => {
@@ -1688,126 +1525,78 @@ mod tests {
     }
 
     #[test]
-    fn attached_travel_moves_the_branch_and_preserves_its_departure() -> gix_testtools::Result {
+    fn forkpoint_moves_and_attaches_the_remembered_branch_without_touching_files() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
-        let root = repository.rev_parse_single("main~2")?.detach();
+        let middle = repository.rev_parse_single("main~1")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let graph = loaded_graph(&repository, &[])?;
-        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
         drop(repository);
 
-        let notice = perform_reporting_rebased(
-            &repository_path,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        .complete()?
-        .context("attached travel changes the branch")?;
-        assert!(notice.contains("moved main"), "{notice}");
+        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        std::fs::write(fixture.path().join("root"), "dirty root\n")?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let notice = forkpoint(&repository_path, false, &[], false)?;
+        assert!(notice.contains("set main forkpoint"), "{notice}");
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
             Some(b"refs/heads/main".into()),
-            "attached travel keeps HEAD on its local branch"
-        );
-        assert_eq!(
-            repository.find_reference("refs/heads/main")?.id().detach(),
-            root,
-            "attached travel moves the worktree branch to the selected commit"
+            "HEAD attaches to the remembered branch"
         );
+        assert_eq!(repository.head_id()?.detach(), middle);
+        assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), middle);
         let pins = history::all_pins(&repository)?;
-        assert_eq!(
-            pins.len(),
-            1,
-            "the destination pin is consumed and the departure is retained"
-        );
-        assert_eq!(pins[0].id, main, "the old branch tip remains reachable");
         assert!(
-            pins[0].target.try_name().is_none(),
-            "a moved branch tip needs a direct pin which does not follow the branch"
+            pins.iter().any(|pin| pin.is_head() && pin.id == middle),
+            "the symbolic HEAD pin remains and follows the moved branch"
         );
         assert!(
-            fixture.path().join("root").is_file(),
-            "the destination tree is checked out"
+            pins.iter().any(|pin| !pin.is_head() && pin.id == main),
+            "the departed branch tip remains visible through an ordinary pin"
         );
-        assert!(
-            !fixture.path().join("main").exists(),
-            "files beyond the destination are removed"
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            after.index_tree, before.index_tree,
+            "forkpoint does not update the index"
+        );
+        assert_eq!(
+            after.worktree, before.worktree,
+            "forkpoint does not update worktree files"
         );
         Ok(())
     }
 
     #[test]
-    fn attached_travel_from_detached_head_retains_only_the_outer_departure() -> gix_testtools::Result {
+    fn forkpoint_does_not_pin_a_tip_retained_by_another_branch() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        git(fixture.path(), &["branch", "keep", "main"])?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
-        let root = repository.rev_parse_single("main~2")?.detach();
         let middle = repository.rev_parse_single("main~1")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let graph = loaded_graph(&repository, &[])?;
         drop(repository);
 
         perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
+        forkpoint(&repository_path, false, &["keep".into()], false)?;
         let repository = crate::test_repository::open(fixture.path())?;
-        assert!(repository.head()?.is_detached(), "ordinary travel detaches HEAD first");
-        assert!(
-            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
-            "ordinary travel remembers the worktree branch"
-        );
-        drop(repository);
-
-        perform_reporting_rebased(
-            &repository_path,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        .complete()?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        assert_eq!(
-            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
-            Some(b"refs/heads/main".into()),
-            "attached travel reattaches the remembered branch"
-        );
-        assert_eq!(
-            repository.head_id()?.detach(),
-            root,
-            "HEAD lands at the selected commit"
-        );
-        let pins = history::all_pins(&repository)?;
-        assert_eq!(
-            pins.len(),
-            1,
-            "the old branch tip makes its ancestor departure redundant"
-        );
-        assert_eq!(pins[0].id, main, "the moved branch tip remains pinned directly");
         assert!(
-            pins.iter().all(|pin| !pin.is_head() && pin.id != middle),
-            "the HEAD pin is consumed and the inner detached departure is removed"
+            history::all_pins(&repository)?
+                .iter()
+                .all(|pin| pin.is_head() || pin.id != main),
+            "the keep branch makes an ordinary departure pin redundant"
         );
         Ok(())
     }
 
     #[test]
-    fn attached_travel_rejects_a_branch_owned_by_another_worktree() -> gix_testtools::Result {
+    fn forkpoint_rejects_a_branch_owned_by_another_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
-        let root = repository.rev_parse_single("main~2")?.detach();
         let middle = repository.rev_parse_single("main~1")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
         let graph = loaded_graph(&repository, &[])?;
@@ -1824,19 +1613,8 @@ mod tests {
             .status()?;
         assert!(worktree.success(), "the remembered branch moves to another worktree");
 
-        let err = perform_reporting_rebased(
-            &repository_path,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )
-        .and_then(Perform::complete)
-        .expect_err("a branch cannot become attached in two worktrees");
+        let err = forkpoint(&repository_path, false, &[], false)
+            .expect_err("a branch cannot become attached in two worktrees");
         assert!(
             format!("{err:#}").contains("checked out in another worktree"),
             "{err:#}"
@@ -1844,12 +1622,12 @@ mod tests {
         let repository = crate::test_repository::open(fixture.path())?;
         assert!(
             repository.head()?.is_detached(),
-            "failed attached travel retains detached HEAD"
+            "failed forkpoint retains detached HEAD"
         );
         assert_eq!(
             repository.head_id()?.detach(),
             middle,
-            "failed travel retains its departure"
+            "failed forkpoint retains its departure"
         );
         assert_eq!(
             repository.find_reference("refs/heads/main")?.id().detach(),
@@ -1863,7 +1641,7 @@ mod tests {
     }
 
     #[test]
-    fn attached_travel_accepts_the_branch_of_the_current_linked_worktree() -> gix_testtools::Result {
+    fn forkpoint_accepts_the_branch_of_the_current_linked_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let linked = fixture.path().join("topic-wt");
         let worktree = Command::new("git")
@@ -1893,178 +1671,17 @@ mod tests {
         );
         drop(repository);
 
-        perform_reporting_rebased(
-            &git_dir,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        .complete()?;
+        forkpoint(&git_dir, false, &[], false)?;
         let repository = open_repository(&git_dir, false, false)?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
             Some(branch.as_bstr().to_owned()),
-            "attached travel reattaches the current linked worktree branch"
+            "forkpoint reattaches the current linked worktree branch"
         );
         assert_eq!(
             repository.find_reference(branch.as_ref())?.id().detach(),
             root,
-            "attached travel moves the linked worktree branch"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn failed_attached_ref_update_restores_only_new_departure_pins() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        let repository_path = repository.git_dir().to_owned();
-        let root = repository.rev_parse_single("main~2")?.detach();
-        let middle = repository.rev_parse_single("main~1")?.detach();
-        let main = repository.rev_parse_single("main")?.detach();
-        let graph = loaded_graph(&repository, &[])?;
-        drop(repository);
-
-        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
-        let index_before = std::fs::read(repository.index_path())?;
-        let snapshot_before = gix_testtools::repository::snapshot(fixture.path())?;
-        let branch_lock = repository.git_dir().join("refs/heads/main.lock");
-        std::fs::write(&branch_lock, b"locked")?;
-        drop(repository);
-
-        let err = perform_reporting_rebased(
-            &repository_path,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )
-        .and_then(Perform::complete)
-        .expect_err("the branch lock rejects the attached ref transaction");
-        std::fs::remove_file(branch_lock)?;
-        assert!(
-            format!("{err:#}").contains("could not move the worktree branch"),
-            "{err:#}"
-        );
-        let repository = crate::test_repository::open(fixture.path())?;
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            snapshot_before,
-            "a failed ref transaction leaves repository references and the worktree unchanged"
-        );
-        assert_eq!(
-            std::fs::read(repository.index_path())?,
-            index_before,
-            "a failed ref transaction leaves the index unchanged"
-        );
-        assert!(
-            repository.head()?.is_detached(),
-            "failed attached travel retains detached HEAD"
-        );
-        assert_eq!(
-            repository.head_id()?.detach(),
-            middle,
-            "failed travel retains its departure"
-        );
-        assert_eq!(
-            repository.find_reference("refs/heads/main")?.id().detach(),
-            main,
-            "the locked branch remains unchanged"
-        );
-        let pins = history::all_pins(&repository)?;
-        assert_eq!(pins.len(), 2, "only the HEAD and destination pins remain");
-        assert!(pins.iter().any(history::Pin::is_head), "the HEAD pin survives failure");
-        assert!(
-            pins.iter().any(|pin| !pin.is_head() && pin.id == root),
-            "the destination pin survives failure"
-        );
-        assert!(
-            pins.iter()
-                .all(|pin| pin.is_head() || pin.id != middle && pin.id != main),
-            "new direct departure pins are cleaned up"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn failed_attached_worktree_update_rolls_back_refs_and_new_pins() -> gix_testtools::Result {
-        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        let repository_path = repository.git_dir().to_owned();
-        let root = repository.rev_parse_single("main~2")?.detach();
-        let middle = repository.rev_parse_single("main~1")?.detach();
-        let main = repository.rev_parse_single("main")?.detach();
-        let graph = loaded_graph(&repository, &[])?;
-        drop(repository);
-
-        perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        create_pin(&repository, Target::Object(root), root, "test attached destination")?;
-        let index_before = std::fs::read(repository.index_path())?;
-        let snapshot_before = gix_testtools::repository::snapshot(fixture.path())?;
-        let index_lock = repository.index_path().with_file_name("index.lock");
-        std::fs::write(&index_lock, b"locked")?;
-        drop(repository);
-
-        let err = perform_reporting_rebased(
-            &repository_path,
-            false,
-            root,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )
-        .and_then(Perform::complete)
-        .expect_err("the index lock rejects the worktree transition after refs move");
-        std::fs::remove_file(index_lock)?;
-        assert!(format!("{err:#}").contains("could not update the worktree"), "{err:#}");
-        let repository = crate::test_repository::open(fixture.path())?;
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            snapshot_before,
-            "a failed worktree transition rolls HEAD, the branch, and worktree back"
-        );
-        assert_eq!(
-            std::fs::read(repository.index_path())?,
-            index_before,
-            "a failed worktree transition leaves the index unchanged"
-        );
-        assert!(repository.head()?.is_detached(), "rollback restores detached HEAD");
-        assert_eq!(
-            repository.head_id()?.detach(),
-            middle,
-            "rollback restores HEAD's commit"
-        );
-        assert_eq!(
-            repository.find_reference("refs/heads/main")?.id().detach(),
-            main,
-            "rollback restores the remembered branch"
-        );
-        let pins = history::all_pins(&repository)?;
-        assert_eq!(pins.len(), 2, "only the pre-existing HEAD and destination pins remain");
-        assert!(pins.iter().any(history::Pin::is_head), "the HEAD pin survives rollback");
-        assert!(
-            pins.iter().any(|pin| !pin.is_head() && pin.id == root),
-            "the destination pin survives rollback"
-        );
-        assert!(
-            pins.iter()
-                .all(|pin| pin.is_head() || pin.id != middle && pin.id != main),
-            "new direct departure pins are removed after successful rollback"
+            "forkpoint moves the linked worktree branch"
         );
         Ok(())
     }
@@ -2333,61 +1950,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn attached_pending_travel_checks_branch_ownership_before_replay() -> gix_testtools::Result {
-        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
-        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let linked = fixture.path().join("main-wt");
-        let worktree = Command::new("git")
-            .arg("-C")
-            .arg(fixture.path())
-            .args(["worktree", "add", "-q"])
-            .arg(&linked)
-            .arg("main")
-            .status()?;
-        assert!(worktree.success(), "another worktree checks out the pending branch");
-        let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let linked_before = gix_testtools::repository::snapshot(&linked)?;
-
-        let err = perform_reporting_rebased(
-            &repository_path,
-            false,
-            tip,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )
-        .and_then(Perform::complete)
-        .expect_err("another worktree must be rejected before pending commits are replayed");
-        assert!(
-            format!("{err:#}").contains("checked out in another worktree"),
-            "{err:#}"
-        );
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            before,
-            "branch ownership rejection leaves the detached source untouched"
-        );
-        assert_eq!(
-            gix_testtools::repository::snapshot(&linked)?,
-            linked_before,
-            "branch ownership rejection does not replay the other worktree"
-        );
-        assert!(
-            super::super::rebase::is_pending(
-                &crate::test_repository::open(fixture.path())?
-                    .find_commit(tip)?
-                    .decode()?
-                    .into_owned()?
-            ),
-            "the pending destination remains unchanged"
-        );
-        Ok(())
-    }
-
     #[test]
     fn conflicting_pending_rebases_are_unobservable_until_accepted() -> gix_testtools::Result {
         let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
@@ -2461,143 +2023,6 @@ mod tests {
         Ok(())
     }
 
-    #[test]
-    fn attached_travel_conflict_moves_and_keeps_the_worktree_branch() -> gix_testtools::Result {
-        let (fixture, repository_path, _root, tip, graph) = pending_conflict_fixture()?;
-        let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let Perform::Conflict(conflict) = perform_reporting_rebased(
-            &repository_path,
-            false,
-            tip,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        else {
-            return Err("attached travel should suspend at its conflicting cherry-pick".into());
-        };
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            before,
-            "preparing an attached conflict changes no repository state"
-        );
-
-        let (_notice, conflict_id, _) = conflict.accept()?;
-        let repository = crate::test_repository::open(fixture.path())?;
-        assert_eq!(
-            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
-            Some(b"refs/heads/main".into()),
-            "materializing an attached conflict keeps HEAD on its worktree branch"
-        );
-        assert_eq!(
-            repository.find_reference("refs/heads/main")?.id().detach(),
-            conflict_id,
-            "the worktree branch moves to the conflicting destination"
-        );
-        assert!(
-            history::all_pins(&repository)?.iter().all(|pin| !pin.is_head()),
-            "an attached conflict leaves no HEAD pin"
-        );
-        assert!(
-            repository
-                .index_or_empty()?
-                .entries()
-                .iter()
-                .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted),
-            "the attached conflict materializes unresolved index stages"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn attached_conflict_rechecks_branch_ownership_before_persisting() -> gix_testtools::Result {
-        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
-        perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
-        let Perform::Conflict(conflict) = perform_reporting_rebased(
-            &repository_path,
-            false,
-            tip,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        else {
-            return Err("attached travel should suspend at its conflicting cherry-pick".into());
-        };
-        let linked = fixture.path().join("main-wt");
-        let worktree = Command::new("git")
-            .arg("-C")
-            .arg(fixture.path())
-            .args(["worktree", "add", "-q"])
-            .arg(&linked)
-            .arg("main")
-            .status()?;
-        assert!(
-            worktree.success(),
-            "another worktree claims the branch before acceptance"
-        );
-        let before = gix_testtools::repository::snapshot(fixture.path())?;
-        let linked_before = gix_testtools::repository::snapshot(&linked)?;
-
-        let err = conflict
-            .accept()
-            .expect_err("conflict acceptance must recheck branch ownership before persisting");
-        assert!(
-            format!("{err:#}").contains("checked out in another worktree"),
-            "{err:#}"
-        );
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            before,
-            "failed acceptance leaves the detached source untouched"
-        );
-        assert_eq!(
-            gix_testtools::repository::snapshot(&linked)?,
-            linked_before,
-            "failed acceptance leaves the owning worktree untouched"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn attached_conflict_rechecks_current_head_before_persisting() -> gix_testtools::Result {
-        let (fixture, repository_path, root, tip, graph) = pending_conflict_fixture()?;
-        let Perform::Conflict(conflict) = perform_reporting_rebased(
-            &repository_path,
-            false,
-            tip,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Attached,
-            |_| {},
-        )?
-        else {
-            return Err("attached travel should suspend at its conflicting cherry-pick".into());
-        };
-        git(fixture.path(), &["branch", "other", &root.to_string()])?;
-        git(fixture.path(), &["checkout", "-q", "other"])?;
-        let before = gix_testtools::repository::snapshot(fixture.path())?;
-
-        let err = conflict
-            .accept()
-            .expect_err("conflict acceptance must recheck HEAD before persisting");
-        assert!(format!("{err:#}").contains("HEAD changed"), "{err:#}");
-        assert_eq!(
-            gix_testtools::repository::snapshot(fixture.path())?,
-            before,
-            "a changed HEAD rejects the stale conflict without rewriting its former branch"
-        );
-        Ok(())
-    }
-
     #[test]
     fn time_travel_materializes_only_the_pending_path_to_the_destination() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
@@ -2684,19 +2109,9 @@ mod tests {
         drop(repository);
 
         let mut rebased = Vec::new();
-        perform_reporting_rebased(
-            &repository_path,
-            false,
-            pending_middle,
-            &graph,
-            &[],
-            &[],
-            false,
-            TravelMode::Detached,
-            |id| {
-                rebased.push(id);
-            },
-        )?
+        perform_reporting_rebased(&repository_path, false, pending_middle, &graph, &[], &[], false, |id| {
+            rebased.push(id);
+        })?
         .complete()?;
         assert_eq!(
             rebased,
@@ -2742,7 +2157,6 @@ mod tests {
             &[],
             &[],
             false,
-            TravelMode::Detached,
             |id| rebased.push(id),
         )?
         .complete()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d54d4083cb4..c9549cee597 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2530,7 +2530,18 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("finish review: {err:#}")),
                     }
                 }
-                Effect::TimeTravel { id, mode } => {
+                Effect::Forkpoint => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    match edit::time_travel::forkpoint(&repository_path, repository_is_bare, &revisions, false) {
+                        Ok(notice) => {
+                            app.leave_success(notice);
+                            refresh_pending = true;
+                        }
+                        Err(err) => app.leave_error(format!("forkpoint: {err:#}")),
+                    }
+                }
+                Effect::TimeTravel(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let review_roots: Vec<_> = app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
@@ -2548,7 +2559,6 @@ fn event_loop(
                                         &review_roots,
                                         &revisions,
                                         false,
-                                        mode,
                                         report,
                                     )
                                 },
@@ -4992,6 +5002,9 @@ fn action_with_shortcut_groups(
         }
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
+        KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+            Some(Action::Forkpoint)
+        }
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -5032,8 +5045,6 @@ fn action_with_shortcut_groups(
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
         KeyCode::Char('@') => Some(Action::TimeTravel),
         KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::TimeTravel),
-        KeyCode::Char('#') => Some(Action::AttachedTimeTravel),
-        KeyCode::Char('3') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::AttachedTimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
@@ -6210,21 +6221,6 @@ mod tests {
             None,
             "an unshifted 2 has no time-travel behavior"
         );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('#'), KeyModifiers::NONE)),
-            Some(Action::AttachedTimeTravel),
-            "the terminal's direct hash event invokes attached time travel"
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('3'), KeyModifiers::SHIFT)),
-            Some(Action::AttachedTimeTravel),
-            "terminals which preserve the base character map Shift-3 to attached time travel"
-        );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('3'), KeyModifiers::NONE)),
-            None,
-            "an unshifted 3 has no attached-time-travel behavior"
-        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::SHIFT)),
             Some(Action::Refresh),
@@ -6317,7 +6313,7 @@ mod tests {
                 "{key} is available after the commit prefix"
             );
         }
-        for (key, expected) in [('r', Action::Review), ('s', Action::Squash)] {
+        for (key, expected) in [('r', Action::Review), ('s', Action::Squash), ('f', Action::Forkpoint)] {
             assert_eq!(
                 action_with_shortcut_groups(
                     KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
@@ -6355,18 +6351,6 @@ mod tests {
             Some(Action::TimeTravel),
             "the direct time-travel key remains available while commit is expanded"
         );
-        assert_eq!(
-            action_with_shortcut_groups(
-                KeyEvent::new(KeyCode::Char('#'), KeyModifiers::NONE),
-                false,
-                true,
-                false,
-                false,
-                false
-            ),
-            Some(Action::AttachedTimeTravel),
-            "the direct attached-time-travel key remains available while commit is expanded"
-        );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('b'), KeyModifiers::CONTROL),
@@ -6539,7 +6523,6 @@ mod tests {
             Action::Amend,
             Action::Rebase,
             Action::TimeTravel,
-            Action::AttachedTimeTravel,
             Action::VerifySignatures,
             Action::Quit,
         ] {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 5527f7fb0af..3aafe2dbb38 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -941,7 +941,6 @@ pub(crate) fn draw_with_worktree(
     };
     let mut footer_spans = vec![Span::raw(status)];
     let mut time_travel = None;
-    let mut attached_time_travel = false;
     let mut commit_prefix_spans = Vec::new();
     let mut actions_prefix_spans = Vec::new();
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
@@ -974,7 +973,6 @@ pub(crate) fn draw_with_worktree(
         } else {
             None
         };
-        attached_time_travel = head_visible && app.attached_time_travel_shortcut_visible();
         if app.commit_expanded {
             let mut options = Vec::new();
             if app.can_rebase() {
@@ -1054,6 +1052,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_squash() {
                 options.push(("squash", 's'));
             }
+            if app.can_forkpoint() {
+                options.push(("forkpoint", 'f'));
+            }
             if options.is_empty() {
                 actions_prefix_spans.push(Span::raw("no actions"));
             } else {
@@ -1161,10 +1162,6 @@ pub(crate) fn draw_with_worktree(
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut(label, '@', true));
     }
-    if attached_time_travel {
-        ordered.push(Span::raw(" · "));
-        ordered.extend(shortcut("# attach", '#', true));
-    }
     if app.can_cycle_duplicate() {
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("next duplicate", 'x', true));
@@ -3519,7 +3516,7 @@ mod tests {
     }
 
     #[test]
-    fn advertises_detached_and_attached_travel() -> Result<(), Box<dyn std::error::Error>> {
+    fn advertises_travel_and_return_for_non_head_rows() -> Result<(), Box<dyn std::error::Error>> {
         let selected = gix::ObjectId::Sha1([1; 20]);
         let head = gix::ObjectId::Sha1([2; 20]);
         let mut app = App::new(2);
@@ -3538,7 +3535,6 @@ mod tests {
             signature: SignatureState::Unsigned,
         }]);
         complete(&mut app);
-        app.set_worktree_branch(Some((head, false)));
         let mut decorations = Decorations::from([
             (
                 selected,
@@ -3565,7 +3561,7 @@ mod tests {
                 }],
             ),
         ]);
-        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
         app.commit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
@@ -3603,16 +3599,15 @@ mod tests {
             "hiding refs retains resource markers: {row:?}"
         );
         assert!(
-            rendered_line(&terminal, 1).contains(
-                "commit (reword · new · new-empty · d forget · unpin) · actions · enrich · @ return · # attach · copy"
-            ),
-            "both travel actions stay outside the active commit prefix"
+            rendered_line(&terminal, 1)
+                .contains("commit (reword · new · new-empty · d forget · unpin) · actions · enrich · @ return · copy"),
+            "time travel stays outside the active commit prefix"
         );
         assert!(!rendered_line(&terminal, 1).contains(" · commit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 1).contains(" · @ travel · # attach · copy"));
+        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         app.ref_mode = RefMode::Default;
@@ -3623,7 +3618,6 @@ mod tests {
                 kind: DecorationKind::HeadPinBranch,
             }],
         );
-        app.set_worktree_branch(Some((selected, false)));
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
         assert!(
@@ -3634,7 +3628,6 @@ mod tests {
         assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
-        app.set_worktree_branch(Some((selected, true)));
         decorations.remove(&head);
         decorations.insert(
             selected,
@@ -3652,8 +3645,8 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let footer = rendered_line(&terminal, 1);
         assert!(
-            footer.contains(" · # attach · copy") && !footer.contains("@ travel") && !footer.contains("@ return"),
-            "a detached worktree can reattach at its remembered branch tip: {footer}"
+            !footer.contains("@ travel") && !footer.contains("@ return"),
+            "time travel is hidden at HEAD: {footer}"
         );
         Ok(())
     }

From 877b44cac686abd04ddd69f7482f6bdb301d422d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 21:49:08 +0200
Subject: [PATCH 222/282] feat: add a TUI cherry-move action

The actions prefix can now move the current HEAD change directly above any visible selected commit instead of requiring an ancestral squash target. The planner removes HEAD from its former position, reconnects both sides of the edit, and reparents every target child so forks retain their shape.

Run the operation through the existing history-todo engine so attached and detached checkouts, mutable refs, pins, notes, enrichments, review state, lazy descendants, and materialized conflict continuation keep their established transactional behavior. Root sources, current-position no-ops, and moves that would rewrite merges are rejected.
---
 gix-tix/spec.md            |  14 +-
 gix-tix/src/app.rs         |  84 ++++++++++-
 gix-tix/src/edit/rebase.rs | 297 +++++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs         |  57 ++++++-
 gix-tix/src/ui.rs          |   3 +
 5 files changed, 451 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ffbcf4ceaf9..9e56efa5cef 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -981,12 +981,22 @@ space first; changes blocks adapt within the remaining history width.
   changes at `@`, `c s` spills `@`, `c p` splits staged from unstaged changes,
   and `c d d` confirms forgetting a top commit when each action is available.
 - `a` toggles the actions shortcut group. `a r` starts or finishes a review and
-  `a s` squashes the selected commit, and `a f` establishes the remembered
-  branch's forkpoint at detached `HEAD` when available.
+  `a s` squashes the selected commit, `a m` cherry-moves current `HEAD` directly
+  above the selected commit, and `a f` establishes the remembered branch's
+  forkpoint at detached `HEAD` when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
   forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
+- Cherry-move requires a non-root, single-parent `HEAD`. It removes `HEAD` from
+  its old position, reconnects its former children to its parent, inserts its
+  rewritten change above the selected target, and reparents every former direct
+  child of the target above it. The target may be an ancestor, descendant, or in
+  unrelated history; selecting `HEAD` or its current parent is a no-op. An
+  unchanged merge target is permitted, but any move that would rewrite a merge
+  is unavailable. Mutable refs, pins, Git notes, enrichments, review resources,
+  and attached or detached checkout state follow their rewritten commits.
+  Cherry-move uses the history-todo conflict and continuation rules.
 - `@` invokes time travel directly, outside both groups. Invoking it leaves an
   already expanded commit group open.
 - Commit and action shortcuts keep their respective group open. Navigation or
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 41077a1f296..fc8c98987aa 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -376,6 +376,7 @@ pub(crate) enum Action {
     Rebase,
     RebaseUpdate,
     Squash,
+    Move,
     Review,
     Forkpoint,
     TimeTravel,
@@ -418,6 +419,10 @@ pub(crate) enum Effect {
         source: ObjectId,
         target: ObjectId,
     },
+    Move {
+        source: ObjectId,
+        target: ObjectId,
+    },
     StartReview {
         tip: ObjectId,
         base: ObjectId,
@@ -1057,7 +1062,7 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleActions | Action::Squash | Action::Review | Action::Forkpoint
+            Action::ToggleActions | Action::Squash | Action::Move | Action::Review | Action::Forkpoint
         ) {
             self.actions_expanded = false;
         }
@@ -1392,6 +1397,12 @@ impl App {
                     return vec![Effect::Squash { source, target }];
                 }
             }
+            Action::Move if self.can_move() => {
+                return vec![Effect::Move {
+                    source: self.worktree_head.expect("move availability requires HEAD"),
+                    target: self.rows[self.selected.expect("move requires a selection")].id,
+                }];
+            }
             Action::Review if self.can_finish_review() => {
                 return vec![Effect::FinishReview {
                     review: self.rows[self.selected.expect("finishing review requires a selection")].id,
@@ -2132,6 +2143,33 @@ impl App {
                 })
     }
 
+    pub(crate) fn can_move(&self) -> bool {
+        if self.state != State::Complete
+            || self.changes_focus.is_some()
+            || self.deferred_history_state.unwrap_or(self.state) != State::Complete
+        {
+            return false;
+        }
+        let Some(source) = self
+            .worktree_head
+            .and_then(|head| self.rows.iter().find(|row| row.id == head))
+        else {
+            return false;
+        };
+        let Some((target_index, target)) = self
+            .selected
+            .and_then(|index| self.rows.get(index).map(|row| (index, row)))
+        else {
+            return false;
+        };
+        source.parent_ids.len() == 1
+            && source.id != target.id
+            && source.parent_ids.first().copied() != Some(target.id)
+            && !self.is_row_hidden(target_index)
+            && !self.known_merge_descendants.contains(&source.id)
+            && !self.known_merge_descendants.contains(&target.id)
+    }
+
     pub(crate) fn can_review(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -3705,6 +3743,49 @@ mod tests {
         assert!(!app.can_squash(), "hidden commits cannot be squash targets");
     }
 
+    #[test]
+    fn move_uses_current_head_and_the_selected_target() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(5)), false);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == id(3));
+
+        assert!(app.can_move());
+        assert_eq!(
+            app.update(Action::Move),
+            vec![Effect::Move {
+                source: id(5),
+                target: id(3),
+            }]
+        );
+
+        app.selected = app.rows.iter().position(|row| row.id == id(4));
+        assert!(!app.can_move(), "the current parent is already directly below HEAD");
+        app.set_known_merge_descendants(HashSet::from([id(3)]));
+        app.selected = app.rows.iter().position(|row| row.id == id(3));
+        assert!(!app.can_move(), "a target with an affected merge is rejected");
+
+        let mut merge_target = App::new(10);
+        merge_target.extend_commits(vec![
+            row_with_parents(5, &[4]),
+            row(4),
+            row_with_parents(3, &[2, 1]),
+            row(2),
+            row(1),
+        ]);
+        merge_target.set_worktree_head(Some(id(5)), false);
+        complete(&mut merge_target);
+        merge_target.selected = merge_target.rows.iter().position(|row| row.id == id(3));
+        assert!(merge_target.can_move(), "an unchanged merge target is allowed");
+    }
+
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);
@@ -4161,6 +4242,7 @@ mod tests {
         assert!(app.actions_expanded);
         app.update(Action::Review);
         app.update(Action::Squash);
+        app.update(Action::Move);
         assert!(app.actions_expanded, "grouped actions keep the group open");
         app.update(Action::ToggleActions);
         assert!(!app.actions_expanded, "the prefix key toggles the group");
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 7fe8cbd88c8..a613c55f9e8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -530,6 +530,141 @@ pub(crate) fn squash_plan(
     })
 }
 
+pub(crate) fn cherry_move_plan(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    source: ObjectId,
+    target: ObjectId,
+) -> Result<Plan> {
+    if source == target {
+        anyhow::bail!("the move target must differ from HEAD");
+    }
+    let source_parents = graph.parents_of(source).context("HEAD is not in the loaded history")?;
+    let [source_parent] = source_parents.as_slice() else {
+        anyhow::bail!("moving HEAD requires exactly one parent");
+    };
+    let source_parent = *source_parent;
+    graph
+        .parents_of(target)
+        .context("the move target is not in the loaded history")?;
+    if source_parent == target {
+        anyhow::bail!("HEAD is already directly above the move target");
+    }
+    if repo.head_id()?.detach() != source {
+        anyhow::bail!("the move source must be the current HEAD");
+    }
+
+    let target_rewritten = graph.is_ancestor(source, target);
+    let mut scope = Vec::new();
+    let mut scope_set = HashSet::new();
+    for id in graph
+        .descendants_in_parent_order(source)
+        .context("HEAD is not in the loaded history")?
+        .into_iter()
+        .chain(
+            graph
+                .descendants_in_parent_order(target)
+                .context("the move target is not in the loaded history")?,
+        )
+    {
+        if (id != target || target_rewritten) && scope_set.insert(id) {
+            scope.push(id);
+        }
+    }
+
+    let mut new_parent = HashMap::with_capacity(scope.len());
+    for id in &scope {
+        let parents = graph.parents_of(*id).context("an affected move commit is incomplete")?;
+        let [parent] = parents.as_slice() else {
+            anyhow::bail!("moving HEAD cannot rewrite root or merge commits");
+        };
+        new_parent.insert(
+            *id,
+            if *id == source {
+                target
+            } else if *parent == source {
+                source_parent
+            } else if *parent == target {
+                source
+            } else {
+                *parent
+            },
+        );
+    }
+
+    let mut steps = Vec::with_capacity(scope.len());
+    let mut step_by_id = HashMap::with_capacity(scope.len());
+    while steps.len() < scope.len() {
+        let before = steps.len();
+        for id in &scope {
+            if step_by_id.contains_key(id) {
+                continue;
+            }
+            let parent = new_parent[id];
+            if scope_set.contains(&parent) && !step_by_id.contains_key(&parent) {
+                continue;
+            }
+            let parent = step_by_id
+                .get(&parent)
+                .copied()
+                .map_or(PlanParent::Existing(parent), PlanParent::Step);
+            step_by_id.insert(*id, steps.len());
+            steps.push(PlanStep {
+                parent,
+                commit: PlanCommit::Pick(*id),
+                squash: Vec::new(),
+            });
+        }
+        if steps.len() == before {
+            anyhow::bail!("moving HEAD would create a commit cycle");
+        }
+    }
+
+    let source_step = PlanParent::Step(step_by_id[&source]);
+    let mut ref_scope = scope.clone();
+    if !scope_set.contains(&target) {
+        ref_scope.push(target);
+    }
+    let ref_scope_set: HashSet<_> = ref_scope.iter().copied().collect();
+    let mut non_leaves = HashSet::new();
+    for id in &ref_scope {
+        non_leaves.extend(
+            graph
+                .parents_of(*id)
+                .context("an affected move commit is incomplete")?
+                .into_iter()
+                .filter(|parent| ref_scope_set.contains(parent)),
+        );
+    }
+    let tips: Vec<_> = ref_scope
+        .iter()
+        .copied()
+        .filter(|id| !non_leaves.contains(id))
+        .collect();
+    let mut expected_refs = capture_refs(repo, &ref_scope, &tips)?;
+    for expected in &mut expected_refs {
+        if expected.target == source {
+            expected.placement = Some(source_step);
+        }
+    }
+    let head = repo.head()?;
+    let reference = head
+        .referent_name()
+        .filter(|name| name.category() == Some(Category::LocalBranch))
+        .map(ToOwned::to_owned);
+
+    Ok(Plan {
+        base: source_parent,
+        scope,
+        steps,
+        checkout: Some(PlanCheckout {
+            target: source_step,
+            reference,
+        }),
+        expected_refs,
+    })
+}
+
 #[tracing::instrument(skip_all, fields(signature = ?signature, tree = ?tree_mode))]
 pub(crate) fn perform(
     repo: &gix::Repository,
@@ -2354,6 +2489,20 @@ mod tests {
         )?)
     }
 
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result {
+        let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
+        if output.status.success() {
+            Ok(())
+        } else {
+            Err(format!(
+                "git {} failed: {}",
+                args.join(" "),
+                String::from_utf8_lossy(&output.stderr)
+            )
+            .into())
+        }
+    }
+
     fn set_git_note(repo: &gix::Repository, id: ObjectId, data: &[u8]) -> gix_testtools::Result {
         let mut notes = repo.notes().map_err(gix::Exn::into_error)?;
         let reference = notes
@@ -3331,6 +3480,154 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn cherry_move_inserts_head_before_every_target_child_and_keeps_its_refs() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        git(fixture.path(), &["checkout", "-q", "-b", "side", "HEAD~2"])?;
+        std::fs::write(fixture.path().join("side"), b"side\n")?;
+        git(fixture.path(), &["add", "side"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "side"])?;
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("main~2")?.detach();
+        let middle = repo.rev_parse_single("main~1")?.detach();
+        let source = repo.head_id()?.detach();
+        let side = repo.rev_parse_single("side")?.detach();
+        set_git_note(&repo, source, b"source note")?;
+
+        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?.complete()?;
+        let moved = outcome.map(source).context("HEAD is retained")?;
+        let rewritten_middle = outcome.map(middle).context("the old source ancestry is retained")?;
+        let rewritten_side = outcome.map(side).context("the target's side child is retained")?;
+        assert_eq!(
+            repo.find_commit(moved)?.parent_ids().next().map(gix::Id::detach),
+            Some(target),
+            "HEAD is inserted directly above the target"
+        );
+        for (name, id) in [("middle", rewritten_middle), ("side", rewritten_side)] {
+            assert_eq!(
+                repo.find_commit(id)?.parent_ids().next().map(gix::Id::detach),
+                Some(moved),
+                "the target's {name} child follows moved HEAD"
+            );
+        }
+        assert_eq!(
+            repo.head_id()?.detach(),
+            moved,
+            "the attached branch follows HEAD itself"
+        );
+        assert_eq!(repo.find_reference("refs/heads/side")?.id().detach(), rewritten_side);
+        assert_eq!(git_note(&repo, moved)?.as_deref(), Some(b"source note".as_slice()));
+        Ok(())
+    }
+
+    #[test]
+    fn cherry_move_can_cross_a_descendant_or_unrelated_history() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let middle = repo.rev_parse_single("main~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        drop(repo);
+        git(fixture.path(), &["checkout", "-q", "--detach", &middle.to_string()])?;
+
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("main~2")?.detach();
+        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, middle, tip)?)?.complete()?;
+        let moved = outcome.map(middle).context("detached HEAD is retained")?;
+        let rewritten_tip = outcome.map(tip).context("the descendant target is retained")?;
+        assert_eq!(
+            repo.find_commit(rewritten_tip)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(base),
+            "the target reconnects around HEAD's old position"
+        );
+        assert_eq!(
+            repo.find_commit(moved)?.parent_ids().next().map(gix::Id::detach),
+            Some(rewritten_tip),
+            "HEAD is reinserted above its former descendant"
+        );
+        let repository_path = repo.git_dir().to_owned();
+        super::super::time_travel::checkout_plan(&repository_path, false, &outcome, &[], false)?;
+        let repo = open(fixture.path())?;
+        assert!(repo.head()?.is_detached(), "a detached checkout remains detached");
+        assert_eq!(repo.head_id()?.detach(), moved);
+        drop(repo);
+
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+        git(fixture.path(), &["checkout", "-q", "--orphan", "other"])?;
+        git(fixture.path(), &["rm", "-q", "-r", "-f", "."])?;
+        std::fs::write(fixture.path().join("other"), b"other\n")?;
+        git(fixture.path(), &["add", "other"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "other"])?;
+        let target = open(fixture.path())?.head_id()?.detach();
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+        let repo = open(fixture.path())?;
+        let source = repo.head_id()?.detach();
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?.complete()?;
+        let moved = outcome.map(source).context("HEAD is retained across histories")?;
+        assert_eq!(
+            repo.find_commit(moved)?.parent_ids().next().map(gix::Id::detach),
+            Some(target),
+            "an unrelated target becomes HEAD's parent"
+        );
+        assert_eq!(repo.head_id()?.detach(), moved);
+        Ok(())
+    }
+
+    #[test]
+    fn a_conflicting_cherry_move_produces_a_materializable_continuation() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("HEAD~2")?.detach();
+        let source = repo.head_id()?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let PlanPerform::Conflict(conflict) =
+            perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?
+        else {
+            return Err("moving the tip delta onto the root should conflict".into());
+        };
+        assert_eq!(conflict.original(), source);
+        assert!(
+            conflict
+                .continuation_plan()
+                .steps
+                .iter()
+                .any(|step| matches!(step.commit, PlanCommit::Resolved(_))),
+            "the ordinary todo continuation can resume the move"
+        );
+        drop(conflict);
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "an unmaterialized move conflict leaves the repository unchanged"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn cherry_move_rejects_a_root_head() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let root = repo.rev_parse_single("main~2")?.detach();
+        let target = repo.head_id()?.detach();
+        drop(repo);
+        git(fixture.path(), &["checkout", "-q", "--detach", &root.to_string()])?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let err = cherry_move_plan(&repo, &graph, root, target)
+            .expect_err("root HEAD cannot be removed from its old position");
+        assert!(err.to_string().contains("exactly one parent"), "{err:#}");
+        Ok(())
+    }
+
     #[test]
     fn a_squash_group_reports_one_configured_signature() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c9549cee597..4c3b36b8089 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2465,6 +2465,55 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("squash: {err:#}")),
                     }
                 }
+                Effect::Move { source, target } => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = (|| {
+                        let graph = history_graph
+                            .as_ref()
+                            .context("moving HEAD requires a completed history graph")?;
+                        let mut repository = open_repository(&repository_path, repository_is_bare, false)
+                            .context("could not open repository to move HEAD")?;
+                        repository.object_cache_size(None);
+                        let plan = edit::rebase::cherry_move_plan(&repository, graph, source, target)?;
+                        run_rebase_plan(terminal, repository.into_sync(), graph, plan)
+                    })();
+                    match result {
+                        Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
+                            let moved = outcome.map(source).unwrap_or(source);
+                            let notice = edit::time_travel::checkout_plan(
+                                &repository_path,
+                                repository_is_bare,
+                                &outcome,
+                                &revisions,
+                                false,
+                            );
+                            match notice {
+                                Ok(notice) => app.leave_success(notice.unwrap_or_else(|| {
+                                    format!("moved {} above {}", moved.to_hex_with_len(7), target.to_hex_with_len(7))
+                                })),
+                                Err(err) => app.leave_attention(format!("move applied, checkout failed: {err:#}")),
+                            }
+                            app.select_commit_after_refresh(moved);
+                            invalidate_worktree_changes(&mut worktree_changes);
+                            refresh_pending = true;
+                        }
+                        Ok(edit::rebase::PlanPerform::Conflict(conflict)) => {
+                            let id = conflict.commit();
+                            preview_todo_rebase_conflict(
+                                &mut app,
+                                &conflict,
+                                &authors,
+                                &ref_snapshot.view_tips,
+                                &ref_snapshot.hidden_tips,
+                            )?;
+                            app.arm_rebase_conflict(id);
+                            app.select_commit(id);
+                            pending_todo_rebase_conflict = Some(conflict);
+                        }
+                        Err(err) => app.leave_error(format!("move: {err:#}")),
+                    }
+                }
                 Effect::StartReview { tip, base } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -5002,6 +5051,7 @@ fn action_with_shortcut_groups(
         }
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
+        KeyCode::Char('m') if actions_expanded => Some(Action::Move),
         KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Forkpoint)
         }
@@ -6313,7 +6363,12 @@ mod tests {
                 "{key} is available after the commit prefix"
             );
         }
-        for (key, expected) in [('r', Action::Review), ('s', Action::Squash), ('f', Action::Forkpoint)] {
+        for (key, expected) in [
+            ('r', Action::Review),
+            ('s', Action::Squash),
+            ('m', Action::Move),
+            ('f', Action::Forkpoint),
+        ] {
             assert_eq!(
                 action_with_shortcut_groups(
                     KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 3aafe2dbb38..933d14149bf 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1052,6 +1052,9 @@ pub(crate) fn draw_with_worktree(
             if app.can_squash() {
                 options.push(("squash", 's'));
             }
+            if app.can_move() {
+                options.push(("cherry-move", 'm'));
+            }
             if app.can_forkpoint() {
                 options.push(("forkpoint", 'f'));
             }

From 199ee475cea96e1324de37453742643c619aa950 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Tue, 18 Aug 2026 22:06:38 +0200
Subject: [PATCH 223/282] feat: round history graph connections

The regular history graph used square box-drawing corners while the ref-tree rounded the same lane transitions afterward. Render the four unambiguous turns as rounded corners in the shared lane primitive so TUI history, tix show, and the ref-tree remain visually consistent.

Merge tees and crossings stay orthogonal because they represent three- or four-way junctions and have no rounded Unicode equivalent. This preserves the existing one-commit-per-row layout, paging, and alignment while removing the ref-tree conversion pass.
---
 gix-tix/spec.md         |  2 ++
 gix-tix/src/app.rs      | 12 ++++++------
 gix-tix/src/command.rs  |  7 +++++++
 gix-tix/src/ref_tree.rs | 10 ----------
 4 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 9e56efa5cef..53cbac9d98b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -175,6 +175,8 @@ without trading responsiveness for metadata that is not visible.
 
 - A row contains graph lanes, a seven-character object ID, optional references,
   author date by default, author and attribution information, markers, and title.
+  Simple lane turns use rounded corners in both the TUI and `tix show`; merge
+  tees and crossings remain orthogonal so every commit still occupies one row.
 - The commit marker is blue when unsigned, orange when signed but unverified or
   being verified, green when verified, and bright red when verification fails.
 - The current `HEAD` commit, including a review commit, uses `@` instead of the
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index fc8c98987aa..b50a349c211 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2816,10 +2816,10 @@ fn transition(
                 VERTICAL_LEFT => '┤',
                 DOWN_HORIZONTAL => '┬',
                 UP_HORIZONTAL => '┴',
-                DOWN_RIGHT => '┌',
-                DOWN_LEFT => '┐',
-                UP_RIGHT => '└',
-                UP_LEFT => '┘',
+                DOWN_RIGHT => '╭',
+                DOWN_LEFT => '╮',
+                UP_RIGHT => '╰',
+                UP_LEFT => '╯',
                 HORIZONTAL => '─',
                 _ => '│',
             }
@@ -2971,7 +2971,7 @@ mod tests {
         );
         assert_eq!(
             app.render_lanes(0..app.rows.len()).iter().collect::<Vec<_>>(),
-            ["●─┐ ", "● │ ", "├─● ", "● "]
+            ["●─╮ ", "● │ ", "├─● ", "● "]
         );
     }
 
@@ -3574,7 +3574,7 @@ mod tests {
 
         assert_eq!(
             app.render_lanes(0..app.rows.len()).iter().collect::<Vec<_>>(),
-            ["●─┐ ", "●─┘ ", "● "]
+            ["●─╮ ", "●─╯ ", "● "]
         );
     }
 
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 9d1afec1d1f..f0a19ea9189 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -1014,6 +1014,13 @@ mod tests {
         )
         .expect_err("disabling auto-hide requires an explicit hidden revision");
         assert!(format!("{err:#}").contains("at least one -x/--hide"));
+        let mut rounded = Vec::new();
+        write_history(&repository, &[], &[OsString::from("v1")], &mut rounded)?;
+        let rounded = String::from_utf8(rounded)?;
+        assert!(
+            rounded.contains(['╭', '╮', '╰', '╯']) && !rounded.contains(['┌', '┐', '└', '┘']),
+            "history graph turns use rounded corners: {rounded:?}"
+        );
         create_pins(&repository, &[OsString::from("topic")])?;
         let old_head = repository.head_id()?.detach();
         let parent = repository
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 0be3eedd967..d375eb3a56f 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1169,16 +1169,6 @@ fn place_rail(overview: &Overview, overlay: Option<&Overlay>) -> Placed {
         let node_lane = state.node_line(item.id, item.marker);
         let mut transition = String::new();
         state.advance_ids(item.id, item.parent, Some(&mut transition), item.marker);
-        transition = transition
-            .chars()
-            .map(|symbol| match symbol {
-                '┌' => '╭',
-                '┐' => '╮',
-                '└' => '╰',
-                '┘' => '╯',
-                _ => symbol,
-            })
-            .collect();
         let rounded_transition = transition.contains('─');
         let lane = if rounded_transition {
             node_lane

From fd6cd977e7acb60a9cc7b51d7f37ac575c078b8f Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:11:06 +0200
Subject: [PATCH 224/282] fix: hide non-visible references from tix ref-tree

The diagnostic ref-tree accepted hidden revisions while also adding every normal reference as a visible tip, so hiding a branch could leave the output unchanged. Filter hidden reference tips and labels in the diagnostic renderer, while retaining visible aliases that share their commit.

Infer hidden local defaults from remote HEADs like tix show and rebase todo, with --no-auto-hide as the explicit opt-out. Interactive ref-tree behavior remains unchanged.
---
 gix-tix/spec.md         | 13 +++---
 gix-tix/src/command.rs  | 90 ++++++++++++++++++++++++++++++++++++++---
 gix-tix/src/history.rs  | 28 ++++++++++---
 gix-tix/src/ref_tree.rs | 22 +++++++---
 4 files changed, 131 insertions(+), 22 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 53cbac9d98b..09583dce23d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -90,14 +90,14 @@ without trading responsiveness for metadata that is not visible.
   it when the editor exits. It also accepts `--materialize-conflicts [CONTINUE]`
   to opt into the same conflict checkout and continuation-document workflow as
   `tix rebase apply`; the option requires `--edit-and-apply`.
-- `tix show` and `tix rebase todo` automatically inspect symbolic
+- `tix show`, `tix ref-tree`, and `tix rebase todo` automatically inspect symbolic
   `refs/remotes/<remote>/HEAD` references. Their targets are reverse-mapped
   through each remote's fetch refspec, and existing local commit branches are
   added to the explicit hidden revisions. Multiple remote defaults are
   deduplicated; stale, direct, ambiguous, unmappable, missing, and non-commit
   results are ignored. At least one explicit or inferred hidden revision is
-  required. `--no-auto-hide` disables inference. The interactive history and
-  `ref-tree --hide` retain their explicit-only behavior.
+  required by commands that need a hidden boundary. `--no-auto-hide` disables
+  inference. The interactive history retains its explicit-only behavior.
 - `tix rebase apply [FILE]` applies such a plan from a file, or from standard
   input when `FILE` is omitted or `-`. Removing its state comment or emptying the
   document cancels successfully; malformed or unsupported state is an error.
@@ -337,11 +337,12 @@ without trading responsiveness for metadata that is not visible.
 
 ### Ref-tree diagnostics
 
-- `tix ref-tree` prints the entire reference projection to standard output without
+- `tix ref-tree` prints the non-hidden reference projection to standard output without
   terminal colors, selection state, counts, or viewport clipping. A detached
   current worktree renders as `[pin]` in ASCII output and `📌` with `--unicode`.
-  It traverses
-  all normal references by default; positional revisions scope traversal.
+  It traverses all normal references by default; positional revisions scope
+  traversal. Hidden reference labels and traversal tips are omitted, including
+  local defaults inferred from remote HEADs unless `--no-auto-hide` is given.
 - Worktree traversal is always enabled. `--no-tags` and repeatable
   `-x/--hide <revision>` match the corresponding ref-tree inputs. Output uses
   ASCII lines and `o` nodes by default; `--unicode` uses the interactive
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index f0a19ea9189..89f7e08c306 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -33,7 +33,7 @@ pub struct Platform {
 
 #[derive(Debug, clap::Subcommand)]
 enum Command {
-    /// Print the complete ref-tree without opening the terminal UI.
+    /// Print the ref-tree of non-hidden references without opening the terminal UI.
     RefTree(RefTree),
     /// Print the complete history view without opening the terminal UI.
     Show(Show),
@@ -66,6 +66,9 @@ struct RefTree {
     /// Hide this revision and every commit reachable from it.
     #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
+    /// Do not infer hidden local branches from remote HEADs.
+    #[arg(long)]
+    no_auto_hide: bool,
     /// Use the ref-tree view's Unicode line and node glyphs instead of ASCII.
     #[arg(long)]
     unicode: bool,
@@ -190,15 +193,26 @@ impl Platform {
 }
 
 fn print_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<()> {
+    let rendered = render_ref_tree(repository, args)?;
+    std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes())
+        .context("could not write ref-tree")?;
+    Ok(())
+}
+
+fn render_ref_tree(repository: &gix::Repository, args: RefTree) -> Result<String> {
+    let (hide, unavailable) = crate::history::available_hidden_revisions(repository, &args.hide, !args.no_auto_hide)?;
+    for (revision, err) in unavailable {
+        eprintln!(
+            "warning: ignoring unavailable hidden revision {}: {err}",
+            revision.to_string_lossy()
+        );
+    }
     let revisions = if args.revisions.is_empty() {
         crate::history::ref_tree_revisions(repository, !args.no_tags)?
     } else {
         args.revisions
     };
-    let rendered = crate::ref_tree::render_full(repository, &revisions, &args.hide, !args.no_tags, args.unicode)?;
-    std::io::Write::write_all(&mut std::io::stdout().lock(), rendered.as_bytes())
-        .context("could not write ref-tree")?;
-    Ok(())
+    crate::ref_tree::render_full(repository, &revisions, &hide, !args.no_tags, args.unicode)
 }
 
 fn show(repository: &gix::Repository, args: Show) -> Result<()> {
@@ -636,9 +650,19 @@ mod tests {
         };
         assert!(ref_tree.no_tags);
         assert_eq!(ref_tree.hide, ["private"]);
+        assert!(!ref_tree.no_auto_hide);
         assert!(ref_tree.unicode);
         assert_eq!(ref_tree.revisions, ["main", "topic"]);
 
+        let ref_tree = Cli::try_parse_from(["tix", "ref-tree", "--no-auto-hide"])
+            .expect("ref-tree can disable automatic hiding")
+            .platform
+            .command;
+        let Some(Command::RefTree(ref_tree)) = ref_tree else {
+            panic!("ref-tree was expected")
+        };
+        assert!(ref_tree.no_auto_hide);
+
         let show = Cli::try_parse_from(["tix", "show", "-x", "main", "--hide", "tag", "topic"])
             .expect("show options parse")
             .platform
@@ -876,6 +900,62 @@ mod tests {
         );
     }
 
+    #[test]
+    fn ref_tree_omits_explicit_and_inferred_hidden_references() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let topic = repository.rev_parse_single("topic")?.detach();
+        repository.reference(
+            "refs/heads/visible",
+            topic,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test visible alias",
+        )?;
+
+        let args = |hide, no_auto_hide| RefTree {
+            no_tags: false,
+            hide,
+            no_auto_hide,
+            unicode: false,
+            revisions: Vec::new(),
+        };
+        let all = render_ref_tree(&repository, args(Vec::new(), true))?;
+        let hidden = render_ref_tree(&repository, args(vec!["topic".into()], true))?;
+        assert!(all.contains("topic"), "the complete tree includes topic: {all:?}");
+        assert!(
+            hidden.contains("visible"),
+            "a visible ref sharing the target remains: {hidden:?}"
+        );
+        assert!(
+            !hidden.contains("topic"),
+            "the explicitly hidden label is gone: {hidden:?}"
+        );
+
+        for git_args in [
+            ["config", "remote.origin.url", "https://example.com/repo"].as_slice(),
+            ["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"].as_slice(),
+            ["update-ref", "refs/remotes/origin/main", "main"].as_slice(),
+            ["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/main"].as_slice(),
+        ] {
+            let status = ProcessCommand::new("git")
+                .current_dir(fixture.path())
+                .args(git_args)
+                .status()?;
+            assert!(status.success(), "git {git_args:?} prepares remote HEAD inference");
+        }
+        let repository = crate::test_repository::open(fixture.path())?;
+        let automatic = render_ref_tree(&repository, args(Vec::new(), false))?;
+        assert!(
+            all.contains("@main"),
+            "disabling inference retains the local default: {all:?}"
+        );
+        assert!(
+            !automatic.contains("@main") && automatic.contains("origin/main"),
+            "automatic hiding removes only the inferred local ref: {automatic:?}"
+        );
+        Ok(())
+    }
+
     #[test]
     fn preserves_hide_and_help_semantics() {
         for command in [
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index dd6407266e3..2b359d01945 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1498,7 +1498,10 @@ pub(crate) fn applicable_pins(repo: &gix::Repository) -> Result<Vec<Pin>> {
         .collect())
 }
 
-fn referenced_refs(repo: &gix::Repository, revisions: &[OsString]) -> Result<HashMap<BString, gix::refs::Target>> {
+pub(crate) fn referenced_refs(
+    repo: &gix::Repository,
+    revisions: &[OsString],
+) -> Result<HashMap<BString, gix::refs::Target>> {
     let implicit_head = OsString::from("HEAD");
     let revisions = if revisions.is_empty() {
         std::slice::from_ref(&implicit_head)
@@ -1776,6 +1779,15 @@ impl Authors {
 }
 
 pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[WorktreeCheckout]) -> Result<Decorations> {
+    decorations_excluding(repo, pins, worktrees, &HashSet::new())
+}
+
+pub(crate) fn decorations_excluding(
+    repo: &gix::Repository,
+    pins: &[Pin],
+    worktrees: &[WorktreeCheckout],
+    excluded: &HashSet<BString>,
+) -> Result<Decorations> {
     let mut out = Decorations::new();
     let head_pin_branch = pins
         .iter()
@@ -1796,6 +1808,9 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let full_name = reference.name().to_owned();
+        if excluded.contains(full_name.as_bstr()) {
+            continue;
+        }
         if full_name.as_bstr() == HEAD_PIN_NAME {
             continue;
         }
@@ -1909,11 +1924,12 @@ pub(crate) fn decorations(repo: &gix::Repository, pins: &[Pin], worktrees: &[Wor
             });
         }
     }
-    if let Some(id) = repo
-        .head()
-        .context("could not read HEAD")?
-        .try_peel_to_id()
-        .context("could not peel HEAD")?
+    if !excluded.contains(b"HEAD".as_bstr())
+        && let Some(id) = repo
+            .head()
+            .context("could not read HEAD")?
+            .try_peel_to_id()
+            .context("could not peel HEAD")?
     {
         out.entry(id.detach()).or_default().push(Decoration {
             name: "HEAD".into(),
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index d375eb3a56f..151cae8fcf9 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -1478,22 +1478,32 @@ pub(crate) fn render_full(
     show_tags: bool,
     unicode: bool,
 ) -> anyhow::Result<String> {
-    let refs = crate::history::snapshot(repository, revisions, hidden, true)?;
+    let hidden_refs = if hidden.is_empty() {
+        HashMap::new()
+    } else {
+        crate::history::referenced_refs(repository, hidden)?
+    };
+    let mut visible_revisions = Vec::with_capacity(revisions.len());
+    for revision in revisions {
+        let referenced = crate::history::referenced_refs(repository, std::slice::from_ref(revision))?;
+        if referenced.keys().all(|name| !hidden_refs.contains_key(name)) {
+            visible_revisions.push(revision.clone());
+        }
+    }
+    let mut refs = crate::history::snapshot(repository, &visible_revisions, hidden, true)?;
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
         crate::history::Authors::default(),
     ));
     let mut graph = None;
-    let mut decorations = None;
     crate::history::load(
         repository,
-        revisions,
+        &visible_revisions,
         hidden,
         true,
         &authors,
         &AtomicBool::new(false),
         |event| {
             match event {
-                crate::history::Event::Decorations(value) => decorations = Some(value),
                 crate::history::Event::Complete(value) => graph = Some(value),
                 _ => {}
             }
@@ -1501,7 +1511,9 @@ pub(crate) fn render_full(
         },
     )?;
     let graph = graph.ok_or_else(|| anyhow::anyhow!("history traversal did not produce a graph"))?;
-    let decorations = decorations.unwrap_or_default();
+    let hidden_refs = hidden_refs.into_keys().collect();
+    let decorations = crate::history::decorations_excluding(repository, &refs.pins, &refs.worktrees, &hidden_refs)?;
+    refs.hidden_tips.clear();
     let overview = Overview::new(&graph, &refs, &decorations, show_tags);
     let labels = overview
         .nodes

From f17f1761d16194e3e76d108ce353c883f7767e93 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:15:32 +0200
Subject: [PATCH 225/282] feat: add status as an alias of tix show

The non-interactive history projection is useful as a repository status view, but was only discoverable under the show command. Advertise status as a visible Clap alias and route it through the exact same parser and implementation.
---
 gix-tix/spec.md        |  3 ++-
 gix-tix/src/command.rs | 14 ++++++++++++++
 2 files changed, 16 insertions(+), 1 deletion(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 09583dce23d..b057950f214 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -13,7 +13,8 @@ without trading responsiveness for metadata that is not visible.
 
 - `tix [REVISION]...` shows commits reachable from the supplied revisions, or
   from `HEAD` when none are supplied.
-- `tix show [-x HIDDEN...] [--no-auto-hide] [TIP...]` prints the complete
+- `tix show [-x HIDDEN...] [--no-auto-hide] [TIP...]`, also available through
+  the visible `tix status` alias, prints the complete
   history view without opening a terminal UI. Tips default to `HEAD`, and
   applicable pins participate exactly as they do in the history view. Output
   uses the history view's graph lanes and default metadata, without colors,
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 89f7e08c306..56dce8e4760 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -36,6 +36,7 @@ enum Command {
     /// Print the ref-tree of non-hidden references without opening the terminal UI.
     RefTree(RefTree),
     /// Print the complete history view without opening the terminal UI.
+    #[command(visible_alias = "status")]
     Show(Show),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend(Amend),
@@ -684,6 +685,18 @@ mod tests {
         assert!(show.no_auto_hide);
         assert!(show.hide.is_empty());
 
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "status", "-x", "main"])
+                .expect("status is a visible show alias")
+                .platform
+                .command,
+            Some(Command::Show(_))
+        ));
+        assert!(
+            Cli::command().render_help().to_string().contains("status"),
+            "top-level help advertises the status alias"
+        );
+
         assert!(
             Cli::try_parse_from(["tix", "--worktrees"]).is_err(),
             "the removed TUI worktree option is rejected"
@@ -962,6 +975,7 @@ mod tests {
             &[][..],
             &["ref-tree"],
             &["show"],
+            &["status"],
             &["amend"],
             &["spill"],
             &["split"],

From 7842cc06c6299de5aae06495c5fd83603c551eb3 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:16:25 +0200
Subject: [PATCH 226/282] Clarify tix stash help

The previous description could be read as an ordinary Git stash at the current checkout. State that tix creates a gix stash associated with the HEAD commit, matching the existing storage and restoration behavior.
---
 gix-tix/spec.md        | 4 ++--
 gix-tix/src/command.rs | 9 ++++++++-
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b057950f214..3be9d7bf7bf 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -34,8 +34,8 @@ without trading responsiveness for metadata that is not visible.
   HEAD-pin rules. Replay conflicts change nothing unless explicitly
   materialized; an accepted conflict writes the checkout and unmerged index,
   then exits with an error so resolution cannot be mistaken for completion.
-- `tix stash` saves the index and worktree state at `HEAD` through the same
-  commit-stash operation as the TUI.
+- `tix stash` saves the index and worktree state in a gix stash associated with
+  the `HEAD` commit through the same commit-stash operation as the TUI.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 56dce8e4760..bad56b4b259 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -44,7 +44,7 @@ enum Command {
     Spill,
     /// Split HEAD by amending worktree changes into it and committing staged index changes on top.
     Split(Split),
-    /// Save index and worktree changes at HEAD.
+    /// Save index and worktree changes in a gix stash associated with the HEAD commit.
     Stash,
     /// Pin one or more commits as persistent history tips.
     Pin(Pin),
@@ -907,6 +907,13 @@ mod tests {
                 .contains("Split HEAD by amending worktree changes into it and committing staged index changes on top"),
             "short help explains how split distributes index and worktree changes"
         );
+        assert!(
+            Cli::command()
+                .render_help()
+                .to_string()
+                .contains("gix stash associated with the HEAD commit"),
+            "short help distinguishes a commit-associated gix stash"
+        );
         assert!(
             Cli::command().render_long_help().to_string().contains("GIT_EDITOR"),
             "top-level help explains how to override Git's editor"

From 0302676a39fd87a3d798bd8fd5643b2b83d5db69 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:17:17 +0200
Subject: [PATCH 227/282] feat: add checks-pass tree enrichments

Store checks-pass metadata as worktree-local Git notes keyed by tree ID. Show the marker in the TUI and plain status output, and expose it through the enrich shortcut group.
---
 gix-tix/spec.md        |  13 +++-
 gix-tix/src/app.rs     |  42 ++++++++++-
 gix-tix/src/command.rs |  27 +++++--
 gix-tix/src/enrich.rs  | 158 ++++++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs     |  51 +++++++++++++
 gix-tix/src/ui.rs      |  25 +++++--
 6 files changed, 290 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 3be9d7bf7bf..e150b3691a7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -247,7 +247,12 @@ without trading responsiveness for metadata that is not visible.
   Consequently, rewritten commits retain their metadata and commits sharing a
   change ID share it as well. Malformed enrichments are ignored for display and
   diagnosed, while mutation refuses to overwrite them.
-- Todo and note enrichments receive a leading `🚧` and `📝` respectively before
+- Tree enrichments use the same human-readable Git config format in notes headed
+  at `refs/worktree/tix/enrich-tree`. They are keyed directly by tree object ID;
+  `[tree] checks-pass = true` therefore applies to every commit with that exact
+  tree and naturally disappears when a rewrite changes the tree.
+- Todo, note, and checks-pass enrichments receive a leading `🚧`, `📝`, and `✔️`
+  respectively before
   the graph, with no gap between them or the following status field. The dedicated
   field remains visible alongside selection, dirty-worktree, and conflict markers.
   `tix show` emits the same field and aligns unmarked rows when any displayed
@@ -1014,8 +1019,10 @@ space first; changes blocks adapt within the remaining history width.
 - The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
   `n t` toggles `[commit] todo`, preserving a saved note, and `n o` opens
   `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
-  the todo flag, and toggling todo preserves the note. `n g` edits the real Git
-  note and remains available when the Tix-specific actions are not. The group is mutually
+  the todo flag, and toggling todo preserves the note. `n c` toggles
+  `[tree] checks-pass` for any selected commit, including immutable boundaries.
+  `n g` edits the real Git note and remains available when the commit-specific
+  Tix actions are not. The group is mutually
   exclusive with the view, commit, actions, and information groups and otherwise follows
   their closing behavior.
 
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index b50a349c211..5a4611d48f9 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -356,6 +356,7 @@ pub(crate) enum Action {
     ToggleActions,
     ToggleEnrich,
     ToggleTodo,
+    ToggleChecksPass,
     EditNote,
     EditGitNote,
     ToggleInformation,
@@ -435,6 +436,7 @@ pub(crate) enum Effect {
     TimeTravel(ObjectId),
     TogglePin(ObjectId),
     ToggleTodo(ObjectId),
+    ToggleChecksPass(ObjectId),
     EditNote(ObjectId),
     EditGitNote(ObjectId),
     VerifySignatures(Vec<ObjectId>),
@@ -475,6 +477,7 @@ pub(crate) struct App {
     titles: Vec<u8>,
     notes: HashMap<ObjectId, Vec<BString>>,
     enrichments: HashMap<ObjectId, crate::enrich::Enrichment>,
+    tree_enrichments: HashMap<ObjectId, crate::enrich::TreeEnrichment>,
     graph: Option<Graph>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
@@ -575,6 +578,7 @@ impl App {
             titles: Vec::new(),
             notes: HashMap::new(),
             enrichments: HashMap::new(),
+            tree_enrichments: HashMap::new(),
             graph: None,
             attributions: Vec::new(),
             #[cfg(test)]
@@ -994,8 +998,23 @@ impl App {
             .and_then(|enrichment| enrichment.note.as_ref().map(|note| note.as_bstr()))
     }
 
+    pub(crate) fn tree_enrichment_loaded(&self, id: ObjectId) -> bool {
+        self.tree_enrichments.contains_key(&id)
+    }
+
+    pub(crate) fn set_tree_enrichment(&mut self, id: ObjectId, enrichment: crate::enrich::TreeEnrichment) {
+        self.tree_enrichments.insert(id, enrichment);
+    }
+
+    pub(crate) fn checks_pass(&self, id: ObjectId) -> bool {
+        self.tree_enrichments
+            .get(&id)
+            .is_some_and(|enrichment| enrichment.checks_pass)
+    }
+
     pub(crate) fn clear_enrichments(&mut self) {
         self.enrichments.clear();
+        self.tree_enrichments.clear();
     }
 
     pub(crate) fn render_lanes(&self, range: Range<usize>) -> RenderedLanes {
@@ -1068,7 +1087,11 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleEnrich | Action::ToggleTodo | Action::EditNote | Action::EditGitNote
+            Action::ToggleEnrich
+                | Action::ToggleTodo
+                | Action::ToggleChecksPass
+                | Action::EditNote
+                | Action::EditGitNote
         ) {
             self.enrich_expanded = false;
         }
@@ -1443,6 +1466,11 @@ impl App {
                     self.rows[self.selected.expect("todo requires a selection")].id,
                 )];
             }
+            Action::ToggleChecksPass => {
+                if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                    return vec![Effect::ToggleChecksPass(id)];
+                }
+            }
             Action::EditNote if self.can_reword() => {
                 return vec![Effect::EditNote(
                     self.rows[self.selected.expect("note requires a selection")].id,
@@ -1783,7 +1811,7 @@ impl App {
         self.pending_hidden_rows = None;
         self.titles = Vec::new();
         self.notes.clear();
-        self.enrichments.clear();
+        self.clear_enrichments();
         self.graph = None;
         self.attributions = Vec::new();
         #[cfg(test)]
@@ -4271,6 +4299,11 @@ mod tests {
             vec![Effect::EditGitNote(id(1))],
             "Git notes are available on every selection"
         );
+        assert_eq!(
+            app.update(Action::ToggleChecksPass),
+            vec![Effect::ToggleChecksPass(id(1))],
+            "tree enrichments are available on every selection"
+        );
         assert!(app.enrich_expanded, "the grouped actions keep enrich open");
 
         app.update(Action::MoveDown);
@@ -4291,6 +4324,11 @@ mod tests {
             vec![Effect::EditGitNote(id(1))],
             "immutable boundaries still accept Git notes"
         );
+        assert_eq!(
+            app.update(Action::ToggleChecksPass),
+            vec![Effect::ToggleChecksPass(id(1))],
+            "immutable boundaries still accept tree enrichments"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index bad56b4b259..8ff81bc4cdf 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -315,6 +315,20 @@ fn write_history(
         }
     }
 
+    let mut checks_pass_ids = HashSet::new();
+    let mut tree_enrichments = crate::enrich::open_tree(repository)?;
+    for row in &app.rows {
+        let loaded = crate::enrich::tree_id(repository, row.id)
+            .and_then(|tree_id| crate::enrich::load_tree(&mut tree_enrichments, tree_id));
+        match loaded {
+            Ok(enrichment) if enrichment.checks_pass => {
+                checks_pass_ids.insert(row.id);
+            }
+            Ok(_) => {}
+            Err(err) => tracing::warn!(commit_id = %row.id, error = %err, "ignored malformed tix tree enrichment"),
+        }
+    }
+
     let change_ids = crate::change_id::abbreviations(repository, app.rows.iter().map(|row| row.id), 7)?;
 
     let mailmap = repository.open_mailmap();
@@ -326,6 +340,7 @@ fn write_history(
             Line::raw(crate::enrich::marker(
                 todo_ids.contains(&row.id),
                 enrichment_note_ids.contains(&row.id),
+                checks_pass_ids.contains(&row.id),
             ))
             .width()
         })
@@ -341,8 +356,11 @@ fn write_history(
             note_ids.contains(&row.id),
             change_ids.values.get(&row.id).copied(),
         );
-        let enrichment_marker =
-            crate::enrich::marker(todo_ids.contains(&row.id), enrichment_note_ids.contains(&row.id));
+        let enrichment_marker = crate::enrich::marker(
+            todo_ids.contains(&row.id),
+            enrichment_note_ids.contains(&row.id),
+            checks_pass_ids.contains(&row.id),
+        );
         let ambiguity_marker = if change_ids.ambiguous.contains(&row.id) {
             "💥"
         } else {
@@ -1154,6 +1172,7 @@ mod tests {
         create_pins(&repository, &[OsString::from(orphan.to_string())])?;
         let head_change_id = crate::change_id::for_commit(&repository, head)?;
         assert!(crate::enrich::toggle(&repository, head)?.todo);
+        assert!(crate::enrich::toggle_checks_pass(&repository, head)?.checks_pass);
 
         let mut output = Vec::new();
         write_history(&repository, &[], &[OsString::from("v1")], &mut output)?;
@@ -1206,8 +1225,8 @@ mod tests {
         }
         assert!(output.contains('●'), "history graph lanes are rendered");
         assert!(
-            output.lines().any(|line| line.starts_with("🚧💥├")),
-            "todos directly lead their rows: {output:?}"
+            output.lines().any(|line| line.starts_with("🚧✔️💥├")),
+            "commit and tree enrichments directly lead their rows: {output:?}"
         );
         assert!(output.contains("📌"), "applicable pins are decorated and traversed");
         assert!(
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index 866d3fd6294..7f01a3e31e9 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -8,6 +8,7 @@ use gix::{
 };
 
 pub(crate) const REF_NAME: &str = "refs/worktree/tix/enrich";
+pub(crate) const TREE_REF_NAME: &str = "refs/worktree/tix/enrich-tree";
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub(crate) struct Enrichment {
@@ -15,32 +16,49 @@ pub(crate) struct Enrichment {
     pub note: Option<BString>,
 }
 
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub(crate) struct TreeEnrichment {
+    pub checks_pass: bool,
+}
+
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub(crate) struct Headers {
     pub todo: bool,
     pub message: Option<BString>,
 }
 
-pub(crate) fn marker(todo: bool, note: bool) -> &'static str {
-    match (todo, note) {
-        (true, true) => "🚧📝",
-        (true, false) => "🚧",
-        (false, true) => "📝",
-        (false, false) => "",
+pub(crate) fn marker(todo: bool, note: bool, checks_pass: bool) -> &'static str {
+    match (todo, note, checks_pass) {
+        (true, true, true) => "🚧📝✔️",
+        (true, true, false) => "🚧📝",
+        (true, false, true) => "🚧✔️",
+        (true, false, false) => "🚧",
+        (false, true, true) => "📝✔️",
+        (false, true, false) => "📝",
+        (false, false, true) => "✔️",
+        (false, false, false) => "",
     }
 }
 
 pub(crate) fn open(repo: &gix::Repository) -> Result<gix::note::Platform> {
+    open_at(repo, REF_NAME)
+}
+
+pub(crate) fn open_tree(repo: &gix::Repository) -> Result<gix::note::Platform> {
+    open_at(repo, TREE_REF_NAME)
+}
+
+fn open_at(repo: &gix::Repository, reference: &str) -> Result<gix::note::Platform> {
     repo.notes()
         .map_err(gix::Exn::into_error)
         .context("could not open tix enrichments")?
-        .with_refs([REF_NAME])
+        .with_refs([reference])
         .map_err(gix::Exn::into_error)
         .context("could not select the tix enrich reference")
 }
 
 pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Enrichment> {
-    let config = load_config(notes, change_id)?;
+    let config = load_config(notes, ObjectId::from(change_id))?;
     let Some(config) = config else {
         return Ok(Enrichment::default());
     };
@@ -53,9 +71,21 @@ pub(crate) fn load(notes: &mut gix::note::Platform, change_id: ChangeId) -> Resu
     })
 }
 
-fn load_config(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<Option<File>> {
+pub(crate) fn load_tree(notes: &mut gix::note::Platform, tree_id: ObjectId) -> Result<TreeEnrichment> {
+    let Some(config) = load_config(notes, tree_id)? else {
+        return Ok(TreeEnrichment::default());
+    };
+    Ok(TreeEnrichment {
+        checks_pass: config
+            .boolean("tree.checks-pass")
+            .context("tree.checks-pass is not a boolean")?
+            .unwrap_or(false),
+    })
+}
+
+fn load_config(notes: &mut gix::note::Platform, object_id: ObjectId) -> Result<Option<File>> {
     let found = notes
-        .get(ObjectId::from(change_id))
+        .get(object_id)
         .map_err(gix::Exn::into_error)
         .context("could not load the tix enrichment")?;
     found
@@ -66,6 +96,14 @@ fn load_config(notes: &mut gix::note::Platform, change_id: ChangeId) -> Result<O
         .transpose()
 }
 
+pub(crate) fn tree_id(repo: &gix::Repository, commit_id: ObjectId) -> Result<ObjectId> {
+    repo.find_commit(commit_id)
+        .context("could not find the enriched commit")?
+        .tree_id()
+        .context("could not read the enriched commit tree")
+        .map(gix::Id::detach)
+}
+
 pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enrichment> {
     update(repo, commit_id, |config| {
         let enabled = !config
@@ -98,6 +136,22 @@ pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option
     })
 }
 
+pub(crate) fn toggle_checks_pass(repo: &gix::Repository, commit_id: ObjectId) -> Result<TreeEnrichment> {
+    let tree_id = tree_id(repo, commit_id)?;
+    update_tree(repo, tree_id, |config| {
+        let enabled = !config
+            .boolean("tree.checks-pass")
+            .context("tree.checks-pass is not a boolean")?
+            .unwrap_or(false);
+        config
+            .section_mut_or_create_new("tree", None)
+            .context("could not create the tree enrichment section")?
+            .set("checks-pass", if enabled { "true" } else { "false" })
+            .context("could not update tree.checks-pass")?;
+        Ok(())
+    })
+}
+
 pub(crate) fn apply_headers(
     repo: &gix::Repository,
     commit_id: ObjectId,
@@ -158,7 +212,7 @@ fn update(
 ) -> Result<Enrichment> {
     let change_id = crate::change_id::for_commit(repo, commit_id)?;
     let mut notes = open(repo)?;
-    let mut config = load_config(&mut notes, change_id)?.unwrap_or_default();
+    let mut config = load_config(&mut notes, ObjectId::from(change_id))?.unwrap_or_default();
     edit(&mut config)?;
     let reference: FullName = REF_NAME.try_into().expect("the tix enrich reference is valid");
     notes
@@ -168,6 +222,24 @@ fn update(
     load(&mut notes, change_id)
 }
 
+fn update_tree(
+    repo: &gix::Repository,
+    tree_id: ObjectId,
+    edit: impl FnOnce(&mut File) -> Result<()>,
+) -> Result<TreeEnrichment> {
+    let mut notes = open_tree(repo)?;
+    let mut config = load_config(&mut notes, tree_id)?.unwrap_or_default();
+    edit(&mut config)?;
+    let reference: FullName = TREE_REF_NAME
+        .try_into()
+        .expect("the tix tree enrich reference is valid");
+    notes
+        .add_to_ref(reference.as_ref(), tree_id, config.to_bstring())
+        .map_err(gix::Exn::into_error)
+        .context("could not write the tix tree enrichment")?;
+    load_tree(&mut notes, tree_id)
+}
+
 #[cfg(test)]
 mod tests {
     use std::process::Command;
@@ -232,6 +304,54 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn checks_pass_follows_only_the_exact_tree_and_preserves_other_fields() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            ["user.name=checks author", "user.email=checks@example.com"],
+        )?;
+        let original = repo.head_id()?.detach();
+        let tree = tree_id(&repo, original)?;
+        let reference: FullName = TREE_REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(
+                reference.as_ref(),
+                tree,
+                b"[tree]\n\tchecks-pass = false\n\towner = me\n",
+            )
+            .map_err(gix::Exn::into_error)?;
+
+        assert!(toggle_checks_pass(&repo, original)?.checks_pass);
+        let mut notes = open_tree(&repo)?;
+        let note = notes
+            .get(tree)
+            .map_err(gix::Exn::into_error)?
+            .into_iter()
+            .next()
+            .expect("the tree enrichment exists");
+        let config = File::try_from(note.blob.data.as_bstr())?;
+        assert_eq!(
+            config.string("tree.owner").as_ref().map(|value| value.as_bstr()),
+            Some(b"me".as_bstr())
+        );
+
+        let mut rewritten = repo.find_commit(original)?.decode()?.into_owned()?;
+        rewritten.message = "same tree".into();
+        let rewritten = repo.write_object(&rewritten)?.detach();
+        assert!(
+            load_tree(&mut open_tree(&repo)?, tree_id(&repo, rewritten)?)?.checks_pass,
+            "a message-only rewrite retains the tree marker"
+        );
+        let changed_tree = tree_id(&repo, repo.rev_parse_single("HEAD~1")?.detach())?;
+        assert!(
+            !load_tree(&mut open_tree(&repo)?, changed_tree)?.checks_pass,
+            "a different tree has no marker"
+        );
+        Ok(())
+    }
+
     #[test]
     fn notes_and_todos_are_independent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -326,6 +446,16 @@ mod tests {
             toggle(&repo, id).is_err(),
             "mutation does not replace malformed enrichments"
         );
+        let tree = tree_id(&repo, id)?;
+        let reference: FullName = TREE_REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(reference.as_ref(), tree, b"[tree")
+            .map_err(gix::Exn::into_error)?;
+        assert!(
+            toggle_checks_pass(&repo, id).is_err(),
+            "tree mutation does not replace malformed enrichments"
+        );
         Ok(())
     }
 
@@ -357,6 +487,12 @@ mod tests {
             load(&mut open(&linked)?, change_id)?.todo,
             "linked enrichments survive main-worktree changes"
         );
+        let tree = tree_id(&main, id)?;
+        assert!(toggle_checks_pass(&main, id)?.checks_pass);
+        assert!(
+            !load_tree(&mut open_tree(&linked)?, tree)?.checks_pass,
+            "tree enrichments are also worktree-local"
+        );
         Ok(())
     }
 }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 4c3b36b8089..2b2680885a9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2701,6 +2701,26 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("todo: {err:#}")),
                     }
                 }
+                Effect::ToggleChecksPass(id) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let result = open_repository(&repository_path, repository_is_bare, false)
+                        .context("could not open repository to update the tree enrichment")
+                        .and_then(|repo| enrich::toggle_checks_pass(&repo, id));
+                    match result {
+                        Ok(enrichment) => {
+                            let enabled = enrichment.checks_pass;
+                            app.clear_enrichments();
+                            app.set_tree_enrichment(id, enrichment);
+                            app.leave_success(if enabled {
+                                "marked tree checks-pass"
+                            } else {
+                                "cleared tree checks-pass"
+                            });
+                        }
+                        Err(err) => app.leave_error(format!("checks-pass: {err:#}")),
+                    }
+                }
                 Effect::EditNote(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -3118,6 +3138,11 @@ fn draw(
         .map(|row| row.id)
         .filter(|id| repository_fill_allowed && !app.enrichment_loaded(*id))
         .collect();
+    let tree_enrichments_to_load: Vec<_> = app.rows[start..end]
+        .iter()
+        .map(|row| row.id)
+        .filter(|id| repository_fill_allowed && !app.tree_enrichment_loaded(*id))
+        .collect();
     let changes_visible = app.changes_visible();
     let selected_id = app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id);
     app.selection_relation = selection_cache
@@ -3192,6 +3217,7 @@ fn draw(
     }
     if !notes_to_load.is_empty()
         || !enrichments_to_load.is_empty()
+        || !tree_enrichments_to_load.is_empty()
         || app.rows[start..end].iter().any(|row| !row.metadata_loaded)
         || message_to_load.is_some()
         || tree_changes_to_load.is_some()
@@ -3239,6 +3265,19 @@ fn draw(
                 }
             }
         }
+        if !tree_enrichments_to_load.is_empty() {
+            let mut notes = enrich::open_tree(repository)?;
+            for id in tree_enrichments_to_load {
+                let loaded = enrich::tree_id(repository, id).and_then(|tree_id| enrich::load_tree(&mut notes, tree_id));
+                match loaded {
+                    Ok(enrichment) => app.set_tree_enrichment(id, enrichment),
+                    Err(err) => {
+                        tracing::warn!(commit_id = %id, error = %err, "ignored malformed tix tree enrichment");
+                        app.set_tree_enrichment(id, enrich::TreeEnrichment::default());
+                    }
+                }
+            }
+        }
         for index in start..end {
             if app.rows[index].metadata_loaded {
                 continue;
@@ -5091,6 +5130,7 @@ fn action_with_shortcut_groups(
         KeyCode::Char('s') if commit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if commit_expanded => Some(Action::Forget),
         KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),
+        KeyCode::Char('c') if enrich_expanded => Some(Action::ToggleChecksPass),
         KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
         KeyCode::Char('@') => Some(Action::TimeTravel),
@@ -6200,6 +6240,17 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE)),
             Some(Action::ToggleEnrich)
         );
+        assert_eq!(
+            action_with_shortcut_groups(
+                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+                false,
+                false,
+                false,
+                true,
+                false
+            ),
+            Some(Action::ToggleChecksPass)
+        );
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 933d14149bf..9625daf30f3 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -479,7 +479,14 @@ pub(crate) fn draw_with_worktree(
     let lanes = app.render_lanes(start..render_end);
     let enrichment_gutter = visible_rows
         .iter()
-        .map(|row| Line::raw(crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some())).width())
+        .map(|row| {
+            Line::raw(crate::enrich::marker(
+                app.todo(row.id),
+                app.note(row.id).is_some(),
+                app.checks_pass(row.id),
+            ))
+            .width()
+        })
         .max()
         .unwrap_or_default() as u16;
     let change_id_gutter = visible_rows
@@ -692,6 +699,7 @@ pub(crate) fn draw_with_worktree(
         let enrichment_marker = crate::enrich::marker(
             app.todo(visible_rows[index].id),
             app.note(visible_rows[index].id).is_some(),
+            app.checks_pass(visible_rows[index].id),
         );
         if !enrichment_marker.is_empty() {
             frame.render_widget(
@@ -1154,6 +1162,8 @@ pub(crate) fn draw_with_worktree(
                 ordered.extend(shortcut("note", 'o', app.note(row.id).is_some()));
                 ordered.push(Span::raw(" · "));
             }
+            ordered.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
+            ordered.push(Span::raw(" · "));
             ordered.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
         } else {
             ordered.push(Span::raw("no actions"));
@@ -2656,14 +2666,16 @@ mod tests {
                 note: Some("follow-up *title*\n\nwhy it matters\n".into()),
             },
         );
+        app.set_tree_enrichment(id, crate::enrich::TreeEnrichment { checks_pass: true });
         let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let row = terminal.backend().buffer();
         assert_eq!(row[(0, 0)].symbol(), "🚧", "todo leads the row");
         assert_eq!(row[(2, 0)].symbol(), "📝", "note directly follows todo");
-        assert_eq!(row[(4, 0)].symbol(), ">", "selection directly follows enrichments");
-        assert_eq!(row[(6, 0)].symbol(), "●", "the graph remains separate");
+        assert_eq!(row[(4, 0)].symbol(), "✔️", "tree status follows commit enrichments");
+        assert_eq!(row[(6, 0)].symbol(), ">", "selection directly follows enrichments");
+        assert_eq!(row[(8, 0)].symbol(), "●", "the graph remains separate");
         assert!(
             rendered_line(&terminal, 0).contains("follow-up title"),
             "the selected todo displays its note title"
@@ -2680,7 +2692,7 @@ mod tests {
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).contains("enrich (todo · note · git note)"),
+            rendered_line(&terminal, 1).contains("enrich (todo · note · checks-pass · git note)"),
             "the enrich group advertises all note actions"
         );
         app.enrich_expanded = false;
@@ -2705,8 +2717,9 @@ mod tests {
             "a note replaces the selected title independently of todo"
         );
         assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "📝");
-        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), ">");
-        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "●");
+        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "✔️");
+        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(6, 0)].symbol(), "●");
         Ok(())
     }
 

From b305b0f69f5bdb71f87a139b3028e784b6324ec0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:25:01 +0200
Subject: [PATCH 228/282] feat: add enrich subcommands

Expose commit todo, Tix note, Git note, and tree checks-pass enrichments through nested CLI commands. Targets default to HEAD, accept change IDs, and boolean commands support idempotent --clear updates.
---
 gix-tix/spec.md               |   8 +
 gix-tix/src/command.rs        |  40 +++++
 gix-tix/src/command/enrich.rs | 266 ++++++++++++++++++++++++++++++++++
 gix-tix/src/enrich.rs         |  49 +++++--
 gix-tix/src/lib.rs            |   2 +-
 5 files changed, 352 insertions(+), 13 deletions(-)
 create mode 100644 gix-tix/src/command/enrich.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e150b3691a7..9613633588b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -36,6 +36,14 @@ without trading responsiveness for metadata that is not visible.
   then exits with an error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state in a gix stash associated with
   the `HEAD` commit through the same commit-stash operation as the TUI.
+- `tix enrich commit todo [--clear] [REVSPEC]`, `tix enrich commit note
+  [REVSPEC]`, `tix enrich commit git-note [REVSPEC]`, and `tix enrich tree
+  checks-pass [--clear] [REVSPEC]` expose the TUI's enrichment actions without
+  opening it. Targets default to `HEAD` and accept Git revisions or unambiguous
+  reverse-hex change-ID prefixes from the default Tix view. Boolean commands
+  idempotently set their marker, or clear it with `--clear`; note commands use
+  Git's editor, remove empty notes, and leave unchanged notes alone. Output
+  starts with the target's abbreviated commit and change IDs before its status.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 8ff81bc4cdf..b0c117517d1 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -10,6 +10,7 @@ use clap::Parser;
 use gix::prelude::ReferenceExt;
 use ratatui::text::Line;
 
+mod enrich;
 mod new;
 mod rebase;
 mod reword;
@@ -38,6 +39,9 @@ enum Command {
     /// Print the complete history view without opening the terminal UI.
     #[command(visible_alias = "status")]
     Show(Show),
+    /// Manage commit and tree enrichments.
+    #[command(subcommand)]
+    Enrich(enrich::Command),
     /// Add staged changes, or worktree changes when nothing is staged, to HEAD.
     Amend(Amend),
     /// Move the changes introduced by HEAD into the worktree.
@@ -187,6 +191,7 @@ impl Platform {
             Command::Travel(args) => return travel::run(repository, args),
             Command::Reword(args) => return reword::run(repository, args),
             Command::New(args) => return new::run(repository, args),
+            Command::Enrich(command) => return enrich::run(repository, command),
             Command::Rebase(command) => return rebase::run(repository, command),
         }
         Ok(())
@@ -715,6 +720,34 @@ mod tests {
             "top-level help advertises the status alias"
         );
 
+        for arguments in [
+            &["tix", "enrich", "commit", "todo"][..],
+            &["tix", "enrich", "commit", "todo", "--clear", "topic"][..],
+            &["tix", "enrich", "commit", "note", "topic"][..],
+            &["tix", "enrich", "commit", "git-note"][..],
+            &["tix", "enrich", "tree", "checks-pass"][..],
+            &["tix", "enrich", "tree", "checks-pass", "--clear", "topic"][..],
+        ] {
+            assert!(
+                matches!(
+                    Cli::try_parse_from(arguments)
+                        .expect("enrich command parses")
+                        .platform
+                        .command,
+                    Some(Command::Enrich(_))
+                ),
+                "{arguments:?} reaches the enrich command"
+            );
+        }
+        assert!(
+            Cli::try_parse_from(["tix", "enrich", "commit", "checks-pass"]).is_err(),
+            "tree enrichments are not commit subcommands"
+        );
+        assert!(
+            Cli::try_parse_from(["tix", "enrich", "tree", "todo"]).is_err(),
+            "commit enrichments are not tree subcommands"
+        );
+
         assert!(
             Cli::try_parse_from(["tix", "--worktrees"]).is_err(),
             "the removed TUI worktree option is rejected"
@@ -1008,6 +1041,13 @@ mod tests {
             &["pin"],
             &["travel"],
             &["reword"],
+            &["enrich"],
+            &["enrich", "commit"],
+            &["enrich", "commit", "todo"],
+            &["enrich", "commit", "note"],
+            &["enrich", "commit", "git-note"],
+            &["enrich", "tree"],
+            &["enrich", "tree", "checks-pass"],
             &["rebase"],
             &["rebase", "todo"],
             &["rebase", "apply"],
diff --git a/gix-tix/src/command/enrich.rs b/gix-tix/src/command/enrich.rs
new file mode 100644
index 00000000000..0f718a0ae14
--- /dev/null
+++ b/gix-tix/src/command/enrich.rs
@@ -0,0 +1,266 @@
+use std::ffi::OsString;
+
+use anyhow::{Context, Result};
+use gix::bstr::ByteSlice;
+
+#[derive(Debug, clap::Subcommand)]
+pub(super) enum Command {
+    /// Manage enrichments keyed by a commit's change ID.
+    #[command(subcommand)]
+    Commit(Commit),
+    /// Manage enrichments keyed by a commit's tree ID.
+    #[command(subcommand)]
+    Tree(Tree),
+}
+
+#[derive(Debug, clap::Subcommand)]
+pub(super) enum Commit {
+    /// Mark the commit as todo, or clear the mark.
+    Todo(BooleanTarget),
+    /// Edit the commit's Tix note with Git's editor.
+    Note(Target),
+    /// Edit the commit's ordinary Git note with Git's editor.
+    GitNote(Target),
+}
+
+#[derive(Debug, clap::Subcommand)]
+pub(super) enum Tree {
+    /// Mark the tree as passing checks, or clear the mark.
+    ChecksPass(BooleanTarget),
+}
+
+#[derive(Debug, clap::Args)]
+pub(super) struct BooleanTarget {
+    /// Clear the enrichment instead of setting it.
+    #[arg(long)]
+    clear: bool,
+    #[command(flatten)]
+    target: Target,
+}
+
+#[derive(Debug, clap::Args)]
+pub(super) struct Target {
+    /// Commit whose enrichment should be changed.
+    #[arg(default_value = "HEAD", value_name = "REVSPEC")]
+    revision: OsString,
+}
+
+pub(super) fn run(repository: gix::Repository, command: Command) -> Result<()> {
+    match command {
+        Command::Commit(Commit::Todo(args)) => {
+            let target = resolve(&repository, &args.target)?;
+            let enrichment = crate::enrich::ensure_todo(&repository, target, !args.clear)?;
+            feedback(
+                &repository,
+                target,
+                if enrichment.todo {
+                    "marked commit todo"
+                } else {
+                    "cleared commit todo"
+                },
+            )
+        }
+        Command::Commit(Commit::Note(args)) => edit_note(&repository, &args),
+        Command::Commit(Commit::GitNote(args)) => edit_git_note(&repository, &args),
+        Command::Tree(Tree::ChecksPass(args)) => {
+            let target = resolve(&repository, &args.target)?;
+            let enrichment = crate::enrich::ensure_checks_pass(&repository, target, !args.clear)?;
+            feedback(
+                &repository,
+                target,
+                if enrichment.checks_pass {
+                    "marked tree checks-pass"
+                } else {
+                    "cleared tree checks-pass"
+                },
+            )
+        }
+    }
+}
+
+fn resolve(repository: &gix::Repository, target: &Target) -> Result<gix::ObjectId> {
+    super::resolve_commit(repository, &target.revision, "enrichment target").map(|(id, _)| id)
+}
+
+fn feedback(repository: &gix::Repository, target: gix::ObjectId, status: &str) -> Result<()> {
+    println!("{} {status}", crate::change_id::display(repository, target, 7)?);
+    Ok(())
+}
+
+fn edit_note(repository: &gix::Repository, args: &Target) -> Result<()> {
+    let target = resolve(repository, args)?;
+    let enrichment = crate::enrich::load(
+        &mut crate::enrich::open(repository)?,
+        crate::change_id::for_commit(repository, target)?,
+    )?;
+    let document = enrichment.note.clone().unwrap_or_default();
+    let editor = repository.editor().context("no Git editor is available")?;
+    let edited = crate::edit::edit_document_without_terminal(
+        &editor,
+        &document,
+        &format!("tix-note-{}-{}.md", std::process::id(), target.to_hex_with_len(7)),
+    )?;
+    let cleaned = crate::edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
+    let desired = (!cleaned.is_empty()).then_some(cleaned.as_bstr());
+    let status = if enrichment.note.as_ref().map(|note| note.as_bstr()) == desired {
+        "note unchanged"
+    } else {
+        crate::enrich::set_note(repository, target, desired.map(AsRef::as_ref))?;
+        if desired.is_some() {
+            "saved note"
+        } else {
+            "cleared note"
+        }
+    };
+    feedback(repository, target, status)
+}
+
+fn edit_git_note(repository: &gix::Repository, args: &Target) -> Result<()> {
+    let target = resolve(repository, args)?;
+    let notes = repository.notes().map_err(gix::Exn::into_error)?;
+    let reference = notes
+        .default_ref()
+        .context("no default Git notes reference is configured")?
+        .to_owned();
+    let mut notes = notes.with_refs([reference.as_bstr()]).map_err(gix::Exn::into_error)?;
+    let document = notes
+        .get(target)
+        .map_err(gix::Exn::into_error)?
+        .first()
+        .map(|note| note.blob.data.clone())
+        .unwrap_or_default();
+    let editor = repository.editor().context("no Git editor is available")?;
+    let edited = crate::edit::edit_document_without_terminal(
+        &editor,
+        &document,
+        &format!("tix-git-note-{}-{}.md", std::process::id(), target.to_hex_with_len(7)),
+    )?;
+    let cleaned = crate::edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
+    let status = if cleaned == document {
+        "Git note unchanged"
+    } else {
+        let saved = !cleaned.is_empty();
+        crate::set_git_note(
+            repository,
+            reference.as_ref(),
+            target,
+            saved.then_some(cleaned.as_ref()),
+        )?;
+        if saved { "saved Git note" } else { "cleared Git note" }
+    };
+    feedback(repository, target, status)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn target(revision: &str) -> Target {
+        Target {
+            revision: revision.into(),
+        }
+    }
+
+    #[test]
+    fn boolean_enrichments_are_idempotent_and_target_the_selected_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let topic = repository.rev_parse_single("topic")?.detach();
+        let head = repository.head_id()?.detach();
+
+        for clear in [false, false, true] {
+            run(
+                repository.clone(),
+                Command::Commit(Commit::Todo(BooleanTarget {
+                    clear,
+                    target: target("topic"),
+                })),
+            )?;
+            run(
+                repository.clone(),
+                Command::Tree(Tree::ChecksPass(BooleanTarget {
+                    clear,
+                    target: target("topic"),
+                })),
+            )?;
+            assert_eq!(
+                crate::enrich::load(
+                    &mut crate::enrich::open(&repository)?,
+                    crate::change_id::for_commit(&repository, topic)?,
+                )?
+                .todo,
+                !clear,
+                "todo is set or cleared without toggling"
+            );
+            assert_eq!(
+                crate::enrich::load_tree(
+                    &mut crate::enrich::open_tree(&repository)?,
+                    crate::enrich::tree_id(&repository, topic)?,
+                )?
+                .checks_pass,
+                !clear,
+                "checks-pass is set or cleared without toggling"
+            );
+            if !clear {
+                assert!(
+                    !crate::enrich::load(
+                        &mut crate::enrich::open(&repository)?,
+                        crate::change_id::for_commit(&repository, head)?,
+                    )?
+                    .todo,
+                    "the default HEAD remains untouched"
+                );
+                assert!(
+                    !crate::enrich::load_tree(
+                        &mut crate::enrich::open_tree(&repository)?,
+                        crate::enrich::tree_id(&repository, head)?,
+                    )?
+                    .checks_pass,
+                    "the default HEAD tree remains untouched"
+                );
+            }
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn editors_preserve_other_enrichments() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = crate::test_repository::open_with(fixture.path(), ["core.editor=sed -i.bak -e 's/old/new/'"])?;
+        let topic = repository.rev_parse_single("topic")?.detach();
+        crate::enrich::ensure_todo(&repository, topic, true)?;
+        crate::enrich::set_note(&repository, topic, Some(b"old\n"))?;
+        let notes = repository.notes().map_err(gix::Exn::into_error)?;
+        let reference = notes.default_ref().context("the fixture has a notes ref")?.to_owned();
+        crate::set_git_note(&repository, reference.as_ref(), topic, Some(b"old\n"))?;
+
+        run(repository.clone(), Command::Commit(Commit::Note(target("topic"))))?;
+        run(repository.clone(), Command::Commit(Commit::GitNote(target("topic"))))?;
+
+        let enrichment = crate::enrich::load(
+            &mut crate::enrich::open(&repository)?,
+            crate::change_id::for_commit(&repository, topic)?,
+        )?;
+        assert!(enrichment.todo, "editing a note preserves todo");
+        assert_eq!(
+            enrichment.note.as_ref().map(|note| note.as_bstr()),
+            Some(b"new\n".as_bstr()),
+            "the Tix note uses the editor output"
+        );
+        let mut notes = repository
+            .notes()
+            .map_err(gix::Exn::into_error)?
+            .with_refs([reference.as_bstr()])
+            .map_err(gix::Exn::into_error)?;
+        assert_eq!(
+            notes
+                .get(topic)
+                .map_err(gix::Exn::into_error)?
+                .first()
+                .map(|note| note.blob.data.as_bstr()),
+            Some(b"new\n".as_bstr()),
+            "the ordinary Git note uses the editor output"
+        );
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index 7f01a3e31e9..8b4544ba0b3 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -110,15 +110,27 @@ pub(crate) fn toggle(repo: &gix::Repository, commit_id: ObjectId) -> Result<Enri
             .boolean("commit.todo")
             .context("commit.todo is not a boolean")?
             .unwrap_or(false);
-        config
-            .section_mut_or_create_new("commit", None)
-            .context("could not create the commit enrichment section")?
-            .set("todo", if enabled { "true" } else { "false" })
-            .context("could not update commit.todo")?;
-        Ok(())
+        set_todo(config, enabled)
     })
 }
 
+pub(crate) fn ensure_todo(repo: &gix::Repository, commit_id: ObjectId, enabled: bool) -> Result<Enrichment> {
+    let current = load(&mut open(repo)?, crate::change_id::for_commit(repo, commit_id)?)?;
+    if current.todo == enabled {
+        return Ok(current);
+    }
+    update(repo, commit_id, |config| set_todo(config, enabled))
+}
+
+fn set_todo(config: &mut File, enabled: bool) -> Result<()> {
+    config
+        .section_mut_or_create_new("commit", None)
+        .context("could not create the commit enrichment section")?
+        .set("todo", if enabled { "true" } else { "false" })
+        .context("could not update commit.todo")?;
+    Ok(())
+}
+
 pub(crate) fn set_note(repo: &gix::Repository, commit_id: ObjectId, note: Option<&[u8]>) -> Result<Enrichment> {
     update(repo, commit_id, |config| {
         let mut section = config
@@ -143,15 +155,28 @@ pub(crate) fn toggle_checks_pass(repo: &gix::Repository, commit_id: ObjectId) ->
             .boolean("tree.checks-pass")
             .context("tree.checks-pass is not a boolean")?
             .unwrap_or(false);
-        config
-            .section_mut_or_create_new("tree", None)
-            .context("could not create the tree enrichment section")?
-            .set("checks-pass", if enabled { "true" } else { "false" })
-            .context("could not update tree.checks-pass")?;
-        Ok(())
+        set_checks_pass(config, enabled)
     })
 }
 
+pub(crate) fn ensure_checks_pass(repo: &gix::Repository, commit_id: ObjectId, enabled: bool) -> Result<TreeEnrichment> {
+    let tree_id = tree_id(repo, commit_id)?;
+    let current = load_tree(&mut open_tree(repo)?, tree_id)?;
+    if current.checks_pass == enabled {
+        return Ok(current);
+    }
+    update_tree(repo, tree_id, |config| set_checks_pass(config, enabled))
+}
+
+fn set_checks_pass(config: &mut File, enabled: bool) -> Result<()> {
+    config
+        .section_mut_or_create_new("tree", None)
+        .context("could not create the tree enrichment section")?
+        .set("checks-pass", if enabled { "true" } else { "false" })
+        .context("could not update tree.checks-pass")?;
+    Ok(())
+}
+
 pub(crate) fn apply_headers(
     repo: &gix::Repository,
     commit_id: ObjectId,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 2b2680885a9..94d7d6b6c78 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3889,7 +3889,7 @@ fn edit_git_note(
     Ok(Some(!cleaned.is_empty()))
 }
 
-fn set_git_note(
+pub(crate) fn set_git_note(
     repository: &gix::Repository,
     reference: &gix::refs::FullNameRef,
     id: gix::ObjectId,

From 5b99b9bcf4ea4776482337f184b1a278799df45c Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 05:38:32 +0200
Subject: [PATCH 229/282] feat: show prefix actions in floating menus

Keep prefix labels compact in the footer and render active choices in a connected one-line overlay above it. Clamp the overlay to the terminal, draw it above other content, and preserve the existing interaction behavior.
---
 gix-tix/spec.md   |  18 +-
 gix-tix/src/ui.rs | 419 +++++++++++++++++++++++++++-------------------
 2 files changed, 259 insertions(+), 178 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 9613633588b..5b00713e981 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -401,14 +401,16 @@ full-column alignment so clipped fields can be reached.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
-for signature verification, alignment, message, and changes actions. While expanded,
-the group visually contains every following status action through `<enter> diff`,
-including pane switching and navigation; none of those hints is visible while
-the group is closed, and quit remains outside it. The footer underlines the `v`
-in `view`; an open prefix reverses its complete expanded group for a strong,
-terminal-theme-independent cue. While active, `view (` contains
-every applicable display option and a closing `)` so direct shortcuts remain visibly
-outside the prefix. The history status starts with the history position, then the
+for signature verification, alignment, message, and changes actions. The footer
+keeps every prefix compact. Opening one reverses its label and shows its available
+items in a reversed, single-row popout immediately above and connected to that
+label; the `?` popout also contains its pane-switching and navigation hints through
+`<enter> diff`. The popout has horizontal padding, shifts left or clips at the
+terminal edge without wrapping, and is omitted when its label or the row above the
+footer is not visible. It does not reserve a history row and may cover history,
+panes, or notices beneath it. Closing behavior and shortcut availability are
+unchanged, and direct status actions and quit remain in the footer. The history
+status starts with the history position, then the
 `v`, `c`, and `a` prefixes when they are addressable. Remaining history-level
 actions end at the information prefix while it is closed. An available direct
 time-travel action follows the shortcut groups, and duplicate cycling follows it when
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 9625daf30f3..8f9b450c23f 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -950,7 +950,9 @@ pub(crate) fn draw_with_worktree(
     let mut footer_spans = vec![Span::raw(status)];
     let mut time_travel = None;
     let mut commit_prefix_spans = Vec::new();
+    let mut commit_popup = None;
     let mut actions_prefix_spans = Vec::new();
+    let mut actions_popup = None;
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
         let head_visible = decorations
             .values()
@@ -1025,32 +1027,31 @@ pub(crate) fn draw_with_worktree(
                 });
                 options.push((if pinned { "unpin" } else { "pin" }, 'i'));
             }
-            commit_prefix_spans.push(Span::raw(" · "));
-            commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
-            commit_prefix_spans.push(Span::raw("ommit ("));
+            let mut items = Vec::new();
             if options.is_empty() {
-                commit_prefix_spans.push(Span::raw("no actions"));
+                items.push(Span::raw("no actions"));
             } else {
                 for (index, (label, key)) in options.into_iter().enumerate() {
                     if index > 0 {
-                        commit_prefix_spans.push(Span::raw(" · "));
+                        items.push(Span::raw(" · "));
                     }
-                    commit_prefix_spans.extend(shortcut(label, key, true));
+                    items.extend(shortcut(label, key, true));
                 }
             }
-            commit_prefix_spans.push(Span::raw(")"));
+            commit_popup = Some(items);
+        }
+        commit_prefix_spans.push(Span::raw(" · "));
+        commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
+        commit_prefix_spans.push(Span::raw("ommit"));
+        if app.commit_expanded {
             emphasize_prefix(&mut commit_prefix_spans[1..]);
-        } else {
-            commit_prefix_spans.push(Span::raw(" · "));
-            commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
-            commit_prefix_spans.push(Span::raw("ommit"));
         }
     }
     if app.changes_focus.is_none() {
         actions_prefix_spans.push(Span::raw(" · "));
         actions_prefix_spans.push(Span::styled("a", Style::default().add_modifier(Modifier::UNDERLINED)));
+        actions_prefix_spans.push(Span::raw("ctions"));
         if app.actions_expanded {
-            actions_prefix_spans.push(Span::raw("ctions ("));
             let mut options = Vec::new();
             if app.can_finish_review() {
                 options.push(("finish-review", 'r'));
@@ -1066,110 +1067,115 @@ pub(crate) fn draw_with_worktree(
             if app.can_forkpoint() {
                 options.push(("forkpoint", 'f'));
             }
+            let mut items = Vec::new();
             if options.is_empty() {
-                actions_prefix_spans.push(Span::raw("no actions"));
+                items.push(Span::raw("no actions"));
             } else {
                 for (index, (label, key)) in options.into_iter().enumerate() {
                     if index > 0 {
-                        actions_prefix_spans.push(Span::raw(" · "));
+                        items.push(Span::raw(" · "));
                     }
-                    actions_prefix_spans.extend(shortcut(label, key, true));
+                    items.extend(shortcut(label, key, true));
                 }
             }
-            actions_prefix_spans.push(Span::raw(")"));
+            actions_popup = Some(items);
             emphasize_prefix(&mut actions_prefix_spans[1..]);
-        } else {
-            actions_prefix_spans.push(Span::raw("ctions"));
         }
     }
     let focus_feedback = app.focus_feedback.take();
-    if app.information_expanded && (app.tree_changes_visible || app.worktree_changes_visible) {
-        footer_spans.push(match focus_feedback {
-            Some(destination) => Span::raw(format!(" · <tab> → {destination}")),
-            None => Span::raw(" · <tab> switch"),
-        });
-    }
     if app.changes_focus.is_some() {
         footer_spans.push(Span::raw(" · q/Esc history"));
     }
     let mut view_prefix_spans = Vec::new();
+    let mut view_popup = None;
+    view_prefix_spans.push(Span::raw(" · "));
+    view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
+    view_prefix_spans.push(Span::raw("iew"));
     if app.history_display_expanded {
-        view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
-        view_prefix_spans.push(Span::raw("iew ("));
+        let mut items = Vec::new();
         let (date_label, date_visible) = match app.date_mode {
             DateMode::Author => ("author date", true),
             DateMode::Committer => ("committer date", true),
             DateMode::None => ("date", false),
         };
-        view_prefix_spans.extend(shortcut(date_label, 'd', date_visible));
-        view_prefix_spans.push(Span::raw(" · "));
+        items.extend(shortcut(date_label, 'd', date_visible));
+        items.push(Span::raw(" · "));
         let (id_label, ids_visible) = match (app.id_mode, app.effective_id_mode()) {
             (IdMode::Off, IdMode::Change) => ("auto change ids", true),
             (IdMode::Commit, _) => ("commit ids", true),
             (IdMode::Change, _) => ("change ids", true),
             (IdMode::Off, _) => ("ids", false),
         };
-        view_prefix_spans.extend(shortcut(id_label, 'i', ids_visible));
-        view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.extend(shortcut("emails", 'e', app.show_emails));
+        items.extend(shortcut(id_label, 'i', ids_visible));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut("emails", 'e', app.show_emails));
         let (name_label, names_visible) = match app.name_mode {
             NameMode::All => ("names", true),
             NameMode::Author => ("name", true),
             NameMode::None => ("name", false),
         };
-        view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.extend(shortcut(name_label, 'n', names_visible));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut(name_label, 'n', names_visible));
         for (label, key, enabled) in [("mailmap", 'm', app.use_mailmap), ("trailers", 't', app.show_trailers)] {
-            view_prefix_spans.push(Span::raw(" · "));
-            view_prefix_spans.extend(shortcut(label, key, enabled));
+            items.push(Span::raw(" · "));
+            items.extend(shortcut(label, key, enabled));
         }
         let ref_label = match app.ref_mode {
             RefMode::All => "all refs",
             RefMode::Default => "refs",
             RefMode::None => "no refs",
         };
-        view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.extend(shortcut(ref_label, 'r', app.ref_mode != RefMode::None));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut(ref_label, 'r', app.ref_mode != RefMode::None));
         if app.has_hidden_filter {
-            view_prefix_spans.push(Span::raw(" · "));
-            view_prefix_spans.extend(shortcut(
+            items.push(Span::raw(" · "));
+            items.extend(shortcut(
                 if app.show_hidden { "hide hidden" } else { "show hidden" },
                 'h',
                 app.show_hidden,
             ));
         }
-        view_prefix_spans.push(Span::raw(")"));
+        view_popup = Some(items);
         emphasize_prefix(&mut view_prefix_spans[1..]);
-    } else {
-        view_prefix_spans.push(Span::raw(" · "));
-        view_prefix_spans.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
-        view_prefix_spans.push(Span::raw("iew"));
     }
     let mut ordered = vec![Span::raw(history_position(app))];
+    let mut prefix_popup = None;
+    let view_anchor = spans_width(&ordered).saturating_add(view_prefix_spans[0].width());
     ordered.append(&mut view_prefix_spans);
+    if let Some(items) = view_popup {
+        prefix_popup = Some((view_anchor, items));
+    }
+    let commit_anchor = spans_width(&ordered).saturating_add(commit_prefix_spans.first().map_or(0, Span::width));
     ordered.append(&mut commit_prefix_spans);
+    if let Some(items) = commit_popup {
+        prefix_popup = Some((commit_anchor, items));
+    }
+    let actions_anchor = spans_width(&ordered).saturating_add(actions_prefix_spans.first().map_or(0, Span::width));
     ordered.append(&mut actions_prefix_spans);
+    if let Some(items) = actions_popup {
+        prefix_popup = Some((actions_anchor, items));
+    }
     ordered.push(Span::raw(" · "));
+    let enrich_anchor = spans_width(&ordered);
     let enrich_prefix_start = ordered.len();
     ordered.extend(shortcut("enrich", 'n', true));
     if app.enrich_expanded {
-        ordered.push(Span::raw(" ("));
+        let mut items = Vec::new();
         if let Some(row) = app.selected.and_then(|index| app.rows.get(index)) {
             if app.can_reword() {
-                ordered.extend(shortcut("todo", 't', app.todo(row.id)));
-                ordered.push(Span::raw(" · "));
-                ordered.extend(shortcut("note", 'o', app.note(row.id).is_some()));
-                ordered.push(Span::raw(" · "));
+                items.extend(shortcut("todo", 't', app.todo(row.id)));
+                items.push(Span::raw(" · "));
+                items.extend(shortcut("note", 'o', app.note(row.id).is_some()));
+                items.push(Span::raw(" · "));
             }
-            ordered.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
-            ordered.push(Span::raw(" · "));
-            ordered.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
+            items.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
+            items.push(Span::raw(" · "));
+            items.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
         } else {
-            ordered.push(Span::raw("no actions"));
+            items.push(Span::raw("no actions"));
         }
-        ordered.push(Span::raw(")"));
         emphasize_prefix(&mut ordered[enrich_prefix_start..]);
+        prefix_popup = Some((enrich_anchor, items));
     }
     if let Some(label) = time_travel {
         ordered.push(Span::raw(" · "));
@@ -1184,18 +1190,19 @@ pub(crate) fn draw_with_worktree(
     ordered.push(Span::raw(" · "));
     ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     ordered.push(Span::raw(" · "));
-    let information_prefix_start = app.information_expanded.then_some(ordered.len());
+    let information_anchor = spans_width(&ordered);
+    let information_prefix_start = ordered.len();
     ordered.push(Span::styled("?", Style::default().add_modifier(Modifier::UNDERLINED)));
     if app.information_expanded {
-        ordered.push(Span::raw(" ("));
+        let mut items = Vec::new();
         if app.signature_failures > 0 {
-            ordered.extend([
+            items.extend([
                 Span::raw(format!("s {} ", app.signature_failures)),
                 Span::styled("●", color(Color::LightRed)),
                 Span::raw(" · "),
             ]);
         } else if has_verifiable_signatures {
-            ordered.extend([
+            items.extend([
                 Span::raw("s "),
                 Span::styled("●", color(Color::Rgb(255, 165, 0))),
                 Span::raw(" -> "),
@@ -1208,38 +1215,47 @@ pub(crate) fn draw_with_worktree(
             HistoryAlignment::Columns => ("[ columns", true),
             HistoryAlignment::None => ("[ align", false),
         };
-        ordered.push(toggle(alignment, enabled));
-        ordered.push(Span::raw(" · "));
-        ordered.extend(shortcut("ref-tree", 't', false));
-        ordered.push(Span::raw(" · "));
-        ordered.extend(shortcut("message", 'm', app.show_commit));
-        ordered.push(Span::raw(" · "));
-        ordered.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
+        items.push(toggle(alignment, enabled));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut("ref-tree", 't', false));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut("message", 'm', app.show_commit));
+        items.push(Span::raw(" · "));
+        items.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
+        if app.tree_changes_visible || app.worktree_changes_visible {
+            items.push(Span::raw(" · "));
+            items.push(match focus_feedback {
+                Some(destination) => Span::raw(format!("<tab> → {destination}")),
+                None => Span::raw("<tab> switch"),
+            });
+        }
+        items.push(Span::raw(" · ↑↓/jk move · h/l pan"));
+        if app.changes_focus.is_none() {
+            items.push(Span::raw(" · <enter> diff"));
+        }
+        emphasize_prefix(&mut ordered[information_prefix_start..]);
+        prefix_popup = Some((information_anchor, items));
     }
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
     if app.changes_focus.is_none() && history_state == State::Loading {
         footer_spans.push(Span::raw(" · Esc cancel"));
     }
-    if app.information_expanded {
-        footer_spans.push(Span::raw(" · ↑↓/jk move · h/l pan"));
-        if app.changes_focus.is_none() {
-            footer_spans.push(Span::raw(" · <enter> diff"));
-        }
-        footer_spans.push(Span::raw(")"));
-        emphasize_prefix(&mut footer_spans[information_prefix_start.expect("the prefix is expanded")..]);
-    }
     if app.changes_focus.is_none() {
         footer_spans.push(Span::raw(" · "));
         footer_spans.extend(shortcut("quit", 'q', true));
     }
     if app.unseen_filesystem_redraw {
         footer_spans = notification_discs(footer_spans);
+        if let Some((_, items)) = prefix_popup.as_mut() {
+            *items = notification_discs(std::mem::take(items));
+        }
     }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
     if let (Some(area), Some(notice)) = (notice_area, notice.as_ref()) {
         render_notice(frame, area, notice);
     }
+    let prefix_popup_area = prefix_popup.and_then(|(anchor, items)| render_prefix_popup(frame, footer, anchor, items));
     FrameLayout {
         history: body,
         overlays: changes_panes
@@ -1247,6 +1263,7 @@ pub(crate) fn draw_with_worktree(
             .map(|pane| pane.outer)
             .chain(commit_pane.map(|(outer, _)| outer))
             .chain(notice_area)
+            .chain(prefix_popup_area)
             .collect(),
         rows,
     }
@@ -1973,6 +1990,32 @@ fn emphasize_prefix(spans: &mut [Span<'_>]) {
     }
 }
 
+fn spans_width(spans: &[Span<'_>]) -> usize {
+    spans.iter().map(Span::width).sum()
+}
+
+fn render_prefix_popup(
+    frame: &mut Frame<'_>,
+    footer: Rect,
+    anchor: usize,
+    mut items: Vec<Span<'static>>,
+) -> Option<Rect> {
+    if footer.width == 0 || footer.y <= frame.area().y || anchor >= usize::from(footer.width) {
+        return None;
+    }
+    items.insert(0, Span::raw(" "));
+    items.push(Span::raw(" "));
+    let width = u16::try_from(spans_width(&items)).unwrap_or(u16::MAX).min(footer.width);
+    let anchor = footer.x.saturating_add(u16::try_from(anchor).unwrap_or(u16::MAX));
+    let area = Rect::new(anchor.min(footer.right().saturating_sub(width)), footer.y - 1, width, 1);
+    frame.render_widget(Clear, area);
+    frame.render_widget(
+        Paragraph::new(Line::from(items)).style(Style::default().add_modifier(Modifier::REVERSED)),
+        area,
+    );
+    Some(area)
+}
+
 fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
     let mut out = Vec::with_capacity(spans.len());
     for span in spans {
@@ -2528,6 +2571,31 @@ mod tests {
         assert!(spans[1].style.add_modifier.contains(Modifier::DIM));
     }
 
+    #[test]
+    fn prefix_popout_clamps_and_clears_the_row_beneath_it() -> Result<(), Box<dyn std::error::Error>> {
+        let mut terminal = Terminal::new(TestBackend::new(20, 2))?;
+        let mut popup = None;
+        terminal.draw(|frame| {
+            frame.render_widget(Paragraph::new("underlying history"), Rect::new(0, 0, 20, 1));
+            popup = render_prefix_popup(
+                frame,
+                Rect::new(0, 1, 20, 1),
+                12,
+                vec![Span::raw("abcdefghijklmnopqrstuvwxyz")],
+            );
+        })?;
+
+        assert_eq!(popup, Some(Rect::new(0, 0, 20, 1)));
+        assert_eq!(rendered_line(&terminal, 0), " abcdefghijklmnopqrs");
+        assert!(
+            (0..20).all(|x| terminal.backend().buffer()[(x, 0)]
+                .modifier
+                .contains(Modifier::REVERSED)),
+            "the complete clipped popout keeps its floating treatment"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_todo_progress_with_operation_counts_and_times() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(80, 8))?;
@@ -2692,7 +2760,7 @@ mod tests {
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 1).contains("enrich (todo · note · checks-pass · git note)"),
+            rendered_line(&terminal, 0).contains(" todo · note · checks-pass · git note "),
             "the enrich group advertises all note actions"
         );
         app.enrich_expanded = false;
@@ -3125,14 +3193,14 @@ mod tests {
         });
         app.selected = None;
         app.history_display_expanded = true;
-        let mut terminal = Terminal::new(TestBackend::new(160, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(160, 3))?;
 
         let mailmap =
             gix::mailmap::Snapshot::from_bytes(b"Mapped Human <mapped@example.com> Human <human@example.com>\n");
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
         assert!(
-            rendered_line(&terminal, 1).contains(" · commit · actions ·"),
+            rendered_line(&terminal, 2).contains(" · commit · actions ·"),
             "the commit and actions prefixes remain available beside the view group"
         );
 
@@ -3161,7 +3229,7 @@ mod tests {
         assert_eq!(style_at("[Claude]"), Color::Green, "bot co-authors use agent styling");
         assert!(
             rendered_line(&terminal, 1).contains("trailers"),
-            "the footer advertises the trailer toggle"
+            "the popout advertises the trailer toggle"
         );
 
         app.update(Action::ToggleTrailers);
@@ -3426,23 +3494,26 @@ mod tests {
         app.history_display_expanded = true;
         app.update(Action::ToggleMailmap);
         assert!(app.notice().is_none(), "the next action clears the notice");
+        let mut terminal = Terminal::new(TestBackend::new(180, 3))?;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_row(&terminal).contains(" author subject"),
             "m restores the original author name"
         );
-        assert!(footer_is_dim(&terminal, "mailmap"), "disabled mailmap is dimmed");
+        assert!(popup_is_dim(&terminal, "mailmap"), "disabled mailmap is dimmed");
 
+        app.history_display_expanded = false;
         app.leave_attention("no commit created: no input was provided");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert_eq!(
-            rendered_line(&terminal, 0).trim(),
+            rendered_line(&terminal, 1).trim(),
             "no commit created: no input was provided",
             "an unchanged new-commit editor explains why nothing happened"
         );
         app.leave_error("operation failed");
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
-        assert_eq!(terminal.backend().buffer()[(2, 0)].bg, Color::LightRed);
+        assert_eq!(terminal.backend().buffer()[(2, 1)].bg, Color::LightRed);
+        app.history_display_expanded = true;
         app.update(Action::ToggleMailmap);
 
         app.update(Action::ToggleDate);
@@ -3464,8 +3535,8 @@ mod tests {
         );
         assert!(!row.contains("refs/patches"), "special refs are hidden until requested");
         assert!(row.contains("subject"), "the commit subject remains visible");
-        assert!(footer_is_dim(&terminal, "date"), "disabled date is dimmed");
-        assert!(footer_is_dim(&terminal, "name"), "disabled name is dimmed");
+        assert!(popup_is_dim(&terminal, "date"), "disabled date is dimmed");
+        assert!(popup_is_dim(&terminal, "name"), "disabled name is dimmed");
 
         app.update(Action::ToggleName);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -3473,10 +3544,7 @@ mod tests {
             rendered_row(&terminal).contains("author"),
             "the second n restores the author name"
         );
-        assert!(
-            !footer_is_dim(&terminal, "name"),
-            "the restored name mode is not dimmed"
-        );
+        assert!(!popup_is_dim(&terminal, "name"), "the restored name mode is not dimmed");
 
         app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -3489,7 +3557,7 @@ mod tests {
             !rendered_row(&terminal).contains("refs/patches"),
             "no refs hides special refs"
         );
-        assert!(footer_is_dim(&terminal, "no refs"), "no refs is dimmed");
+        assert!(popup_is_dim(&terminal, "no refs"), "no refs is dimmed");
 
         app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -3501,7 +3569,7 @@ mod tests {
             rendered_row(&terminal).contains("refs/patches"),
             "all refs shows special refs"
         );
-        assert!(!footer_is_dim(&terminal, "all refs"), "all refs is not dimmed");
+        assert!(!popup_is_dim(&terminal, "all refs"), "all refs is not dimmed");
 
         app.update(Action::CycleRefs);
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
@@ -3513,19 +3581,19 @@ mod tests {
             !rendered_row(&terminal).contains("refs/patches"),
             "refs hides special refs"
         );
-        assert!(!footer_is_dim(&terminal, "refs"), "refs is not dimmed");
+        assert!(!popup_is_dim(&terminal, "refs"), "refs is not dimmed");
 
         app.has_hidden_filter = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_line(&terminal, 1).contains("show hidden"),
-            "the footer advertises the configured hidden-history toggle"
+            "the popout advertises the configured hidden-history toggle"
         );
         app.show_hidden = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(
             rendered_line(&terminal, 1).contains("hide hidden"),
-            "the footer reflects the unfiltered view"
+            "the popout reflects the unfiltered view"
         );
 
         Ok(())
@@ -3577,7 +3645,7 @@ mod tests {
                 }],
             ),
         ]);
-        let mut terminal = Terminal::new(TestBackend::new(140, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(140, 3))?;
         app.commit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
@@ -3615,15 +3683,17 @@ mod tests {
             "hiding refs retains resource markers: {row:?}"
         );
         assert!(
-            rendered_line(&terminal, 1)
-                .contains("commit (reword · new · new-empty · d forget · unpin) · actions · enrich · @ return · copy"),
+            rendered_line(&terminal, 1).contains(" reword · new · new-empty · d forget · unpin "),
+            "the commit actions float above their prefix"
+        );
+        assert!(
+            rendered_line(&terminal, 2).contains("commit · actions · enrich · @ return · copy"),
             "time travel stays outside the active commit prefix"
         );
-        assert!(!rendered_line(&terminal, 1).contains(" · commit ·"));
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
+        assert!(rendered_line(&terminal, 2).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         app.ref_mode = RefMode::Default;
@@ -3641,7 +3711,7 @@ mod tests {
             "the remembered branch has its dedicated marker: {row:?}"
         );
         assert!(!row.contains("📌"), "the HEAD pin is not an ordinary pin: {row:?}");
-        assert!(rendered_line(&terminal, 1).contains(" · @ travel · copy"));
+        assert!(rendered_line(&terminal, 2).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         decorations.remove(&head);
@@ -3659,7 +3729,7 @@ mod tests {
             ],
         );
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        let footer = rendered_line(&terminal, 1);
+        let footer = rendered_line(&terminal, 2);
         assert!(
             !footer.contains("@ travel") && !footer.contains("@ return"),
             "time travel is hidden at HEAD: {footer}"
@@ -3674,73 +3744,81 @@ mod tests {
         app.configure_hidden_filter(true);
         app.history_display_expanded = true;
         let mut terminal = Terminal::new(TestBackend::new(180, 2))?;
+        let mut layout = None;
 
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        terminal.draw(|frame| {
+            layout = Some(super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                None,
+            ));
+        })?;
 
         let footer = rendered_line(&terminal, 1);
-        let view = "view (author date · ids · emails · names · mailmap · trailers · refs · show hidden)";
-        assert!(
-            footer.starts_with(&format!(
-                "0 commits · {view} · commit · actions · enrich · copy · refs · ?"
-            )),
-            "the active view prefix follows the history position"
-        );
-        let active = footer[..footer.find("view (").expect("the active view prefix is visible")]
+        let compact = "0 commits · view · commit · actions · enrich · copy · refs · ? · Esc cancel · quit";
+        assert_eq!(footer.trim_end(), compact, "the footer keeps every prefix compact");
+        let view = "author date · ids · emails · names · mailmap · trailers · refs · show hidden";
+        let popup = rendered_line(&terminal, 0);
+        let view_x = footer[..footer.find("view").expect("the view prefix is visible")]
             .chars()
             .count() as u16;
+        let popup_x = popup[..popup.find(view).expect("the view items are visible")]
+            .chars()
+            .count() as u16
+            - 1;
+        assert_eq!(popup_x, view_x, "the popout is connected to its footer prefix");
         assert!(
-            terminal.backend().buffer()[(active, 1)]
+            terminal.backend().buffer()[(view_x, 1)]
                 .modifier
                 .contains(Modifier::UNDERLINED),
             "the prefix key is underlined in its verb"
         );
-        assert_reversed_group(&terminal, 1, view);
+        assert_reversed_group(&terminal, 1, "view");
+        assert_reversed_group(&terminal, 0, &format!(" {view} "));
+        let popup_area = Rect::new(view_x, 0, Line::raw(format!(" {view} ")).width() as u16, 1);
+        let layout = layout.expect("drawing returns its layout");
+        assert_eq!(layout.history.height, 1, "the popout does not reserve history space");
+        assert!(
+            layout.overlays.contains(&popup_area),
+            "animation treats the floating menu as an overlay"
+        );
 
         app.history_display_expanded = false;
         app.commit_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(
-            rendered_line(&terminal, 1)
-                .starts_with("0 commits · view · commit (no actions) · actions · enrich · copy · refs · ?"),
-            "the commit prefix follows the view prefix even when no action is available"
-        );
-        assert_reversed_group(&terminal, 1, "commit (no actions)");
+        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        assert!(rendered_line(&terminal, 0).contains(" no actions "));
+        assert_reversed_group(&terminal, 1, "commit");
+        assert_reversed_group(&terminal, 0, " no actions ");
 
         app.commit_expanded = false;
         app.actions_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(
-            rendered_line(&terminal, 1)
-                .starts_with("0 commits · view · commit · actions (no actions) · enrich · copy · refs · ?"),
-            "the actions prefix follows the commit prefix"
-        );
-        assert_reversed_group(&terminal, 1, "actions (no actions)");
+        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        assert!(rendered_line(&terminal, 0).contains(" no actions "));
+        assert_reversed_group(&terminal, 1, "actions");
+        assert_reversed_group(&terminal, 0, " no actions ");
 
         app.actions_expanded = false;
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(
-            rendered_line(&terminal, 1)
-                .starts_with("0 commits · view · commit · actions · enrich (no actions) · copy · refs · ?"),
-            "the enrich prefix follows the actions prefix"
-        );
-        assert_reversed_group(&terminal, 1, "enrich (no actions)");
+        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        assert!(rendered_line(&terminal, 0).contains(" no actions "));
+        assert_reversed_group(&terminal, 1, "enrich");
+        assert_reversed_group(&terminal, 0, " no actions ");
 
         app.enrich_expanded = false;
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        let footer = rendered_line(&terminal, 1);
-        assert!(
-            footer.starts_with(
-                    "0 commits · view · commit · actions · enrich · copy · refs · ? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff) · quit"
-                ),
-            "the information prefix contains every following action except quit: {footer}"
-        );
-        assert_reversed_group(
-            &terminal,
-            1,
-            "? ([ title · ref-tree · message · changes · Esc cancel · ↑↓/jk move · h/l pan · <enter> diff)",
-        );
+        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        let information = "[ title · ref-tree · message · changes · ↑↓/jk move · h/l pan · <enter> diff";
+        assert!(rendered_line(&terminal, 0).contains(information));
+        assert_reversed_group(&terminal, 1, "?");
+        assert_reversed_group(&terminal, 0, &format!(" {information} "));
         Ok(())
     }
 
@@ -3793,12 +3871,12 @@ mod tests {
                 Some(&changes),
             );
         })?;
-        let footer = rendered_line(&terminal, 7);
+        let popup = rendered_line(&terminal, 6);
         assert!(
-            footer.contains("commit (spill)"),
-            "tree focus keeps the scoped edit visible: {footer}"
+            popup.contains(" spill "),
+            "tree focus keeps the scoped edit visible: {popup}"
         );
-        assert!(!footer.contains("amend"), "tree paths cannot be amended");
+        assert!(!popup.contains("amend"), "tree paths cannot be amended");
 
         app.changes_focus = Some(ChangePane::Worktree);
         let mut worktree = Changes {
@@ -3827,12 +3905,12 @@ mod tests {
         })?;
         assert!(app.can_amend(), "drawing retains scoped amend availability");
         assert!(app.commit_expanded, "drawing retains the expanded commit prefix");
-        let footer = rendered_line(&terminal, 7);
+        let popup = rendered_line(&terminal, 6);
         assert!(
-            footer.contains("commit (amend)"),
-            "worktree focus keeps the scoped edit visible: {footer}"
+            popup.contains(" amend "),
+            "worktree focus keeps the scoped edit visible: {popup}"
         );
-        assert!(!footer.contains("spill"), "worktree paths cannot be spilled");
+        assert!(!popup.contains("spill"), "worktree paths cannot be spilled");
 
         app.changes_focus = None;
         terminal.draw(|frame| {
@@ -3847,7 +3925,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 7).contains("stash"),
+            rendered_line(&terminal, 6).contains("stash"),
             "loaded unconflicted worktree changes offer stashing"
         );
         decorations
@@ -3869,7 +3947,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 7).contains("unstash"),
+            rendered_line(&terminal, 6).contains("unstash"),
             "an existing commit stash offers in-place restoration even with worktree changes"
         );
         decorations
@@ -3891,7 +3969,7 @@ mod tests {
             );
         })?;
         assert!(
-            !rendered_line(&terminal, 7).contains("amend"),
+            !rendered_line(&terminal, 6).contains("amend"),
             "a review cannot amend an unstaged selected path"
         );
         worktree.paths[0].group = ChangeGroup::Staged;
@@ -3907,7 +3985,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 7).contains("commit (amend)"),
+            rendered_line(&terminal, 6).contains(" amend "),
             "a review may amend its selected staged path"
         );
         Ok(())
@@ -4480,11 +4558,12 @@ mod tests {
 
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("copy · refs · ? (s ● -> ● · [ title"));
+        assert!(rendered_line(&terminal, 0).contains(" s ● -> ● · [ title"));
+        assert!(rendered_line(&terminal, 1).contains("copy · refs · ?"));
 
         app.finish_signature_verification(vec![(id, false)]);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&terminal, 1).contains("? (s 1 ● · [ title"));
+        assert!(rendered_line(&terminal, 0).contains(" s 1 ● · [ title"));
         Ok(())
     }
 
@@ -4527,7 +4606,7 @@ mod tests {
 
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(footer_is_dim(&terminal, "message"), "the closed commit pane is dimmed");
+        assert!(popup_is_dim(&terminal, "message"), "the closed commit pane is dimmed");
 
         app.update(Action::ToggleCommit);
         terminal.draw(|frame| {
@@ -4571,7 +4650,7 @@ mod tests {
             "the commit body remains separated from its title"
         );
         assert!(
-            !footer_is_dim(&terminal, "message"),
+            !popup_is_dim(&terminal, "message"),
             "the open commit pane is not dimmed"
         );
 
@@ -4925,11 +5004,12 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&footer_terminal, 15).contains(
-                "? ([ title · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff) · quit"
+            rendered_line(&footer_terminal, 14).contains(
+                " [ title · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff "
             ),
-            "the expanded information prefix contains every following action except quit"
+            "the expanded information prefix floats its actions above the footer"
         );
+        assert!(rendered_line(&footer_terminal, 15).contains("? · quit"));
         app.information_expanded = false;
 
         assert_eq!(
@@ -5022,7 +5102,7 @@ mod tests {
             "repeated history navigation temporarily hides the changes pane"
         );
         assert!(
-            app.changes_mode.is_some() && !footer_is_dim(&terminal, "changes"),
+            app.changes_mode.is_some() && !popup_is_dim(&terminal, "changes"),
             "temporary suppression leaves the persistent changes setting enabled"
         );
         app.changes_suppressed = false;
@@ -6029,18 +6109,19 @@ mod tests {
         );
 
         let mut narrow = Terminal::new(TestBackend::new(28, 3))?;
-        app.commit_expanded = true;
         narrow.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
             rendered_line(&narrow, 1).ends_with(" ⇣2 "),
             "the terminal edge pushes the marker over clipped title text"
         );
+        app.commit_expanded = true;
         let mut actions = Terminal::new(TestBackend::new(120, 3))?;
         actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&actions, 2).contains("commit (rebase · rebase-update · pin) · actions"),
+            rendered_line(&actions, 1).contains(" rebase · rebase-update · pin ")
+                && rendered_line(&actions, 2).contains("commit · actions"),
             "the selected hidden base offers independent edits: {:?}",
-            rendered_line(&actions, 2)
+            rendered_line(&actions, 1)
         );
         Ok(())
     }
@@ -6402,7 +6483,7 @@ mod tests {
 
     fn assert_reversed_group(terminal: &Terminal<TestBackend>, y: u16, group: &str) {
         let line = rendered_line(terminal, y);
-        let start = line[..line.find(group).expect("the active prefix group is visible")]
+        let start = line[..line.rfind(group).expect("the active prefix group is visible")]
             .chars()
             .count() as u16;
         let end = start + group.chars().count() as u16;
@@ -6418,12 +6499,10 @@ mod tests {
         );
     }
 
-    fn footer_is_dim(terminal: &Terminal<TestBackend>, label: &str) -> bool {
-        let y = terminal.backend().buffer().area.height - 1;
-        let footer = rendered_line(terminal, y);
-        let x = footer[..footer.rfind(label).expect("toggle is visible")]
-            .chars()
-            .count() as u16;
+    fn popup_is_dim(terminal: &Terminal<TestBackend>, label: &str) -> bool {
+        let y = terminal.backend().buffer().area.height - 2;
+        let popup = rendered_line(terminal, y);
+        let x = popup[..popup.rfind(label).expect("toggle is visible")].chars().count() as u16;
         terminal.backend().buffer()[(x, y)].modifier.contains(Modifier::DIM)
     }
 }

From dc1c07bfcfe51e634930dc66dfa6a8ab10521bc2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 07:23:35 +0200
Subject: [PATCH 230/282] feat: add cherry-move-stack to tix

Move rebase commands into the actions prefix and allow a selected linear HEAD ancestry to move as one stack while preserving refs, checkout state, and cycle safety.\n\nAdapt the rebased signing API and fixture snapshots needed by the feature tests.
---
 gix-tix/Cargo.toml                            |   2 +-
 gix-tix/spec.md                               |  25 +-
 gix-tix/src/app.rs                            | 280 +++++++++++++++++-
 gix-tix/src/edit/rebase.rs                    | 178 +++++++++--
 ..._rebase__tests__reworded-middle-stack.snap |  37 ++-
 ...tests__changed-review-with-successors.snap |  34 ++-
 ...sts__accepted-pending-rebase-conflict.snap |  29 +-
 gix-tix/src/lib.rs                            |  20 +-
 gix-tix/src/ui.rs                             | 104 +++++--
 9 files changed, 606 insertions(+), 103 deletions(-)

diff --git a/gix-tix/Cargo.toml b/gix-tix/Cargo.toml
index ec3a777ff67..05be5b57940 100644
--- a/gix-tix/Cargo.toml
+++ b/gix-tix/Cargo.toml
@@ -37,7 +37,7 @@ tracing-subscriber = "0.3.17"
 tui-markdown = { version = "0.3.9", default-features = false }
 
 [dev-dependencies]
-gix-testtools = { path = "../tests/tools" }
+gix-testtools = { path = "../tests/tools", features = ["sha1"] }
 insta = "1.46.3"
 
 [package.metadata.docs.rs]
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 5b00713e981..b89a3a2c780 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -866,7 +866,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### History rebase editor
 
-- Selecting an eligible hidden boundary and pressing `c b` opens a Markdown
+- Selecting an eligible hidden boundary and pressing `a b` opens a Markdown
   `.md` todo. Its editable plan is read bottom-to-top like the history view:
   newest commands and refs are highest, and each stack ends in a centered
   `──── fork <id> ────` separator below its oldest command.
@@ -876,7 +876,7 @@ space first; changes blocks adapt within the remaining history width.
   exactly as displayed in history without Markdown escaping. Fork points within the editable tree
   remain plain `fork <id>` separators. Every separator is centered with at least
   four `─` characters per side, and all span the widest editable line.
-- When that boundary shows `⇣N`, `c u` opens the same editor with each base-level
+- When that boundary shows `⇣N`, `a u` opens the same editor with each base-level
   stack rooted at the corresponding hidden branch tip. Its otherwise unfamiliar
   separator is `fork <id> (updated-base) <title>`, with the raw title exactly as
   shown in history, including `[A]` and `[N]`. The hidden branch
@@ -994,15 +994,17 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Commit and action shortcuts
 
-- `c` toggles the commit shortcut group. `c b` rebases an eligible hidden base and
-  `c u` rebases it onto the newer hidden branch tip when available,
-  `c o` rewords, `c n` creates a rebased child, `c a` amends `@`, `c h` stashes
+- `c` toggles the commit shortcut group. `c o` rewords, `c n` creates a rebased
+  child, `c a` amends `@`, `c h` stashes
   changes at `@`, `c s` spills `@`, `c p` splits staged from unstaged changes,
   and `c d d` confirms forgetting a top commit when each action is available.
-- `a` toggles the actions shortcut group. `a r` starts or finishes a review and
-  `a s` squashes the selected commit, `a m` cherry-moves current `HEAD` directly
-  above the selected commit, and `a f` establishes the remembered branch's
-  forkpoint at detached `HEAD` when available.
+- `a` toggles the actions shortcut group. `a b` rebases an eligible hidden base,
+  `a u` rebases it onto the newer hidden branch tip when available, `a r` starts
+  or finishes a review, `a s` squashes the selected commit, `a m` cherry-moves
+  current `HEAD` directly above the selected commit, `a v` starts
+  cherry-move-stack for the linear ancestry from the selected commit through
+  `HEAD`, and `a f` establishes
+  the remembered branch's forkpoint at detached `HEAD` when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
@@ -1016,6 +1018,11 @@ space first; changes blocks adapt within the remaining history width.
   is unavailable. Mutable refs, pins, Git notes, enrichments, review resources,
   and attached or detached checkout state follow their rewritten commits.
   Cherry-move uses the history-todo conflict and continuation rules.
+- Cherry-move-stack requires the selected commit to be an inclusive base in the linear
+  ancestry of `HEAD`. It then limits navigation to eligible insertion targets;
+  `<enter>` moves the complete inclusive base-through-`HEAD` stack as a unit above the selected
+  target, and Escape cancels. The stack follows the same eligibility, rewrite,
+  no-op, metadata, checkout, and conflict rules as a single cherry-move.
 - `@` invokes time travel directly, outside both groups. Invoking it leaves an
   already expanded commit group open.
 - Commit and action shortcuts keep their respective group open. Navigation or
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 5a4611d48f9..5fac6a750fb 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -378,6 +378,7 @@ pub(crate) enum Action {
     RebaseUpdate,
     Squash,
     Move,
+    MoveStack,
     Review,
     Forkpoint,
     TimeTravel,
@@ -422,6 +423,7 @@ pub(crate) enum Effect {
     },
     Move {
         source: ObjectId,
+        base: ObjectId,
         target: ObjectId,
     },
     StartReview {
@@ -519,6 +521,7 @@ pub(crate) struct App {
     review_tip: Option<ObjectId>,
     review_return: Option<(ObjectId, ObjectId)>,
     squash_source: Option<ObjectId>,
+    move_stack_base: Option<ObjectId>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
@@ -620,6 +623,7 @@ impl App {
             review_tip: None,
             review_return: None,
             squash_source: None,
+            move_stack_base: None,
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
@@ -731,6 +735,8 @@ impl App {
             Some("review base · j/k select ancestor · <enter> start · Esc cancel")
         } else if self.squash_selection_active() {
             Some("squash target · j/k select ancestor · <enter> squash · Esc cancel")
+        } else if self.move_stack_base.is_some() {
+            Some("cherry-move-stack target · j/k select insertion point · <enter> move · Esc cancel")
         } else if self.forget_confirmation_visible() {
             Some("forget commit · d again confirm · any other action cancel")
         } else {
@@ -1072,8 +1078,6 @@ impl App {
                 | Action::Spill
                 | Action::Split
                 | Action::Forget
-                | Action::Rebase
-                | Action::RebaseUpdate
                 | Action::TimeTravel
                 | Action::TogglePin
         ) {
@@ -1081,7 +1085,14 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleActions | Action::Squash | Action::Move | Action::Review | Action::Forkpoint
+            Action::ToggleActions
+                | Action::Rebase
+                | Action::RebaseUpdate
+                | Action::Squash
+                | Action::Move
+                | Action::MoveStack
+                | Action::Review
+                | Action::Forkpoint
         ) {
             self.actions_expanded = false;
         }
@@ -1331,6 +1342,20 @@ impl App {
                 self.clear_reachability_selection();
                 return vec![Effect::Squash { source, target }];
             }
+            Action::OpenDiff if self.move_stack_base.is_some() => {
+                let source = self.worktree_head.expect("cherry-stack selection requires HEAD");
+                let base = self.move_stack_base.expect("cherry-stack selection has a base");
+                let Some(target) = self
+                    .selected
+                    .filter(|index| self.is_row_reachable(*index) && self.reachable_row_selectable(*index))
+                    .and_then(|index| self.rows.get(index))
+                    .map(|row| row.id)
+                else {
+                    return Vec::new();
+                };
+                self.clear_reachability_selection();
+                return vec![Effect::Move { source, base, target }];
+            }
             Action::OpenDiff => {
                 if let Some(target) = self.selected_tree_diff_target() {
                     return vec![Effect::OpenCommitDiff(target)];
@@ -1421,11 +1446,28 @@ impl App {
                 }
             }
             Action::Move if self.can_move() => {
+                let source = self.worktree_head.expect("move availability requires HEAD");
                 return vec![Effect::Move {
-                    source: self.worktree_head.expect("move availability requires HEAD"),
+                    source,
+                    base: source,
                     target: self.rows[self.selected.expect("move requires a selection")].id,
                 }];
             }
+            Action::MoveStack => {
+                if let Some((source, base, base_parent, stack)) = self.cherry_stack() {
+                    let reachable: Vec<_> = self
+                        .rows
+                        .iter()
+                        .enumerate()
+                        .map(|(index, row)| self.is_cherry_stack_target(index, row.id, base, base_parent, &stack))
+                        .collect();
+                    if reachable.iter().any(|reachable| *reachable) {
+                        debug_assert_eq!(source, self.worktree_head.expect("a cherry-stack has HEAD"));
+                        self.move_stack_base = Some(base);
+                        self.reachable_rows = Some(reachable);
+                    }
+                }
+            }
             Action::Review if self.can_finish_review() => {
                 return vec![Effect::FinishReview {
                     review: self.rows[self.selected.expect("finishing review requires a selection")].id,
@@ -1503,7 +1545,10 @@ impl App {
             }
             Action::ForceQuit => return vec![Effect::Quit],
             Action::Cancel
-                if self.review_tip.is_some() || self.review_return.is_some() || self.squash_source.is_some() =>
+                if self.review_tip.is_some()
+                    || self.review_return.is_some()
+                    || self.squash_source.is_some()
+                    || self.move_stack_base.is_some() =>
             {
                 self.clear_reachability_selection();
             }
@@ -1673,6 +1718,9 @@ impl App {
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
         self.forget_confirmation = None;
+        if self.move_stack_base.is_some() {
+            self.clear_reachability_selection();
+        }
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -1870,6 +1918,7 @@ impl App {
         self.review_tip = None;
         self.review_return = None;
         self.squash_source = None;
+        self.move_stack_base = None;
         self.reachability_anchor = None;
         self.reachable_rows = None;
     }
@@ -2198,6 +2247,62 @@ impl App {
             && !self.known_merge_descendants.contains(&target.id)
     }
 
+    pub(crate) fn can_cherry_stack(&self) -> bool {
+        self.cherry_stack().is_some_and(|(_, base, base_parent, stack)| {
+            self.rows
+                .iter()
+                .enumerate()
+                .any(|(index, row)| self.is_cherry_stack_target(index, row.id, base, base_parent, &stack))
+        })
+    }
+
+    fn cherry_stack(&self) -> Option<(ObjectId, ObjectId, ObjectId, HashSet<ObjectId>)> {
+        if self.state != State::Complete
+            || self.changes_focus.is_some()
+            || self.deferred_history_state.unwrap_or(self.state) != State::Complete
+        {
+            return None;
+        }
+        let source = self.worktree_head?;
+        let base = self.selected.and_then(|index| self.rows.get(index))?.id;
+        if self.hidden_rows.contains(&base) || self.known_merge_descendants.contains(&base) {
+            return None;
+        }
+
+        let mut current = source;
+        let mut stack = HashSet::new();
+        loop {
+            if !stack.insert(current) {
+                return None;
+            }
+            let row = self.all_rows.get(&current)?;
+            let [parent] = row.parent_ids.as_slice() else {
+                return None;
+            };
+            if current == base {
+                return Some((source, base, *parent, stack));
+            }
+            current = *parent;
+        }
+    }
+
+    fn is_cherry_stack_target(
+        &self,
+        index: usize,
+        id: ObjectId,
+        base: ObjectId,
+        base_parent: ObjectId,
+        stack: &HashSet<ObjectId>,
+    ) -> bool {
+        !self.is_row_hidden(index)
+            && !stack.contains(&id)
+            && id != base_parent
+            && !self.known_merge_descendants.contains(&id)
+            && !stack
+                .iter()
+                .any(|ancestor| *ancestor != base && self.is_known_ancestor(*ancestor, id))
+    }
+
     pub(crate) fn can_review(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
@@ -3790,6 +3895,7 @@ mod tests {
             app.update(Action::Move),
             vec![Effect::Move {
                 source: id(5),
+                base: id(5),
                 target: id(3),
             }]
         );
@@ -3814,6 +3920,161 @@ mod tests {
         assert!(merge_target.can_move(), "an unchanged merge target is allowed");
     }
 
+    #[test]
+    fn cherry_stack_selects_only_valid_insertion_targets() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(7, &[6]),
+            row_with_parents(6, &[1]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(5)), false);
+        app.set_known_merge_descendants(HashSet::from([id(6)]));
+        complete(&mut app);
+        app.select_commit(id(3));
+
+        assert!(app.can_cherry_stack());
+        assert!(app.update(Action::MoveStack).is_empty());
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("cherry-move-stack target · j/k select insertion point · <enter> move · Esc cancel".into())
+        );
+        for (n, reachable) in [
+            (7, true),
+            (6, false),
+            (5, false),
+            (4, false),
+            (3, false),
+            (2, false),
+            (1, true),
+        ] {
+            let index = app
+                .rows
+                .iter()
+                .position(|row| row.id == id(n))
+                .expect("the fixture commit is visible");
+            assert_eq!(app.is_row_reachable(index), reachable, "commit {n} target eligibility");
+        }
+
+        app.update(Action::MoveDown);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::Move {
+                source: id(5),
+                base: id(3),
+                target: id(1),
+            }]
+        );
+
+        app.select_commit(id(3));
+        app.update(Action::MoveStack);
+        app.update(Action::Cancel);
+        assert!(app.notice().is_none(), "Escape cancels insertion-target selection");
+        assert!(
+            app.rows
+                .iter()
+                .enumerate()
+                .all(|(index, _)| app.is_row_reachable(index))
+        );
+    }
+
+    #[test]
+    fn cherry_stack_requires_a_linear_head_ancestry() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3, 2]),
+            row_with_parents(3, &[1]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(5)), false);
+        complete(&mut app);
+        app.select_commit(id(3));
+
+        assert!(!app.can_cherry_stack());
+        assert!(app.update(Action::MoveStack).is_empty());
+        assert!(app.notice().is_none());
+    }
+
+    #[test]
+    fn cherry_stack_hides_targets_that_would_cycle_through_an_internal_commit() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(8, &[4]),
+            row_with_parents(7, &[3]),
+            row_with_parents(6, &[1]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(5)), false);
+        complete(&mut app);
+        app.select_commit(id(3));
+
+        assert!(app.update(Action::MoveStack).is_empty());
+        for (commit, expected) in [(8, false), (7, true), (6, true)] {
+            let index = app
+                .rows
+                .iter()
+                .position(|row| row.id == id(commit))
+                .expect("the candidate is visible");
+            assert_eq!(
+                app.is_row_reachable(index),
+                expected,
+                "candidate {commit} has the expected cycle safety"
+            );
+        }
+    }
+
+    #[test]
+    fn refresh_cancels_cherry_stack_selection_before_rows_change() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(5)), false);
+        complete(&mut app);
+        app.select_commit(id(3));
+        app.update(Action::MoveStack);
+        assert!(app.move_stack_base.is_some(), "target selection is active");
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(6, &[5])].into(), &[id(6)], &[], false)
+            .expect("the changed history starts lane computation");
+        assert!(
+            app.move_stack_base.is_none(),
+            "refresh cancels the index-based selection"
+        );
+        assert!(
+            app.reachable_rows.is_none(),
+            "the stale row mask is discarded immediately"
+        );
+        assert!(app.notice().is_none(), "the cancelled selection no longer prompts");
+
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(app.rows.first().map(|row| row.id), Some(id(6)));
+        assert!(
+            app.rows
+                .iter()
+                .enumerate()
+                .all(|(index, _)| app.is_row_reachable(index)),
+            "the replacement projection has no stale eligibility mask"
+        );
+    }
+
     #[test]
     fn selection_follows_the_oldest_commit_until_the_user_moves() {
         let mut app = App::new(2);
@@ -4246,11 +4507,13 @@ mod tests {
         app.update(Action::Reword);
         app.update(Action::NewCommit);
         app.update(Action::Forget);
-        app.update(Action::Rebase);
-        app.update(Action::RebaseUpdate);
         app.update(Action::TimeTravel);
         assert!(app.commit_expanded, "grouped commit commands keep the group open");
 
+        app.update(Action::Rebase);
+        assert!(!app.commit_expanded, "rebase now belongs to the actions group");
+
+        app.update(Action::ToggleCommitGroup);
         app.update(Action::MoveDown);
         assert!(!app.commit_expanded, "navigation collapses the group");
 
@@ -4268,9 +4531,12 @@ mod tests {
         app.update(Action::ToggleActions);
         assert!(!app.commit_expanded, "opening actions closes commit");
         assert!(app.actions_expanded);
+        app.update(Action::Rebase);
+        app.update(Action::RebaseUpdate);
         app.update(Action::Review);
         app.update(Action::Squash);
         app.update(Action::Move);
+        app.update(Action::MoveStack);
         assert!(app.actions_expanded, "grouped actions keep the group open");
         app.update(Action::ToggleActions);
         assert!(!app.actions_expanded, "the prefix key toggles the group");
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index a613c55f9e8..b80f18cebad 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -536,30 +536,56 @@ pub(crate) fn cherry_move_plan(
     source: ObjectId,
     target: ObjectId,
 ) -> Result<Plan> {
-    if source == target {
-        anyhow::bail!("the move target must differ from HEAD");
+    cherry_stack_plan(repo, graph, source, source, target)
+}
+
+pub(crate) fn cherry_stack_plan(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    base: ObjectId,
+    head: ObjectId,
+    target: ObjectId,
+) -> Result<Plan> {
+    if repo.head_id()?.detach() != head {
+        anyhow::bail!("the move source must be the current HEAD");
+    }
+    if !graph.is_ancestor(base, head) {
+        anyhow::bail!("the stack base must be an ancestor of HEAD");
     }
-    let source_parents = graph.parents_of(source).context("HEAD is not in the loaded history")?;
-    let [source_parent] = source_parents.as_slice() else {
-        anyhow::bail!("moving HEAD requires exactly one parent");
-    };
-    let source_parent = *source_parent;
     graph
         .parents_of(target)
         .context("the move target is not in the loaded history")?;
-    if source_parent == target {
-        anyhow::bail!("HEAD is already directly above the move target");
+
+    let mut stack = vec![head];
+    let mut stack_parent = HashMap::new();
+    loop {
+        let id = *stack.last().expect("a stack always contains HEAD");
+        let parents = graph.parents_of(id).context("a moved stack commit is incomplete")?;
+        let [parent] = parents.as_slice() else {
+            anyhow::bail!("moving a stack requires every commit to have exactly one parent");
+        };
+        stack_parent.insert(id, *parent);
+        if id == base {
+            break;
+        }
+        stack.push(*parent);
     }
-    if repo.head_id()?.detach() != source {
-        anyhow::bail!("the move source must be the current HEAD");
+    stack.reverse();
+    let stack_set: HashSet<_> = stack.iter().copied().collect();
+    if stack_set.contains(&target) {
+        anyhow::bail!("the move target must not be part of the moved stack");
+    }
+    let base_parent = stack_parent[&base];
+    if base_parent == target {
+        anyhow::bail!("the stack is already directly above the move target");
     }
 
-    let target_rewritten = graph.is_ancestor(source, target);
+    let target_rewritten = graph.is_ancestor(base, target);
     let mut scope = Vec::new();
     let mut scope_set = HashSet::new();
     for id in graph
-        .descendants_in_parent_order(source)
-        .context("HEAD is not in the loaded history")?
+        .descendants_in_parent_order(base)
+        .context("the stack base is not in the loaded history")?
         .into_iter()
         .chain(
             graph
@@ -576,16 +602,18 @@ pub(crate) fn cherry_move_plan(
     for id in &scope {
         let parents = graph.parents_of(*id).context("an affected move commit is incomplete")?;
         let [parent] = parents.as_slice() else {
-            anyhow::bail!("moving HEAD cannot rewrite root or merge commits");
+            anyhow::bail!("moving a stack cannot rewrite root or merge commits");
         };
         new_parent.insert(
             *id,
-            if *id == source {
+            if *id == base {
                 target
-            } else if *parent == source {
-                source_parent
+            } else if stack_set.contains(id) {
+                *parent
+            } else if let Some(old_parent) = stack_parent.get(parent) {
+                *old_parent
             } else if *parent == target {
-                source
+                head
             } else {
                 *parent
             },
@@ -616,11 +644,11 @@ pub(crate) fn cherry_move_plan(
             });
         }
         if steps.len() == before {
-            anyhow::bail!("moving HEAD would create a commit cycle");
+            anyhow::bail!("moving the stack would create a commit cycle");
         }
     }
 
-    let source_step = PlanParent::Step(step_by_id[&source]);
+    let head_step = PlanParent::Step(step_by_id[&head]);
     let mut ref_scope = scope.clone();
     if !scope_set.contains(&target) {
         ref_scope.push(target);
@@ -643,8 +671,8 @@ pub(crate) fn cherry_move_plan(
         .collect();
     let mut expected_refs = capture_refs(repo, &ref_scope, &tips)?;
     for expected in &mut expected_refs {
-        if expected.target == source {
-            expected.placement = Some(source_step);
+        if stack_set.contains(&expected.target) {
+            expected.placement = Some(PlanParent::Step(step_by_id[&expected.target]));
         }
     }
     let head = repo.head()?;
@@ -654,11 +682,11 @@ pub(crate) fn cherry_move_plan(
         .map(ToOwned::to_owned);
 
     Ok(Plan {
-        base: source_parent,
+        base: base_parent,
         scope,
         steps,
         checkout: Some(PlanCheckout {
-            target: source_step,
+            target: head_step,
             reference,
         }),
         expected_refs,
@@ -2090,7 +2118,7 @@ fn write_commit(
     predecessor: Option<ObjectId>,
     committer: &gix::actor::Signature,
     state: CommitState,
-    signing: Option<gix::objs::commit::signature::Options>,
+    signing: Option<gix::commit::sign::Options>,
 ) -> Result<ObjectId> {
     Ok(write_commit_timed(repo, commit, predecessor, committer, state, signing)?.0)
 }
@@ -2101,7 +2129,7 @@ fn write_commit_timed(
     predecessor: Option<ObjectId>,
     committer: &gix::actor::Signature,
     state: CommitState,
-    signing: Option<gix::objs::commit::signature::Options>,
+    signing: Option<gix::commit::sign::Options>,
 ) -> Result<(ObjectId, Option<Duration>)> {
     if let Some(predecessor) = predecessor {
         crate::change_id::inherit(repo, &mut commit, predecessor)?;
@@ -3480,6 +3508,102 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn cherry_stack_moves_the_linear_range_and_reconnects_side_children() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        git(fixture.path(), &["checkout", "-q", "-b", "fork", "HEAD~1"])?;
+        std::fs::write(fixture.path().join("fork"), b"fork\n")?;
+        git(fixture.path(), &["add", "fork"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "fork"])?;
+        git(fixture.path(), &["checkout", "-q", "-b", "destination", "main~2"])?;
+        std::fs::write(fixture.path().join("destination"), b"destination\n")?;
+        git(fixture.path(), &["add", "destination"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "destination"])?;
+        std::fs::write(fixture.path().join("destination-child"), b"destination child\n")?;
+        git(fixture.path(), &["add", "destination-child"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "destination child"])?;
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let old_parent = repo.rev_parse_single("main~2")?.detach();
+        let base = repo.rev_parse_single("main~1")?.detach();
+        let head = repo.head_id()?.detach();
+        let fork = repo.rev_parse_single("fork")?.detach();
+        let target = repo.rev_parse_single("destination~1")?.detach();
+        let target_child = repo.rev_parse_single("destination")?.detach();
+
+        let outcome = perform_plan(&repo, &graph, cherry_stack_plan(&repo, &graph, base, head, target)?)?.complete()?;
+        let moved_base = outcome.map(base).context("the stack base is retained")?;
+        let moved_head = outcome.map(head).context("HEAD is retained")?;
+        let rewritten_fork = outcome.map(fork).context("the side child is retained")?;
+        let rewritten_target_child = outcome.map(target_child).context("the target child is retained")?;
+        let parent = |id| -> gix_testtools::Result<Option<ObjectId>> {
+            Ok(repo.find_commit(id)?.parent_ids().next().map(gix::Id::detach))
+        };
+        assert_eq!(
+            parent(moved_base)?,
+            Some(target),
+            "the stack is inserted above the target"
+        );
+        assert_eq!(
+            parent(moved_head)?,
+            Some(moved_base),
+            "the stack keeps its internal ancestry"
+        );
+        assert_eq!(
+            parent(rewritten_fork)?,
+            Some(old_parent),
+            "a non-stack child reconnects to its moved parent's original parent"
+        );
+        assert_eq!(
+            parent(rewritten_target_child)?,
+            Some(moved_head),
+            "the target's former child follows the moved stack"
+        );
+        assert_eq!(repo.head_id()?.detach(), moved_head, "checkout follows rewritten HEAD");
+        for (name, expected) in [
+            ("refs/patches/middle", moved_base),
+            ("refs/patches/tip", moved_head),
+            ("refs/heads/fork", rewritten_fork),
+            ("refs/heads/destination", rewritten_target_child),
+        ] {
+            assert_eq!(
+                repo.find_reference(name)?.id().detach(),
+                expected,
+                "{name} follows its corresponding rewrite"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn cherry_stack_rejects_invalid_ranges_and_cycles() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        git(fixture.path(), &["checkout", "-q", "-b", "cycle-target"])?;
+        std::fs::write(fixture.path().join("cycle-target"), b"cycle target\n")?;
+        git(fixture.path(), &["add", "cycle-target"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "cycle target"])?;
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let root = repo.rev_parse_single("main~2")?.detach();
+        let base = repo.rev_parse_single("main~1")?.detach();
+        let head = repo.head_id()?.detach();
+        let target = repo.rev_parse_single("cycle-target")?.detach();
+        let err = cherry_stack_plan(&repo, &graph, target, head, root)
+            .expect_err("the selected base must be in HEAD's ancestry");
+        assert!(err.to_string().contains("ancestor"), "{err:#}");
+        let err = cherry_stack_plan(&repo, &graph, base, head, base)
+            .expect_err("the insertion target cannot be part of the stack");
+        assert!(err.to_string().contains("moved stack"), "{err:#}");
+        let err = cherry_stack_plan(&repo, &graph, base, head, target)
+            .expect_err("inserting a stack into its own side descendant would cycle");
+        assert!(err.to_string().contains("cycle"), "{err:#}");
+        Ok(())
+    }
+
     #[test]
     fn cherry_move_inserts_head_before_every_target_child_and_keeps_its_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
index a2c67cb161a..4eef12c01ed 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__rebase__tests__reworded-middle-stack.snap
@@ -4,6 +4,15 @@ expression: "gix_testtools::repository::snapshot(fixture.path())?.to_string()"
 ---
 HEAD refs/heads/main -> C2
 
+[config]
+[core]
+	bare = false
+[user]
+	name = author
+	email = author@example.com
+[commit]
+	gpgSign = false
+
 [refs]
 refs/heads/main = C2
 refs/patches/middle = C1
@@ -11,10 +20,10 @@ refs/patches/tip = C2
 
 [commits]
 C0
-  tree T2
+  tree T1
   author author <author@example.com> 946684800 +0000
   committer committer <committer@example.com> 946684800 +0000
-  
+
   base
 
 C1
@@ -23,23 +32,23 @@ C1
   author author <author@example.com> 946771200 +0000
   committer rebasing committer <rebasing@example.com> 978307200 +0000
   change-id wtvpqoumovpvzypqrpsxxlkvxmltvtlxvomlzyxs
-  
+
   rewritten middle
 
 C2
-  tree T1
+  tree T2
   parent C1
   author author <author@example.com> 946857600 +0000
   committer rebasing committer <rebasing@example.com> 978307200 +0000
   change-id zvoumlrryyvtnnxxqnmrnlxnvtlmnvwlynmuuvux
-  
+
   tip
 
 [index]
-tree = T1
-100644 B1 stage=0 "base"
-100644 B2 stage=0 "middle"
-100644 B0 stage=0 "tip"
+tree = T2
+100644 B0 stage=0 "base"
+100644 B1 stage=0 "middle"
+100644 B2 stage=0 "tip"
 
 [worktree]
 100644 file "base" = "base\n"
@@ -50,9 +59,9 @@ tree = T1
 C1 = 1583a183c3a57fce524e7acdd5a1c007d5f0f9a9
 C0 = 5295d5ce934d18b6a1f48c3b7d836d53b55304e5
 T0 = 559dc660acc84805fedbcb75588371240372c173
-T1 = 569961a34e2a909d8c7a2940ed4ad365504e64ed
-T2 = 8552142164d268c95f60dabb74465a2f4ffb51b7
+T2 = 569961a34e2a909d8c7a2940ed4ad365504e64ed
+T1 = 8552142164d268c95f60dabb74465a2f4ffb51b7
 C2 = 91e50045e3c98994aebc74a28953fc04ce49cacf
-B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
-B1 = df967b96a579e45a18b8251732d16804b2e56a55
-B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
+B2 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
+B0 = df967b96a579e45a18b8251732d16804b2e56a55
+B1 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
index e73d00cb3c2..6129f3fc1a4 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -4,42 +4,52 @@ expression: "gix_testtools::repository::snapshot(fixture.path())?.to_string()"
 ---
 HEAD refs/heads/main -> C4
 
+[config]
+[core]
+	bare = false
+[user]
+	name = reviewer
+	email = reviewer@example.com
+[gitoxide "commit"]
+	authorDate = 2001-01-01T00:00:00 +0000
+	committerDate = 2001-01-01T00:00:00 +0000
+
 [refs]
 refs/heads/main = C4
 refs/heads/review-successor = C3
 
 [commits]
 C0
-  tree T1
+  tree T3
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
-  
+
   base
 
 C1
-  tree T0
+  tree T1
   parent C0
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
-  
+
   B
 
 C2
-  tree T3
+  tree T0
   parent C1
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
   change-id oxzuvntpklkyxykvvmmuzqomsnzrrwwvtuoxwttx
-  
+
   review
 
 C3
-  tree T3
+  tree T0
   parent C2
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
   change-id tlynrtysuoqktszrqppwrnsxpvokwvoqoqvkvqsv
-  
+
   review successor
 
 C4
@@ -49,7 +59,7 @@ C4
   committer reviewer <reviewer@example.com> 978307200 +0000
   change-id xlpouomvnxrqllnkynsusvqwkkwnlrttmrvxquso
   tix-rebase-parent 2cb49e443aa675eab8add679938ca6cd303ae353
-  
+
   A
 
 [index]
@@ -65,11 +75,11 @@ tree = T2
 C2 = 1a13dc5cbbc857de093c9a007e6b104a1a9ffbdb
 B0 = 223b7836fb19fdf64ba2d3cd6173c6a283141f78
 C1 = 2cb49e443aa675eab8add679938ca6cd303ae353
-T0 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
-T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+T1 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
+T3 = 6d5f482d15035cdd7733b1b551d1fead28d22592
 T2 = 74c148aa829dcd83ad2608b6d0862ae1e6981501
 C4 = 7b4c1808849fabbe6f5afcd94ff930defbda47f3
-T3 = 93664bfc7cc096fcc0d1ac962596031e10f26906
+T0 = 93664bfc7cc096fcc0d1ac962596031e10f26906
 C0 = c38a9f7427b84ed8ba5e187ec385489d82d71695
 C3 = e028a8e769407c249d118ddc499f0c064685ba16
 B1 = f70f10e4db19068f79bc43844b49f3eece45c4e8
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
index 4c984bb0b88..6b5a0febb66 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__time_travel__tests__accepted-pending-rebase-conflict.snap
@@ -4,20 +4,31 @@ expression: "gix_testtools::repository::snapshot(fixture.path())?\n.to_string().
 ---
 HEAD detached C1
 
+[config]
+[core]
+	bare = false
+[user]
+	name = author
+	email = author@example.com
+[commit]
+	gpgSign = false
+[gitoxide "commit"]
+	committerDate = 2001-01-01T00:00:00 +0000
+
 [refs]
 refs/heads/main = C2
 refs/worktree/tix/pins/HEAD = -> refs/heads/main
 
 [commits]
 C0
-  tree T0
+  tree T1
   author author <author@example.com> 946684800 +0000
   committer committer <committer@example.com> 946684800 +0000
 
   base
 
 C1
-  tree T0
+  tree T1
   parent C0
   author author <author@example.com> 946684800 +0000
   committer author <author@example.com> 978307200 +0000
@@ -27,7 +38,7 @@ C1
   tip
 
 C2
-  tree T1
+  tree T0
   parent C1
   author author <author@example.com> 946944000 +0000
   committer author <author@example.com> 978307200 +0000
@@ -38,9 +49,9 @@ C2
 
 [index]
 tree = conflicted
-100644 B2 stage=1 "file"
+100644 B0 stage=1 "file"
 100644 B1 stage=2 "file"
-100644 B0 stage=3 "file"
+100644 B2 stage=3 "file"
 
 [worktree]
 100644 file "file" = "<<<<<<< rebased parent\nbase\n=======\ntip\n>>>>>>> commit\n"
@@ -48,9 +59,9 @@ tree = conflicted
 [objects]
 C2 = 26d78d03083cfe539c4a94c28bd30d9a548a8394
 C1 = 69348f5557de103f6771f9a121ff67f5272ceab5
-T0 = 6d5f482d15035cdd7733b1b551d1fead28d22592
-T1 = 6f2762b571ef9a93001cc607058818aa5d0d055c
-B0 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
+T1 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+T0 = 6f2762b571ef9a93001cc607058818aa5d0d055c
+B2 = b218ebde2fc5b78f14aa04eeb42a74b17e2e367d
 C0 = c0b811a58f27425263a4276fe881de38736a9446
 B1 = df967b96a579e45a18b8251732d16804b2e56a55
-B2 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
+B0 = ea1a2ae6cdab2b53dee8943ca555c4312a0b798a
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 94d7d6b6c78..8ef82fe4120 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2465,7 +2465,7 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("squash: {err:#}")),
                     }
                 }
-                Effect::Move { source, target } => {
+                Effect::Move { source, base, target } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let result = (|| {
@@ -2475,7 +2475,11 @@ fn event_loop(
                         let mut repository = open_repository(&repository_path, repository_is_bare, false)
                             .context("could not open repository to move HEAD")?;
                         repository.object_cache_size(None);
-                        let plan = edit::rebase::cherry_move_plan(&repository, graph, source, target)?;
+                        let plan = if base == source {
+                            edit::rebase::cherry_move_plan(&repository, graph, source, target)?
+                        } else {
+                            edit::rebase::cherry_stack_plan(&repository, graph, base, source, target)?
+                        };
                         run_rebase_plan(terminal, repository.into_sync(), graph, plan)
                     })();
                     match result {
@@ -5084,13 +5088,16 @@ fn action_with_shortcut_groups(
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
         KeyCode::Char('c') if information_expanded => Some(Action::ToggleChanges),
         KeyCode::Char('p') if commit_expanded => Some(Action::Split),
-        KeyCode::Char('b') if commit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Rebase),
-        KeyCode::Char('u') if commit_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+        KeyCode::Char('b') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+            Some(Action::Rebase)
+        }
+        KeyCode::Char('u') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::RebaseUpdate)
         }
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
         KeyCode::Char('m') if actions_expanded => Some(Action::Move),
+        KeyCode::Char('v') if actions_expanded => Some(Action::MoveStack),
         KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Forkpoint)
         }
@@ -6389,8 +6396,6 @@ mod tests {
             "v closes the view shortcut group"
         );
         for (key, expected) in [
-            ('b', Action::Rebase),
-            ('u', Action::RebaseUpdate),
             ('o', Action::Reword),
             ('n', Action::NewCommit),
             ('m', Action::NewEmptyCommit),
@@ -6415,9 +6420,12 @@ mod tests {
             );
         }
         for (key, expected) in [
+            ('b', Action::Rebase),
+            ('u', Action::RebaseUpdate),
             ('r', Action::Review),
             ('s', Action::Squash),
             ('m', Action::Move),
+            ('v', Action::MoveStack),
             ('f', Action::Forkpoint),
         ] {
             assert_eq!(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8f9b450c23f..93fb5de19a5 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -985,12 +985,6 @@ pub(crate) fn draw_with_worktree(
         };
         if app.commit_expanded {
             let mut options = Vec::new();
-            if app.can_rebase() {
-                options.push(("rebase", 'b'));
-            }
-            if app.can_rebase_update() {
-                options.push(("rebase-update", 'u'));
-            }
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'o'));
             }
@@ -1053,6 +1047,12 @@ pub(crate) fn draw_with_worktree(
         actions_prefix_spans.push(Span::raw("ctions"));
         if app.actions_expanded {
             let mut options = Vec::new();
+            if app.can_rebase() {
+                options.push(("rebase", 'b'));
+            }
+            if app.can_rebase_update() {
+                options.push(("rebase-update", 'u'));
+            }
             if app.can_finish_review() {
                 options.push(("finish-review", 'r'));
             } else if app.can_review() {
@@ -1064,19 +1064,28 @@ pub(crate) fn draw_with_worktree(
             if app.can_move() {
                 options.push(("cherry-move", 'm'));
             }
+            let mut items = Vec::new();
+            for (label, key) in options {
+                if !items.is_empty() {
+                    items.push(Span::raw(" · "));
+                }
+                items.extend(shortcut(label, key, true));
+            }
+            if app.can_cherry_stack() {
+                if !items.is_empty() {
+                    items.push(Span::raw(" · "));
+                }
+                items.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
+                items.push(Span::raw(" cherry-move-stack"));
+            }
             if app.can_forkpoint() {
-                options.push(("forkpoint", 'f'));
+                if !items.is_empty() {
+                    items.push(Span::raw(" · "));
+                }
+                items.extend(shortcut("forkpoint", 'f', true));
             }
-            let mut items = Vec::new();
-            if options.is_empty() {
+            if items.is_empty() {
                 items.push(Span::raw("no actions"));
-            } else {
-                for (index, (label, key)) in options.into_iter().enumerate() {
-                    if index > 0 {
-                        items.push(Span::raw(" · "));
-                    }
-                    items.extend(shortcut(label, key, true));
-                }
             }
             actions_popup = Some(items);
             emphasize_prefix(&mut actions_prefix_spans[1..]);
@@ -3822,6 +3831,59 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn actions_popup_shows_the_prefixed_cherry_stack_shortcut() -> Result<(), Box<dyn std::error::Error>> {
+        let head = gix::ObjectId::Sha1([1; 20]);
+        let base = gix::ObjectId::Sha1([2; 20]);
+        let parent = gix::ObjectId::Sha1([3; 20]);
+        let target = gix::ObjectId::Sha1([4; 20]);
+        let commit = |id, parent: Option<gix::ObjectId>| Commit {
+            id,
+            parent_ids: parent.into_iter().collect(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: "subject".into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(4);
+        app.set_worktree_head(Some(head), false);
+        app.extend_commits(vec![
+            commit(head, Some(base)),
+            commit(base, Some(parent)),
+            commit(parent, None),
+            commit(target, None),
+        ]);
+        complete(&mut app);
+        app.selected = app.rows.iter().position(|row| row.id == base);
+        app.actions_expanded = true;
+        let mut terminal = Terminal::new(TestBackend::new(160, 5))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let popup = rendered_line(&terminal, 3);
+        let label = "v cherry-move-stack";
+        let start = popup[..popup.find(label).expect("the cherry-move-stack action is visible")]
+            .chars()
+            .count() as u16;
+        assert!(
+            terminal.backend().buffer()[(start, 3)]
+                .modifier
+                .contains(Modifier::UNDERLINED)
+        );
+        assert!(
+            (start + 1..start + label.len() as u16).all(|x| !terminal.backend().buffer()[(x, 3)]
+                .modifier
+                .contains(Modifier::UNDERLINED)),
+            "only the prefixed v is underlined"
+        );
+        Ok(())
+    }
+
     #[test]
     fn focused_paths_offer_only_their_scoped_edit_in_the_main_prefix() -> Result<(), Box<dyn std::error::Error>> {
         let id = gix::ObjectId::Sha1([1; 20]);
@@ -6115,12 +6177,18 @@ mod tests {
             "the terminal edge pushes the marker over clipped title text"
         );
         app.commit_expanded = true;
+        let mut commit = Terminal::new(TestBackend::new(120, 3))?;
+        commit.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_line(&commit, 1).contains(" pin "));
+        assert!(!rendered_line(&commit, 1).contains("rebase"));
+        app.commit_expanded = false;
+        app.actions_expanded = true;
         let mut actions = Terminal::new(TestBackend::new(120, 3))?;
         actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&actions, 1).contains(" rebase · rebase-update · pin ")
+            rendered_line(&actions, 1).contains(" rebase · rebase-update ")
                 && rendered_line(&actions, 2).contains("commit · actions"),
-            "the selected hidden base offers independent edits: {:?}",
+            "the selected hidden base offers rebasing from actions: {:?}",
             rendered_line(&actions, 1)
         );
         Ok(())

From d0c25caac5e049c881867bd32e51de61a0a8423d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 08:02:40 +0200
Subject: [PATCH 231/282] fix: keep tix rebase editors complete

Keep conflict previews armed while users navigate, center the conflicting row, require Enter or Escape, and absorb the resolved index before continuing.\n\nLoad metadata for the full editable todo scope and render commit/tree enrichment markers before signature state.
---
 gix-tix/spec.md               |  41 ++--
 gix-tix/src/app.rs            |  68 ++++++-
 gix-tix/src/command/rebase.rs |  49 +----
 gix-tix/src/edit/todo.rs      | 128 ++++++++++++-
 gix-tix/src/lib.rs            | 352 +++++++++++++++++++++++++++++++---
 5 files changed, 533 insertions(+), 105 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b89a3a2c780..2113a223a42 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -740,11 +740,13 @@ space first; changes blocks adapt within the remaining history width.
   pending history; traveling toward a non-pending ancestor leaves the entire
   pending region untouched. A conflict retains the ours tree, exact merge-result
   tree, conflict stages, prepared commits, and in-memory objects without changing
-  the repository. The conflicting row shows a blinking red `C`; `<enter>` persists
+  the repository. The actual conflicting row is selected and centered with normal
+  history-boundary clamping and shows a blinking red `C`; `<enter>` persists
   the prepared rebase, leaves later descendants lazy, checks out the conflicting
   commit at the ours tree, then checks out the merge result and derives the
-  unmerged index from it. Any other key discards
-  the suspended operation; key-release events are not actions and leave it armed.
+  unmerged index from it. `Esc` discards the suspended operation; navigation and
+  other read-only actions leave the choice armed, while repository-changing actions
+  and refresh are blocked. Key-release events are not actions and leave it armed.
   Diagnostics warn when a conflict suspends the rebase and record whether it is
   accepted, discarded, or fails during checkout.
 - A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
@@ -860,9 +862,9 @@ space first; changes blocks adapt within the remaining history width.
   being departed necessarily follows the successful checkout. Newly written
   unreachable objects may remain for normal Git garbage collection.
 - A suspended conflict temporarily owns a cloned repository with object memory
-  while awaiting one confirmation key. Dropping it writes nothing; accepting it
-  consumes the repository immediately after persisting the commit at the ours
-  tree and materializing the retained merge result in the worktree and index.
+  while awaiting an explicit `<enter>` or `Esc` choice. Dropping it writes nothing;
+  accepting it consumes the repository immediately after persisting the commit at
+  the ours tree and materializing the retained merge result in the worktree and index.
 
 ### History rebase editor
 
@@ -870,8 +872,9 @@ space first; changes blocks adapt within the remaining history width.
   `.md` todo. Its editable plan is read bottom-to-top like the history view:
   newest commands and refs are highest, and each stack ends in a centered
   `──── fork <id> ────` separator below its oldest command.
-  IDs are shortened through repository configuration; metadata repeats the
-  information visible in history and always includes the subject. Base-level
+  IDs are shortened through repository configuration; metadata is loaded across
+  the complete todo scope, repeats the full information visible in history, and
+  always includes the subject. Base-level
   stacks end with `fork <id> (base) <title>` in the separator, using the title
   exactly as displayed in history without Markdown escaping. Fork points within the editable tree
   remain plain `fork <id>` separators. Every separator is centered with at least
@@ -927,7 +930,8 @@ space first; changes blocks adapt within the remaining history width.
 - Pick lines use display-only state symbols documented in the footer: `↻` for a
   lazy rebase, `◌` for an invalidated signature awaiting signing, `◐` for an
   unverified signature, and `○` for an unsigned commit. Applicable states may be
-  combined without changing plan semantics.
+  combined without changing plan semantics. Applicable `🚧`, `📝`, and `✔️`
+  enrichment gutter symbols appear before the signature-state disk as metadata.
 - `@pick`, `@squash`, or `@empty` chooses the post-rebase commit. A generated
   todo keeps this marker even when `HEAD` is attached, but shows its branch as an
   ordinary ref. Versioned state remembers that attachment while the ref stays
@@ -944,16 +948,21 @@ space first; changes blocks adapt within the remaining history width.
   markers, and invalidate old signatures for later time travel. With no `@`,
   ordinary steps remain lazy while squash groups are still materialized.
   Any conflict while applying a history todo first remains entirely in memory.
-  The TUI projects the partial result, selects the actual conflicting result, and
-  marks it with a blinking red `C`; predicted ref decorations remain at their
+  The TUI projects the partial result, selects and centers the actual conflicting
+  result with normal history-boundary clamping, and marks it with a blinking red
+  `C`; predicted ref decorations remain at their
   repository positions. Repository-backed overlay content is hidden while these
-  candidate objects exist only in memory. `<enter>` accepts the partial result,
+  candidate objects exist only in memory. History and pane navigation and other
+  read-only actions leave the preview armed; repository-changing actions and
+  refresh are blocked. `<enter>` accepts the partial result,
   moves already-final refs, records the ours tree in the conflicting commit, and
   checks out the retained merge result with an unmerged index,
-  and retains an in-memory continuation plan. Any other key discards the preview
-  without writes.
-  Once the index has no unresolved stages, `<enter>` continues; another conflict
-  repeats the same choice.
+  and retains an in-memory continuation plan. Only `Esc` discards the preview
+  without writes. On continuation, `<enter>` stages paths that still have unresolved
+  index entries, refuses to proceed if any unresolved stages remain, and amends the
+  current conflicting commit from the complete staged index, including any additional
+  staged changes. Unrelated unstaged changes remain untouched. Another conflict
+  repeats the same explicit choice.
 - Command-line apply, including todo `--edit-and-apply`, reports a conflict
   without changes unless `--materialize-conflicts` was explicitly supplied. Its
   continuation document uses the full null object ID for the command whose tree
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 5fac6a750fb..7342f948721 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -728,7 +728,7 @@ impl App {
                 "REBASE PAUSED · <enter> continue · Esc stop"
             })
         } else if self.pending_rebase_conflict.is_some() {
-            Some("rebase conflict · <enter> checkout for resolution · any other key cancel")
+            Some("rebase conflict · <enter> checkout for resolution · Esc cancel")
         } else if self.review_return_selection_active() {
             Some("review return is missing · j/k select commit · <enter> finish detached · Esc cancel")
         } else if self.review_selection_active() {
@@ -786,6 +786,12 @@ impl App {
         );
         self.pending_rebase_conflict = Some(id);
         self.rebase_continuation_pending = false;
+        if let Some(index) = self.rows.iter().position(|row| row.id == id) {
+            self.select(index);
+            self.center_selection();
+        } else {
+            self.selection_after_refresh = Some(id);
+        }
     }
 
     pub(crate) fn has_rebase_conflict(&self) -> bool {
@@ -1841,7 +1847,14 @@ impl App {
         if self.reachability_anchor.is_some() {
             self.compute_reachable_rows();
         }
-        self.ensure_visible();
+        if self
+            .pending_rebase_conflict
+            .is_some_and(|id| self.selected.is_some_and(|index| self.rows[index].id == id))
+        {
+            self.center_selection();
+        } else {
+            self.ensure_visible();
+        }
     }
 
     #[cfg(test)]
@@ -2497,16 +2510,21 @@ impl App {
             }
             return;
         };
-        let height = self.viewport_rows.max(1);
-        let centered = selected.saturating_sub(height / 2);
-        let max_offset = self.rows.len().saturating_sub(height);
         self.selected = Some(selected);
-        self.offset = centered.min(max_offset);
+        self.center_selection();
         if matches!(self.state, State::Complete | State::Cancelled) {
             self.pending_initial_selection = None;
         }
     }
 
+    fn center_selection(&mut self) {
+        let Some(selected) = self.selected else { return };
+        let height = self.viewport_rows.max(1);
+        self.offset = selected
+            .saturating_sub(height / 2)
+            .min(self.rows.len().saturating_sub(height));
+    }
+
     pub(crate) fn set_horizontal_bounds(&mut self, page: usize, max: usize) {
         self.horizontal_page = page.max(1);
         self.horizontal_max = max;
@@ -3616,6 +3634,44 @@ mod tests {
         assert!(app.changes_visible(), "clearing the preview restores the changes view");
     }
 
+    #[test]
+    fn rebase_conflicts_are_selected_and_centered() {
+        let mut app = App::new(3);
+        app.extend_commits((1..=7).rev().map(row).collect::<Vec<_>>());
+        complete(&mut app);
+
+        app.arm_rebase_conflict(id(4));
+
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+        assert_eq!(app.offset, 2, "the conflict is centered in the three-row viewport");
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("rebase conflict · <enter> checkout for resolution · Esc cancel".into())
+        );
+    }
+
+    #[test]
+    fn an_unloaded_rebase_conflict_is_centered_after_refresh() {
+        let mut app = App::new(3);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+        app.arm_rebase_conflict(id(4));
+
+        let rows = app
+            .start_refresh(
+                vec![row_with_parents(5, &[4]), row_with_parents(4, &[2])].into(),
+                &[id(3), id(5)],
+                &[],
+                false,
+            )
+            .expect("the conflict refresh computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
+        assert_eq!(app.offset, 1, "the newly loaded conflict is centered");
+    }
+
     #[test]
     fn lane_computation_keeps_provisional_rows_interactive() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 6dde6a81109..40c4e4eaf64 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -1,5 +1,4 @@
 use std::{
-    collections::HashMap,
     ffi::{OsStr, OsString},
     io::{IsTerminal, Read, Write},
     path::{Path, PathBuf},
@@ -167,53 +166,7 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
         )
     };
 
-    let mut notes = repo
-        .notes()
-        .map_err(gix::Exn::into_error)
-        .context("could not open Git notes")?;
-    let row_indices: HashMap<_, _> = app
-        .rows
-        .iter()
-        .enumerate()
-        .map(|(index, row)| (row.id, index))
-        .collect();
-    for id in &scope {
-        let index = row_indices
-            .get(id)
-            .copied()
-            .context("an editable commit disappeared from the history view")?;
-        if !app.rows[index].metadata_loaded {
-            let (metadata, attributions) =
-                history::load_metadata(repo, *id, &authors).context("could not load editable commit metadata")?;
-            app.set_metadata(index, metadata, attributions);
-        }
-        let loaded = notes
-            .get(*id)
-            .map_err(gix::Exn::into_error)
-            .context("could not load commit notes")?
-            .into_iter()
-            .map(|note| {
-                let mut blob = note.blob;
-                blob.take_data().into()
-            })
-            .collect();
-        app.set_notes(*id, loaded);
-    }
-    let mailmap = repo.open_mailmap();
-    let commits = scope
-        .iter()
-        .map(|id| {
-            let row = row_indices
-                .get(id)
-                .and_then(|index| app.rows.get(*index))
-                .context("an editable commit disappeared while formatting the todo")?;
-            Ok(todo::Commit {
-                id: *id,
-                parents: row.parent_ids.iter().copied().collect(),
-                info: crate::ui::todo_metadata(&app, row, &mailmap),
-            })
-        })
-        .collect::<Result<Vec<_>>>()?;
+    let commits = crate::load_rebase_todo_commits(repo, &mut app, &authors, &scope)?;
     todo::prepare(repo, base, onto, &commits, &refs.view_tips, onto_kind, true)
 }
 
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index d1f069f2eaf..8bd5b0142ed 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -25,7 +25,7 @@ const HELP: &str = r#"
 - Saving an unchanged document in the history-view editor is a no-op unless the ancestry ending at `@` has a pending rebase. Explicit `tix rebase apply` and `--edit-and-apply` apply valid unchanged plans. Unchanged picks whose parent stays unchanged retain their IDs; replay starts at the first pending or structurally changed commit. Changed commits through `@` are cherry-picked and re-signed, while descendants and other stacks remain lazily rebased with invalidated signatures until time travel reaches them.
 - Tix pins, stashes, and review refs, tags, remote-tracking refs, and symbolic refs stay unchanged and hidden. A ref checked out by another worktree may be moved but not deleted. New unreferenced leaves are pinned.
 - A todo conflict changes nothing unless explicitly accepted. The TUI offers `<enter>` to materialize it; command-line apply requires `--materialize-conflicts [CONTINUE]` and writes a continuation todo. Resolve the ordinary unmerged index, then apply that todo. Concurrent ref changes still abort the update.
-- Commit states are display-only and editing them has no effect: `↻` means a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, `○` means unsigned, and `🎁` means worktree state is stashed for that commit. Stashes follow rewritten commits automatically; dropping a stashed commit or combining multiple stashes into one result is rejected.
+- Commit states are display-only and editing them has no effect: `🚧` means the commit is a todo, `📝` it has a note, `✔️` its tree passed checks, `↻` a lazy rebase is pending, `◌` an empty signature awaits signing, `◐` a signature is present but unverified, `○` means unsigned, and `🎁` means worktree state is stashed for that commit. Stashes follow rewritten commits automatically; dropping a stashed commit or combining multiple stashes into one result is rejected.
 -->
 "#;
 
@@ -201,6 +201,8 @@ pub(crate) fn prepare(
     };
     let anchor_title = anchor_title(repo, onto)?;
     let mut body = Vec::new();
+    let mut enrichments = crate::enrich::open(repo)?;
+    let mut tree_enrichments = crate::enrich::open_tree(repo)?;
     for (section_index, section) in sections.iter().enumerate() {
         if section_index > 0 {
             body.push(b'\n');
@@ -222,7 +224,7 @@ pub(crate) fn prepare(
             } else {
                 "pick"
             };
-            let states = commit_states(repo, *id)?;
+            let states = commit_states(repo, &mut enrichments, &mut tree_enrichments, *id)?;
             body.extend_from_slice(
                 format!(
                     "`{verb} {}` {states}{}\n",
@@ -278,6 +280,8 @@ pub(crate) fn prepare_continuation(
     };
     let mut document = b"<!-- Rebase help follows. Saving unchanged continues the materialized rebase; empty this file or remove the tix-rebase-state-v2 comment to cancel. -->\n# Continue materialized rebase\n\n".to_vec();
     let mut body = Vec::new();
+    let mut enrichments = crate::enrich::open(repo)?;
+    let mut tree_enrichments = crate::enrich::open_tree(repo)?;
     for (index, step) in plan.steps.iter().enumerate() {
         let continues = matches!(step.parent, rebase::PlanParent::Step(parent) if parent + 1 == index);
         if !continues {
@@ -334,7 +338,12 @@ pub(crate) fn prepare_continuation(
                 };
                 let title = anchor_title(repo, id)?;
                 body.extend_from_slice(
-                    format!("`{marker}pick {value}` {}{}\n", commit_states(repo, id)?, title).as_bytes(),
+                    format!(
+                        "`{marker}pick {value}` {}{}\n",
+                        commit_states(repo, &mut enrichments, &mut tree_enrichments, id)?,
+                        title
+                    )
+                    .as_bytes(),
                 );
             }
             rebase::PlanCommit::Empty(ref title) => {
@@ -347,7 +356,7 @@ pub(crate) fn prepare_continuation(
                 format!(
                     "`squash {}` {}{}\n",
                     short(repo, *id, show_change_ids)?,
-                    commit_states(repo, *id)?,
+                    commit_states(repo, &mut enrichments, &mut tree_enrichments, *id)?,
                     title
                 )
                 .as_bytes(),
@@ -477,7 +486,12 @@ fn ref_display_name(name: &gix::refs::FullName, refs: &[rebase::ExpectedRef]) ->
     }
 }
 
-fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
+fn commit_states(
+    repo: &gix::Repository,
+    enrichments: &mut gix::note::Platform,
+    tree_enrichments: &mut gix::note::Platform,
+    id: ObjectId,
+) -> Result<String> {
     let commit = repo
         .find_commit(id)
         .context("could not load a commit state for the rebase todo")?
@@ -501,7 +515,29 @@ fn commit_states(repo: &gix::Repository, id: ObjectId) -> Result<String> {
     let stashed = repo
         .try_find_reference(super::stash::reference(id)?.as_ref())?
         .is_some();
-    let mut out = Vec::with_capacity(4);
+    let enrichment =
+        crate::change_id::for_commit(repo, id).and_then(|change_id| crate::enrich::load(enrichments, change_id));
+    let enrichment = match enrichment {
+        Ok(enrichment) => enrichment,
+        Err(err) => {
+            tracing::warn!(commit_id = %id, error = %err, "ignored malformed tix enrichment");
+            crate::enrich::Enrichment::default()
+        }
+    };
+    let tree_enrichment =
+        crate::enrich::tree_id(repo, id).and_then(|tree_id| crate::enrich::load_tree(tree_enrichments, tree_id));
+    let tree_enrichment = match tree_enrichment {
+        Ok(enrichment) => enrichment,
+        Err(err) => {
+            tracing::warn!(commit_id = %id, error = %err, "ignored malformed tix tree enrichment");
+            crate::enrich::TreeEnrichment::default()
+        }
+    };
+    let marker = crate::enrich::marker(enrichment.todo, enrichment.note.is_some(), tree_enrichment.checks_pass);
+    let mut out = Vec::with_capacity(6);
+    if !marker.is_empty() {
+        out.push(marker);
+    }
     if pending {
         out.push("↻");
     }
@@ -1323,6 +1359,86 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn enrichment_markers_precede_commit_states_in_initial_and_continuation_todos() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        crate::enrich::ensure_todo(&repo, middle, true)?;
+        crate::enrich::set_note(&repo, middle, Some(b"follow up"))?;
+        crate::enrich::ensure_checks_pass(&repo, middle, true)?;
+
+        let id = crate::change_id::display_short(&repo, middle)?;
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let document = String::from_utf8(prepared.document)?;
+        assert!(
+            document.contains(&format!("`pick {id}` 🚧📝✔️ ○ 2000-01-02")),
+            "commit and tree enrichments precede the unsigned signature state"
+        );
+        assert!(
+            document.contains("`🚧` means the commit is a todo, `📝` it has a note, `✔️` its tree passed checks"),
+            "the embedded legend explains enrichment states"
+        );
+
+        repo.reference(
+            super::super::stash::reference(middle)?,
+            tip,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test enriched todo stash ordering",
+        )?;
+        let prepared = prepare_continuation(
+            &repo,
+            &rebase::Plan {
+                base,
+                scope: vec![middle],
+                steps: vec![rebase::PlanStep {
+                    parent: rebase::PlanParent::Existing(base),
+                    commit: rebase::PlanCommit::Pick(middle),
+                    squash: Vec::new(),
+                }],
+                checkout: None,
+                expected_refs: Vec::new(),
+            },
+            vec![middle],
+            true,
+        )?;
+        let document = String::from_utf8(prepared.document)?;
+        assert!(
+            document.contains(&format!("`pick {id}` 🚧📝✔️ ○ 🎁 middle")),
+            "continuation todos retain enrichment ordering before stash state"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn malformed_enrichments_do_not_prevent_todo_generation() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let (base, middle, tip, commits) = commits(&repo)?;
+        let change_id = crate::change_id::for_commit(&repo, middle)?;
+        let reference: gix::refs::FullName = crate::enrich::REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(reference.as_ref(), ObjectId::from(change_id), b"[commit")
+            .map_err(gix::Exn::into_error)?;
+        let tree_id = crate::enrich::tree_id(&repo, middle)?;
+        let reference: gix::refs::FullName = crate::enrich::TREE_REF_NAME.try_into()?;
+        repo.notes()
+            .map_err(gix::Exn::into_error)?
+            .add_to_ref(reference.as_ref(), tree_id, b"[tree")
+            .map_err(gix::Exn::into_error)?;
+
+        let prepared = prepare_test(&repo, base, base, &commits, Some(tip))?;
+        let document = String::from_utf8(prepared.document)?;
+        let line = document
+            .lines()
+            .find(|line| line.contains("2000-01-02 author middle"))
+            .expect("the malformed enrichment commit remains in the todo");
+        assert!(line.contains(" ○ "), "ordinary commit states remain visible");
+        for marker in ["🚧", "📝", "✔️"] {
+            assert!(!line.contains(marker), "malformed enrichments are ignored");
+        }
+        Ok(())
+    }
+
     #[test]
     fn state_round_trips_non_utf8_ref_names_and_controls_cancellation() -> gix_testtools::Result {
         let (_fixture, repo) = repo()?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 8ef82fe4120..eb81f810f2b 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1792,6 +1792,7 @@ fn event_loop(
             urgent = true;
         }
         if key_pressed
+            && action == Some(Action::Cancel)
             && pending_rebase_conflict.is_none()
             && pending_todo_rebase_conflict.is_none()
             && app.has_rebase_conflict()
@@ -1799,6 +1800,7 @@ fn event_loop(
             app.clear_rebase_conflict();
             dirty = true;
             urgent = true;
+            continue;
         }
         if key_pressed && pending_rebase_conflict.is_some() {
             if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
@@ -1842,13 +1844,16 @@ fn event_loop(
                 urgent = true;
                 continue;
             }
-            let conflict = pending_rebase_conflict
-                .take()
-                .expect("a pending conflict was checked before discarding it");
-            tracing::info!(commit_id = %conflict.original(), ?action, "discarded suspended rebase conflict");
-            app.clear_rebase_conflict();
-            dirty = true;
-            urgent = true;
+            if action == Some(Action::Cancel) && app.changes_focus.is_none() {
+                let conflict = pending_rebase_conflict
+                    .take()
+                    .expect("a pending conflict was checked before discarding it");
+                tracing::info!(commit_id = %conflict.original(), "discarded suspended rebase conflict");
+                app.clear_rebase_conflict();
+                dirty = true;
+                urgent = true;
+                continue;
+            }
         }
         if key_pressed && pending_todo_rebase_conflict.is_some() {
             if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
@@ -1881,14 +1886,24 @@ fn event_loop(
                 urgent = true;
                 continue;
             }
-            let conflict = pending_todo_rebase_conflict
-                .take()
-                .expect("a pending todo conflict was checked before discarding it");
-            tracing::info!(commit_id = %conflict.original(), ?action, "discarded suspended todo rebase conflict");
-            app.clear_rebase_conflict();
-            refresh_pending = true;
+            if action == Some(Action::Cancel) && app.changes_focus.is_none() {
+                let conflict = pending_todo_rebase_conflict
+                    .take()
+                    .expect("a pending todo conflict was checked before discarding it");
+                tracing::info!(commit_id = %conflict.original(), "discarded suspended todo rebase conflict");
+                app.clear_rebase_conflict();
+                refresh_pending = true;
+                dirty = true;
+                urgent = true;
+                continue;
+            }
+        }
+        if (pending_rebase_conflict.is_some() || pending_todo_rebase_conflict.is_some())
+            && !action_allowed_during_rebase_continuation(action.as_ref(), app.changes_focus.is_some())
+        {
             dirty = true;
             urgent = true;
+            continue;
         }
         if key_pressed
             && action == Some(Action::Cancel)
@@ -1915,6 +1930,7 @@ fn event_loop(
                 let mut repository = open_repository(&repository_path, repository_is_bare, false)
                     .context("could not reopen repository to continue the rebase")?;
                 repository.object_cache_size(None);
+                stage_resolved_conflict_paths(&repository)?;
                 let graph = HistoryGraph::for_commits(&repository, &plan.scope)?;
                 run_rebase_plan(terminal, repository.into_sync(), &graph, plan.clone())
             })();
@@ -2334,21 +2350,12 @@ fn event_loop(
                 Effect::Rebase { base, onto, commits } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    let todo_commits = commits
-                        .iter()
-                        .map(|id| {
-                            let row = app
-                                .rows
-                                .iter()
-                                .find(|row| row.id == *id)
-                                .context("an editable commit disappeared from the view")?;
-                            Ok(edit::todo::Commit {
-                                id: *id,
-                                parents: row.parent_ids.to_vec(),
-                                info: ui::todo_metadata(&app, row, &mailmap),
-                            })
-                        })
-                        .collect::<Result<Vec<_>>>();
+                    let todo_commits = (|| {
+                        let mut repository = open_repository(&repository_path, repository_is_bare, false)
+                            .context("could not open repository before formatting the rebase todo")?;
+                        repository.object_cache_size(None);
+                        load_rebase_todo_commits(&repository, &mut app, &authors, &commits)
+                    })();
                     let result = history_graph
                         .as_ref()
                         .context("rebasing requires a completed history graph")
@@ -3949,6 +3956,61 @@ fn reword_commit(
     edit::reword::apply(repository, graph, id, &edited).map(Some)
 }
 
+pub(crate) fn load_rebase_todo_commits(
+    repository: &gix::Repository,
+    app: &mut App,
+    authors: &SharedAuthors,
+    scope: &[gix::ObjectId],
+) -> Result<Vec<edit::todo::Commit>> {
+    let row_indices: HashMap<_, _> = app
+        .rows
+        .iter()
+        .enumerate()
+        .map(|(index, row)| (row.id, index))
+        .collect();
+    let mut notes = repository
+        .notes()
+        .map_err(gix::Exn::into_error)
+        .context("could not open Git notes")?;
+    for id in scope {
+        let index = row_indices
+            .get(id)
+            .copied()
+            .context("an editable commit disappeared from the history view")?;
+        if !app.rows[index].metadata_loaded {
+            let (metadata, attributions) =
+                history::load_metadata(repository, *id, authors).context("could not load editable commit metadata")?;
+            app.set_metadata(index, metadata, attributions);
+        }
+        let loaded = notes
+            .get(*id)
+            .map_err(gix::Exn::into_error)
+            .context("could not load commit notes")?
+            .into_iter()
+            .map(|note| {
+                let mut blob = note.blob;
+                BString::from(blob.take_data())
+            })
+            .collect();
+        app.set_notes(*id, loaded);
+    }
+    let mailmap = repository.open_mailmap();
+    scope
+        .iter()
+        .map(|id| {
+            let row = row_indices
+                .get(id)
+                .and_then(|index| app.rows.get(*index))
+                .context("an editable commit disappeared while formatting the todo")?;
+            Ok(edit::todo::Commit {
+                id: *id,
+                parents: row.parent_ids.to_vec(),
+                info: ui::todo_metadata(app, row, &mailmap),
+            })
+        })
+        .collect()
+}
+
 #[tracing::instrument(skip_all, fields(base = %base, commits = commits.len()))]
 #[expect(
     clippy::too_many_arguments,
@@ -4001,6 +4063,58 @@ fn rebase_history(
     run_rebase_plan(terminal, repository.into_sync(), graph, parsed.plan).map(Some)
 }
 
+fn stage_resolved_conflict_paths(repository: &gix::Repository) -> Result<()> {
+    let index = repository
+        .open_index()
+        .context("could not inspect the conflict index")?;
+    let mut paths: Vec<BString> = index
+        .entries()
+        .iter()
+        .filter(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+        .map(|entry| entry.path(&index).to_owned())
+        .collect();
+    paths.sort();
+    paths.dedup();
+    if paths.is_empty() {
+        return Ok(());
+    }
+
+    let workdir = repository
+        .workdir()
+        .context("cannot resolve a conflict without a worktree")?;
+    let mut command = Command::new("git");
+    command
+        .arg("--literal-pathspecs")
+        .arg("-C")
+        .arg(workdir)
+        .args(["add", "-A", "--"]);
+    for path in &paths {
+        command.arg(gix::path::from_bstr(path.as_bstr()).as_ref());
+    }
+    let output = command
+        .output()
+        .context("could not launch git add for resolved paths")?;
+    if !output.status.success() {
+        let stderr = output.stderr.trim().to_str_lossy();
+        if stderr.is_empty() {
+            anyhow::bail!("git add for resolved paths failed with {}", output.status);
+        }
+        anyhow::bail!("git add for resolved paths failed with {}: {stderr}", output.status);
+    }
+
+    let index = repository
+        .open_index()
+        .context("could not verify the resolved conflict index")?;
+    if index
+        .entries()
+        .iter()
+        .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+    {
+        anyhow::bail!("the conflict index still has unresolved entries");
+    }
+    Ok(())
+}
+
 fn preview_todo_rebase_conflict(
     app: &mut App,
     conflict: &edit::rebase::PlanConflict,
@@ -5055,7 +5169,6 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
                 | Action::ToggleMailmap
                 | Action::CycleRefs
                 | Action::ToggleRefs
-                | Action::ToggleHidden
                 | Action::ToggleHistoryDisplay
                 | Action::ToggleInformation
                 | Action::ToggleAlign
@@ -6633,6 +6746,8 @@ mod tests {
         }
         for action in [
             Action::Refresh,
+            Action::ToggleHidden,
+            Action::ToggleRefTree,
             Action::ToggleCommitGroup,
             Action::Amend,
             Action::Rebase,
@@ -7052,6 +7167,185 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn continuing_a_conflict_commits_the_complete_resolved_index() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let git = |args: &[&str]| Command::new("git").arg("-C").arg(fixture.path()).args(args).output();
+        #[cfg(unix)]
+        let conflict_path = ":(glob)*";
+        #[cfg(not(unix))]
+        let conflict_path = "file";
+        let deleted_path = "deleted-conflict";
+        std::fs::write(fixture.path().join(conflict_path), b"conflict base\n")?;
+        std::fs::write(fixture.path().join(deleted_path), b"delete base\n")?;
+        assert!(
+            git(&["--literal-pathspecs", "add", "--", conflict_path, deleted_path,])?
+                .status
+                .success()
+        );
+        assert!(git(&["commit", "-qm", "conflict base"])?.status.success());
+        assert!(git(&["checkout", "-q", "-b", "conflict-side"])?.status.success());
+        std::fs::write(fixture.path().join(conflict_path), b"side\n")?;
+        std::fs::write(fixture.path().join(deleted_path), b"side\n")?;
+        assert!(git(&["commit", "-qam", "side"])?.status.success());
+        assert!(git(&["checkout", "-q", "main"])?.status.success());
+        std::fs::write(fixture.path().join(conflict_path), b"main\n")?;
+        std::fs::write(fixture.path().join(deleted_path), b"main\n")?;
+        assert!(git(&["commit", "-qam", "main"])?.status.success());
+        assert!(
+            !git(&["merge", "--no-edit", "conflict-side"])?.status.success(),
+            "the fixture produces an ordinary unmerged index"
+        );
+        std::fs::write(fixture.path().join(conflict_path), b"resolved\n")?;
+        std::fs::remove_file(fixture.path().join(deleted_path))?;
+        std::fs::write(fixture.path().join("already-staged"), b"staged\n")?;
+        assert!(git(&["add", "already-staged"])?.status.success());
+        std::fs::write(fixture.path().join("unrelated"), b"unstaged\n")?;
+
+        let repository = test_repository::open(fixture.path())?;
+        stage_resolved_conflict_paths(&repository)?;
+
+        let index = repository.index_or_empty()?;
+        assert!(
+            index
+                .entries()
+                .iter()
+                .all(|entry| entry.stage() == gix::index::entry::Stage::Unconflicted),
+            "resolved paths no longer retain conflict stages"
+        );
+        let staged = git(&["diff", "--cached", "--name-only"])?.stdout;
+        assert_eq!(
+            staged.as_bstr().lines().collect::<HashSet<_>>(),
+            HashSet::from([
+                b"already-staged".as_slice(),
+                conflict_path.as_bytes(),
+                deleted_path.as_bytes(),
+            ]),
+            "edited and deleted resolutions join changes that were already staged"
+        );
+
+        let head = repository.head_id()?.detach();
+        let parent = repository
+            .find_commit(head)?
+            .parent_ids()
+            .next()
+            .map(gix::Id::detach)
+            .context("the conflicted commit has a parent")?;
+        let plan = edit::rebase::Plan {
+            base: parent,
+            scope: vec![head],
+            steps: vec![edit::rebase::PlanStep {
+                parent: edit::rebase::PlanParent::Existing(parent),
+                commit: edit::rebase::PlanCommit::Resolved(head),
+                squash: Vec::new(),
+            }],
+            checkout: Some(edit::rebase::PlanCheckout {
+                target: edit::rebase::PlanParent::Step(0),
+                reference: None,
+            }),
+            expected_refs: Vec::new(),
+        };
+        let graph = HistoryGraph::for_commits(&repository, &plan.scope)?;
+        let outcome = edit::rebase::perform_plan(&repository, &graph, plan)?.complete()?;
+        let resolved = outcome.map(head).context("the conflicted commit is retained")?;
+        edit::time_travel::checkout_without_replay(fixture.path(), false, resolved, &[], false)?;
+
+        let repository = test_repository::open(fixture.path())?;
+        assert_eq!(
+            repository.head_id()?.detach(),
+            resolved,
+            "HEAD selects the resolved commit"
+        );
+        for (path, expected) in [
+            (conflict_path, b"resolved\n".as_slice()),
+            ("already-staged", b"staged\n"),
+        ] {
+            let object = format!("{resolved}:{path}");
+            assert_eq!(
+                git(&["show", &object])?.stdout,
+                expected,
+                "{path} is absorbed into HEAD"
+            );
+        }
+        let deleted = format!("{resolved}:{deleted_path}");
+        assert!(
+            !git(&["cat-file", "-e", &deleted])?.status.success(),
+            "a deleted conflict is absent from HEAD"
+        );
+        assert!(
+            git(&["diff", "--cached", "--quiet"])?.status.success(),
+            "the resolved commit leaves no staged changes"
+        );
+        assert!(
+            repository
+                .index_or_empty()?
+                .entries()
+                .iter()
+                .all(|entry| entry.stage() == gix::index::entry::Stage::Unconflicted),
+            "the final index has no conflict stages"
+        );
+        assert!(
+            !git(&["ls-files", "--error-unmatch", "unrelated"])?.status.success(),
+            "unrelated unstaged paths remain untouched"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn rebase_todo_loads_metadata_for_the_entire_editable_scope() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let scope = ["HEAD", "HEAD~1", "HEAD~2"]
+            .into_iter()
+            .map(|revision| Ok(repository.rev_parse_single(revision)?.detach()))
+            .collect::<gix_testtools::Result<Vec<_>>>()?;
+        let unloaded_author = Box::leak(Box::new(app::Author {
+            name: b"".as_bstr(),
+            email: b"".as_bstr(),
+        }));
+        let rows = scope
+            .iter()
+            .map(|id| {
+                let commit = repository.find_commit(*id)?;
+                Ok(app::Commit {
+                    id: *id,
+                    parent_ids: commit.parent_ids().map(gix::Id::detach).collect(),
+                    committer_time: gix::date::Time::default(),
+                    author_time: gix::date::Time::default(),
+                    author: unloaded_author,
+                    attributions: 0..0,
+                    title: BString::default(),
+                    metadata_loaded: false,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: app::SignatureState::Unsigned,
+                })
+            })
+            .collect::<gix_testtools::Result<Vec<_>>>()?;
+        let mut app = App::new(1);
+        app.extend_commits(rows);
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+
+        let commits = load_rebase_todo_commits(&repository, &mut app, &authors, &scope)?;
+
+        assert!(app.rows.iter().all(|row| row.metadata_loaded));
+        for (commit, title) in commits.iter().zip(["tip", "middle", "base"]) {
+            assert!(
+                commit.info.contains("author"),
+                "author metadata is loaded: {}",
+                commit.info
+            );
+            assert!(commit.info.contains(title), "the real title is loaded: {}", commit.info);
+            assert!(
+                !commit.info.contains("1970-01-01"),
+                "missing dates never leak into the editor: {}",
+                commit.info
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn todo_conflict_preview_selects_the_partial_result_in_memory() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;

From 2f780d7aecd9bb35dab7dee0f72f90f22a86d7d2 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 08:06:31 +0200
Subject: [PATCH 232/282] fix: keep tix popouts clear of messages

Shift notices and pane status rows above visible prefix popouts, suppressing a popout only when a protected row has no space to move. Reverse only the title of an unselected HEAD row.
---
 gix-tix/spec.md   |  16 ++-
 gix-tix/src/ui.rs | 334 +++++++++++++++++++++++++++++++++++++---------
 2 files changed, 281 insertions(+), 69 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 2113a223a42..7ccae18c23c 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -195,8 +195,8 @@ without trading responsiveness for metadata that is not visible.
 - At startup, the current worktree's `@` row becomes selected as soon as it is
   loaded, unless the user navigates first. Once the viewport is known, the row
   is centered with normal history-boundary clamping so surrounding commits are
-  visible. If it has visible descendants, its unselected non-whitespace content
-  is underlined and `@` is bold; a selected row keeps only bold `@`.
+  visible. While the row is unselected, its title is shown in reverse video and
+  `@` is bold; a selected row keeps only bold `@`.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. The current worktree's
   symbolic branch is displayed as `@short-name` in the local-reference color.
@@ -406,11 +406,13 @@ keeps every prefix compact. Opening one reverses its label and shows its availab
 items in a reversed, single-row popout immediately above and connected to that
 label; the `?` popout also contains its pane-switching and navigation hints through
 `<enter> diff`. The popout has horizontal padding, shifts left or clips at the
-terminal edge without wrapping, and is omitted when its label or the row above the
-footer is not visible. It does not reserve a history row and may cover history,
-panes, or notices beneath it. Closing behavior and shortcut availability are
-unchanged, and direct status actions and quit remain in the footer. The history
-status starts with the history position, then the
+terminal edge without wrapping, and is omitted when its label, the row above the
+footer, or space needed to preserve a protected message is not visible. It does
+not reserve a history row and may cover history,
+but message and changes panes, their status lines, and transient notices shift
+upward to reserve its line and are never occluded. Closing behavior and shortcut
+availability are unchanged, and direct status actions and quit remain in the
+footer. The history status starts with the history position, then the
 `v`, `c`, and `a` prefixes when they are addressable. Remaining history-level
 actions end at the information prefix while it is closed. An available direct
 time-travel action follows the shortcut groups, and duplicate cycling follows it when
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 93fb5de19a5..bb6ee08a98d 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -334,7 +334,7 @@ pub(crate) fn draw_with_worktree(
         app.changes_visible() && app.changes_mode == Some(ChangesMode::Both) && worktree_changes.is_some();
     let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
     let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
-    let commit_pane = app.show_commit.then(|| {
+    let mut commit_pane = app.show_commit.then(|| {
         let width = COMMIT_PANE_WIDTH.min(full_body.width / 2);
         let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
         body.width = body.width.min(commits.width);
@@ -350,7 +350,7 @@ pub(crate) fn draw_with_worktree(
             .saturating_add(u16::from(index_separator(pane, changes).is_some()))
             .saturating_add(2)
     };
-    let (changes_layout, changes_panes, _) = changes_pane_areas(
+    let (changes_layout, mut changes_panes, _) = changes_pane_areas(
         body,
         frame.area().height / 2,
         tree_shown.then(|| {
@@ -382,16 +382,14 @@ pub(crate) fn draw_with_worktree(
         },
         |pane| pane.outer.y,
     );
-    let notice_area = notice
+    let mut notice_area = notice
         .as_ref()
         .and_then(|notice| notice_area(notice, notice_horizontal, body.y, notice_bottom));
     if let Some(notice_area) = notice_area {
         body.height = notice_area.y.saturating_sub(body.y);
     }
-    let worktree_dirty = worktree_changes.is_some_and(|changes| !changes.paths.is_empty())
-        && changes_panes
-            .iter()
-            .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0);
+    let history_changes_panes = changes_panes.clone();
+    let history_notice_area = notice_area;
     if let Some(changes) = worktree_changes {
         app.set_worktree_conflicted(changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
     }
@@ -447,6 +445,36 @@ pub(crate) fn draw_with_worktree(
                     && !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
             }),
     );
+    let mut prefix_popup_allowed = active_prefix_popup_anchor(app, decorations)
+        .is_some_and(|anchor| prefix_popup_can_render(frame.area(), footer, anchor));
+    if prefix_popup_allowed {
+        let popup_y = footer.y - 1;
+        let shifted_y = |area: Rect| area.y.saturating_sub(1).max(full_body.y);
+        prefix_popup_allowed = changes_panes.iter().all(|pane| popup_y > shifted_y(pane.outer))
+            && commit_pane.as_ref().is_none_or(|(outer, _)| popup_y > outer.y)
+            && notice_area.is_none_or(|area| popup_y.saturating_sub(shifted_y(area)) >= area.height);
+        if prefix_popup_allowed {
+            for pane in &mut changes_panes {
+                pane.outer.y = shifted_y(pane.outer);
+                pane.outer.height = pane.outer.height.min(popup_y.saturating_sub(pane.outer.y));
+            }
+            if let Some(area) = notice_area.as_mut() {
+                area.y = shifted_y(*area);
+                area.height = area.height.min(popup_y.saturating_sub(area.y));
+            }
+            if let Some((outer, content)) = commit_pane.as_mut() {
+                outer.height = outer.height.min(popup_y.saturating_sub(outer.y));
+                *content = outer.inner(Margin {
+                    horizontal: 2,
+                    vertical: 1,
+                });
+            }
+        }
+    }
+    let worktree_dirty = worktree_changes.is_some_and(|changes| !changes.paths.is_empty())
+        && changes_panes
+            .iter()
+            .any(|pane| pane.pane == ChangePane::Worktree && pane.outer.height > 0);
     if app.changes_visible() {
         app.set_changes_layout(
             changes_layout,
@@ -460,10 +488,10 @@ pub(crate) fn draw_with_worktree(
                 && worktree_changes.is_some_and(Changes::is_visible),
         );
     }
-    app.viewport_rows = changes_panes
+    app.viewport_rows = history_changes_panes
         .iter()
         .map(|pane| pane.outer.y.saturating_sub(body.y))
-        .chain(notice_area.map(|area| area.y.saturating_sub(body.y)))
+        .chain(history_notice_area.map(|area| area.y.saturating_sub(body.y)))
         .min()
         .unwrap_or(body.height)
         .max(1) as usize;
@@ -551,7 +579,7 @@ pub(crate) fn draw_with_worktree(
                 || app.title(row),
                 |note| gix::objs::commit::MessageRef::from_bytes(note).title,
             );
-            metadata_columns(
+            let mut metadata = metadata_columns(
                 row,
                 title,
                 app.attributions(row),
@@ -571,7 +599,19 @@ pub(crate) fn draw_with_worktree(
                     selected: (row_selected && app.show_selection_tail) || compared_parent == Some(row.id),
                     copy_feedback: if row_selected { copy_feedback } else { None },
                 },
-            )
+            );
+            if !row_selected
+                && decorations.get(&row.id).is_some_and(|decorations| {
+                    decorations
+                        .iter()
+                        .any(|decoration| decoration.kind == DecorationKind::Head)
+                })
+            {
+                for span in &mut metadata.fields[5].spans {
+                    span.style = span.style.add_modifier(Modifier::REVERSED);
+                }
+            }
+            metadata
         })
         .collect();
     let title_column = lanes
@@ -648,7 +688,6 @@ pub(crate) fn draw_with_worktree(
                 .any(|decoration| decoration.kind == DecorationKind::CurrentWorktreeBranch)
         });
         let head_has_descendants = app.worktree_head_has_descendants(visible_rows[index].id);
-        let underline = head_has_descendants && !selected;
         let head_state = head.then_some(HeadState {
             has_descendants: head_has_descendants,
             attached: attached_head,
@@ -786,14 +825,6 @@ pub(crate) fn draw_with_worktree(
             }
             buffer[(marker_x, y)].set_symbol(" ").set_style(style);
         }
-        if underline {
-            for x in body.x..body.right() {
-                let cell = &mut frame.buffer_mut()[(x, y)];
-                if !cell.symbol().chars().all(char::is_whitespace) {
-                    cell.modifier.insert(Modifier::UNDERLINED);
-                }
-            }
-        }
         if !app.is_row_reachable(start + index) {
             for x in body.x..body.right() {
                 frame.buffer_mut()[(x, y)].set_style(Style::default().add_modifier(Modifier::DIM));
@@ -954,35 +985,7 @@ pub(crate) fn draw_with_worktree(
     let mut actions_prefix_spans = Vec::new();
     let mut actions_popup = None;
     if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
-        let head_visible = decorations
-            .values()
-            .flatten()
-            .any(|decoration| decoration.kind == DecorationKind::Head);
-        time_travel = if app.time_travel_shortcut_visible()
-            && head_visible
-            && let Some(selected) = app.selected.and_then(|index| app.rows.get(index))
-        {
-            let selected_refs = decorations.get(&selected.id).map(Vec::as_slice).unwrap_or_default();
-            if !selected_refs
-                .iter()
-                .any(|decoration| decoration.kind == DecorationKind::Head)
-            {
-                Some(
-                    if selected_refs
-                        .iter()
-                        .any(|decoration| decoration.kind == DecorationKind::Pin)
-                    {
-                        "@ return"
-                    } else {
-                        "@ travel"
-                    },
-                )
-            } else {
-                None
-            }
-        } else {
-            None
-        };
+        time_travel = time_travel_label(app, decorations);
         if app.commit_expanded {
             let mut options = Vec::new();
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
@@ -1264,7 +1267,9 @@ pub(crate) fn draw_with_worktree(
     if let (Some(area), Some(notice)) = (notice_area, notice.as_ref()) {
         render_notice(frame, area, notice);
     }
-    let prefix_popup_area = prefix_popup.and_then(|(anchor, items)| render_prefix_popup(frame, footer, anchor, items));
+    let prefix_popup_area = prefix_popup
+        .filter(|_| prefix_popup_allowed)
+        .and_then(|(anchor, items)| render_prefix_popup(frame, footer, anchor, items));
     FrameLayout {
         history: body,
         overlays: changes_panes
@@ -1288,6 +1293,77 @@ fn history_position(app: &App) -> String {
     }
 }
 
+fn time_travel_label(app: &App, decorations: &Decorations) -> Option<&'static str> {
+    if !app.time_travel_shortcut_visible()
+        || !decorations
+            .values()
+            .flatten()
+            .any(|decoration| decoration.kind == DecorationKind::Head)
+    {
+        return None;
+    }
+    let selected = app.selected.and_then(|index| app.rows.get(index))?;
+    let selected_refs = decorations.get(&selected.id).map(Vec::as_slice).unwrap_or_default();
+    if selected_refs
+        .iter()
+        .any(|decoration| decoration.kind == DecorationKind::Head)
+    {
+        None
+    } else if selected_refs
+        .iter()
+        .any(|decoration| decoration.kind == DecorationKind::Pin)
+    {
+        Some("@ return")
+    } else {
+        Some("@ travel")
+    }
+}
+
+fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<usize> {
+    let mut width = history_position(app).chars().count();
+    width += 3;
+    let view = width;
+    width += "view".len();
+    let mut active = app.history_display_expanded.then_some(view);
+
+    let commit_visible = app.changes_focus != Some(ChangePane::Worktree) || app.can_amend();
+    if commit_visible {
+        width += 3;
+        let commit = width;
+        width += "commit".len();
+        if app.commit_expanded {
+            active = Some(commit);
+        }
+    }
+    if app.changes_focus.is_none() {
+        width += 3;
+        let actions = width;
+        width += "actions".len();
+        if app.actions_expanded {
+            active = Some(actions);
+        }
+    }
+    width += 3;
+    let enrich = width;
+    width += "enrich".len();
+    if app.enrich_expanded {
+        active = Some(enrich);
+    }
+    if commit_visible && let Some(label) = time_travel_label(app, decorations) {
+        width += 3 + label.len();
+    }
+    if app.can_cycle_duplicate() {
+        width += 3 + "next duplicate".len();
+    }
+    width += 3 + "copy".len();
+    width += 3 + "refs".len();
+    width += 3;
+    if app.information_expanded {
+        active = Some(width);
+    }
+    active
+}
+
 fn render_changes_divider(frame: &mut Frame<'_>, panes: &[ChangesPaneArea], app: &App) {
     let Some(tree) = panes.iter().find(|pane| pane.pane == ChangePane::Tree) else {
         return;
@@ -2009,7 +2085,7 @@ fn render_prefix_popup(
     anchor: usize,
     mut items: Vec<Span<'static>>,
 ) -> Option<Rect> {
-    if footer.width == 0 || footer.y <= frame.area().y || anchor >= usize::from(footer.width) {
+    if !prefix_popup_can_render(frame.area(), footer, anchor) {
         return None;
     }
     items.insert(0, Span::raw(" "));
@@ -2025,6 +2101,10 @@ fn render_prefix_popup(
     Some(area)
 }
 
+fn prefix_popup_can_render(frame: Rect, footer: Rect, anchor: usize) -> bool {
+    footer.width > 0 && footer.y > frame.y && anchor < usize::from(footer.width)
+}
+
 fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
     let mut out = Vec::with_capacity(spans.len());
     for span in spans {
@@ -2879,6 +2959,31 @@ mod tests {
             "the ordinary footer remains visible"
         );
 
+        app.information_expanded = true;
+        let mut layout = None;
+        terminal.draw(|frame| {
+            layout = Some(super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                None,
+            ));
+        })?;
+        assert!(rendered_line(&terminal, 0).trim_start().starts_with("REBASE PAUSED"));
+        assert!(
+            rendered_line(&terminal, 1).contains("[ title"),
+            "the popup keeps its footer-adjacent row"
+        );
+        assert_eq!(
+            layout.expect("drawing returns its layout").history.height,
+            1,
+            "moving the notice leaves history geometry unchanged"
+        );
+        app.information_expanded = false;
+
         app.update(Action::MoveDown);
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
@@ -2904,6 +3009,34 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn an_offscreen_popup_does_not_move_a_notice() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.information_expanded = true;
+        app.leave_success("notice");
+        let mut terminal = Terminal::new(TestBackend::new(10, 3))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        assert!(rendered_line(&terminal, 1).contains("notice"));
+        assert!(!rendered_line(&terminal, 0).contains("notice"));
+        Ok(())
+    }
+
+    #[test]
+    fn a_popup_is_suppressed_when_a_notice_cannot_move() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.information_expanded = true;
+        app.leave_success("notice");
+        let mut terminal = Terminal::new(TestBackend::new(120, 2))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        assert!(rendered_line(&terminal, 0).contains("notice"));
+        assert!(!rendered_line(&terminal, 0).contains("[ title"));
+        Ok(())
+    }
+
     #[test]
     fn renders_selection_info_beside_the_right_marker_without_dimming_it() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(2);
@@ -4336,7 +4469,7 @@ mod tests {
     }
 
     #[test]
-    fn underlines_an_unselected_non_tip_head_and_bolds_its_marker() -> Result<(), Box<dyn std::error::Error>> {
+    fn reverses_only_an_unselected_head_title_and_bolds_a_non_tip_marker() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);
         let child = gix::ObjectId::Sha1([2; 20]);
         let commit = |id: gix::ObjectId, parent: Option<gix::ObjectId>| Commit {
@@ -4369,22 +4502,30 @@ mod tests {
 
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let head_row = 1;
-        for x in [2, 5, 20] {
+        let line = rendered_line(&terminal, head_row);
+        let title = line.find("subject").expect("the HEAD title is visible") as u16;
+        for x in title..title + "subject".len() as u16 {
             assert!(
                 terminal.backend().buffer()[(x, head_row)]
                     .modifier
-                    .contains(Modifier::UNDERLINED),
-                "each non-whitespace part of the unselected HEAD line is underlined"
+                    .contains(Modifier::REVERSED),
+                "the unselected HEAD title is reversed"
             );
         }
-        for x in [0, 1, 3, 11, 79] {
+        for x in [0, 2, 5, 12, 79] {
             assert!(
                 !terminal.backend().buffer()[(x, head_row)]
                     .modifier
-                    .contains(Modifier::UNDERLINED),
-                "whitespace on the HEAD line is not underlined"
+                    .contains(Modifier::REVERSED),
+                "HEAD emphasis does not invert the gutter or metadata"
             );
         }
+        assert!(
+            (0..80).all(|x| !terminal.backend().buffer()[(x, head_row)]
+                .modifier
+                .contains(Modifier::UNDERLINED)),
+            "the old HEAD underline is gone"
+        );
         assert!(
             terminal.backend().buffer()[(2, head_row)]
                 .modifier
@@ -4395,10 +4536,10 @@ mod tests {
         app.selected = Some(1);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
-            !terminal.backend().buffer()[(20, head_row)]
+            !terminal.backend().buffer()[(title, head_row)]
                 .modifier
-                .contains(Modifier::UNDERLINED),
-            "selection removes the warning underline"
+                .contains(Modifier::REVERSED),
+            "selection removes the HEAD title emphasis"
         );
         assert!(
             terminal.backend().buffer()[(2, head_row)]
@@ -4417,6 +4558,15 @@ mod tests {
         )]);
         app.selected = Some(1);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let tip_title = rendered_line(&terminal, 0)
+            .find("subject")
+            .expect("the tip title is visible") as u16;
+        assert!(
+            terminal.backend().buffer()[(tip_title, 0)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "an unselected tip HEAD title is reversed too"
+        );
         assert!(
             !terminal.backend().buffer()[(2, 0)].modifier.contains(Modifier::BOLD),
             "a tip @ keeps its normal weight"
@@ -4664,7 +4814,7 @@ mod tests {
             is_review: false,
             signature: SignatureState::Unsigned,
         }]);
-        let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
+        let mut terminal = Terminal::new(TestBackend::new(120, 7))?;
 
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
@@ -4813,6 +4963,24 @@ mod tests {
             "the main status keeps its original background"
         );
 
+        app.information_expanded = true;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                Some(message),
+                None,
+            );
+        })?;
+        assert!(
+            rendered_line(&terminal, 4).contains("PgUp/C-b up page · PgDn/C-f down page"),
+            "the popup moves the commit-message status up"
+        );
+        assert!(rendered_line(&terminal, 5).contains("[ title"));
+        app.information_expanded = false;
+
         app.update(Action::PageDown);
         app.update(Action::PageDown);
         terminal.draw(|frame| {
@@ -4848,6 +5016,48 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn popup_keeps_a_focused_changes_error_visible() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(1);
+        app.changes_focus = Some(ChangePane::Tree);
+        app.tree_changes.error = Some("failed deliberately".into());
+        app.information_expanded = true;
+        let changes = Changes {
+            paths: vec![crate::app::PathChange {
+                kind: ChangeKind::Modified,
+                group: ChangeGroup::Tree,
+                source: None,
+                path: "file".into(),
+                lines: None,
+            }],
+            ..Changes::default()
+        };
+        let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
+        let mut layout = None;
+
+        terminal.draw(|frame| {
+            layout = Some(super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+                None,
+            ));
+        })?;
+
+        assert!(rendered_line(&terminal, 3).contains("diff: failed deliberately"));
+        assert_eq!(terminal.backend().buffer()[(2, 3)].bg, PANE_STATUS_BACKGROUND);
+        assert!(rendered_line(&terminal, 4).contains("[ title"));
+        assert_eq!(
+            layout.expect("drawing returns its layout").history.height,
+            5,
+            "moving the changes pane leaves history geometry unchanged"
+        );
+        Ok(())
+    }
+
     #[test]
     fn changing_the_changes_height_keeps_history_alignment_stable() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(11);

From e3c9716c6fca6d0412d32c003b275656032cf4fa Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 08:08:17 +0200
Subject: [PATCH 233/282] feat: add copy-insert to tix
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Add copy-insert beside the renamed move-insert and stack-insert actions, using a dedicated copied plan step so the destination receives HEAD’s change without consuming the source occurrence or its resources.

Select the new copy as detached HEAD, retain source refs and notes, carry copy conflicts through the existing continuation flow, reject review-source duplication, and expose the actions as a c, a m, and a t.
---
 gix-tix/spec.md            |  25 ++-
 gix-tix/src/app.rs         | 177 +++++++++++++-------
 gix-tix/src/edit/rebase.rs | 331 ++++++++++++++++++++++++++++++++++---
 gix-tix/src/edit/todo.rs   |   6 +-
 gix-tix/src/lib.rs         |  56 +++++--
 gix-tix/src/ui.rs          |  32 ++--
 6 files changed, 506 insertions(+), 121 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 7ccae18c23c..bd19e80318d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1011,16 +1011,25 @@ space first; changes blocks adapt within the remaining history width.
   and `c d d` confirms forgetting a top commit when each action is available.
 - `a` toggles the actions shortcut group. `a b` rebases an eligible hidden base,
   `a u` rebases it onto the newer hidden branch tip when available, `a r` starts
-  or finishes a review, `a s` squashes the selected commit, `a m` cherry-moves
-  current `HEAD` directly above the selected commit, `a v` starts
-  cherry-move-stack for the linear ancestry from the selected commit through
-  `HEAD`, and `a f` establishes
+  or finishes a review, `a s` squashes the selected commit, `a c` copy-inserts
+  current `HEAD` above the selected commit, `a m` move-inserts it, `a t` starts
+  stack-insert for the linear ancestry from the selected commit through `HEAD`,
+  and `a f` establishes
   the remembered branch's forkpoint at detached `HEAD` when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
   forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
-- Cherry-move requires a non-root, single-parent `HEAD`. It removes `HEAD` from
+- Copy-insert requires a non-root, single-parent `HEAD` that is not an active
+  review commit. It inserts another occurrence of its change above the selected
+  target without removing the source occurrence, including when the target is
+  the source's current parent. The new copy becomes detached `HEAD`; an attached
+  source branch remains visible through the ordinary HEAD pin. If the target is
+  an ancestor of the source, that source occurrence is retained in its original
+  logical position while its branch follows the necessary rewrite. Git notes are
+  copied to the new occurrence. Copy-insert uses the history-todo conflict and
+  continuation rules.
+- Move-insert requires a non-root, single-parent `HEAD`. It removes `HEAD` from
   its old position, reconnects its former children to its parent, inserts its
   rewritten change above the selected target, and reparents every former direct
   child of the target above it. The target may be an ancestor, descendant, or in
@@ -1028,12 +1037,12 @@ space first; changes blocks adapt within the remaining history width.
   unchanged merge target is permitted, but any move that would rewrite a merge
   is unavailable. Mutable refs, pins, Git notes, enrichments, review resources,
   and attached or detached checkout state follow their rewritten commits.
-  Cherry-move uses the history-todo conflict and continuation rules.
-- Cherry-move-stack requires the selected commit to be an inclusive base in the linear
+  Move-insert uses the history-todo conflict and continuation rules.
+- Stack-insert requires the selected commit to be an inclusive base in the linear
   ancestry of `HEAD`. It then limits navigation to eligible insertion targets;
   `<enter>` moves the complete inclusive base-through-`HEAD` stack as a unit above the selected
   target, and Escape cancels. The stack follows the same eligibility, rewrite,
-  no-op, metadata, checkout, and conflict rules as a single cherry-move.
+  no-op, metadata, checkout, and conflict rules as move-insert.
 - `@` invokes time travel directly, outside both groups. Invoking it leaves an
   already expanded commit group open.
 - Commit and action shortcuts keep their respective group open. Navigation or
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7342f948721..5b1c2f54eb6 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -377,8 +377,9 @@ pub(crate) enum Action {
     Rebase,
     RebaseUpdate,
     Squash,
-    Move,
-    MoveStack,
+    CopyInsert,
+    MoveInsert,
+    StackInsert,
     Review,
     Forkpoint,
     TimeTravel,
@@ -421,10 +422,11 @@ pub(crate) enum Effect {
         source: ObjectId,
         target: ObjectId,
     },
-    Move {
+    Insert {
         source: ObjectId,
         base: ObjectId,
         target: ObjectId,
+        copy: bool,
     },
     StartReview {
         tip: ObjectId,
@@ -521,7 +523,7 @@ pub(crate) struct App {
     review_tip: Option<ObjectId>,
     review_return: Option<(ObjectId, ObjectId)>,
     squash_source: Option<ObjectId>,
-    move_stack_base: Option<ObjectId>,
+    stack_insert_base: Option<ObjectId>,
     reachable_rows: Option<Vec<bool>>,
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
@@ -623,7 +625,7 @@ impl App {
             review_tip: None,
             review_return: None,
             squash_source: None,
-            move_stack_base: None,
+            stack_insert_base: None,
             reachable_rows: None,
             copy_feedback: None,
             focus_feedback: None,
@@ -735,8 +737,8 @@ impl App {
             Some("review base · j/k select ancestor · <enter> start · Esc cancel")
         } else if self.squash_selection_active() {
             Some("squash target · j/k select ancestor · <enter> squash · Esc cancel")
-        } else if self.move_stack_base.is_some() {
-            Some("cherry-move-stack target · j/k select insertion point · <enter> move · Esc cancel")
+        } else if self.stack_insert_base.is_some() {
+            Some("stack-insert target · j/k select insertion point · <enter> insert · Esc cancel")
         } else if self.forget_confirmation_visible() {
             Some("forget commit · d again confirm · any other action cancel")
         } else {
@@ -1095,8 +1097,9 @@ impl App {
                 | Action::Rebase
                 | Action::RebaseUpdate
                 | Action::Squash
-                | Action::Move
-                | Action::MoveStack
+                | Action::CopyInsert
+                | Action::MoveInsert
+                | Action::StackInsert
                 | Action::Review
                 | Action::Forkpoint
         ) {
@@ -1348,9 +1351,9 @@ impl App {
                 self.clear_reachability_selection();
                 return vec![Effect::Squash { source, target }];
             }
-            Action::OpenDiff if self.move_stack_base.is_some() => {
-                let source = self.worktree_head.expect("cherry-stack selection requires HEAD");
-                let base = self.move_stack_base.expect("cherry-stack selection has a base");
+            Action::OpenDiff if self.stack_insert_base.is_some() => {
+                let source = self.worktree_head.expect("stack insertion requires HEAD");
+                let base = self.stack_insert_base.expect("stack insertion has a base");
                 let Some(target) = self
                     .selected
                     .filter(|index| self.is_row_reachable(*index) && self.reachable_row_selectable(*index))
@@ -1360,7 +1363,12 @@ impl App {
                     return Vec::new();
                 };
                 self.clear_reachability_selection();
-                return vec![Effect::Move { source, base, target }];
+                return vec![Effect::Insert {
+                    source,
+                    base,
+                    target,
+                    copy: false,
+                }];
             }
             Action::OpenDiff => {
                 if let Some(target) = self.selected_tree_diff_target() {
@@ -1451,25 +1459,35 @@ impl App {
                     return vec![Effect::Squash { source, target }];
                 }
             }
-            Action::Move if self.can_move() => {
-                let source = self.worktree_head.expect("move availability requires HEAD");
-                return vec![Effect::Move {
+            Action::CopyInsert if self.can_copy_insert() => {
+                let source = self.worktree_head.expect("copy-insert availability requires HEAD");
+                return vec![Effect::Insert {
+                    source,
+                    base: source,
+                    target: self.rows[self.selected.expect("copy-insert requires a selection")].id,
+                    copy: true,
+                }];
+            }
+            Action::MoveInsert if self.can_move_insert() => {
+                let source = self.worktree_head.expect("move-insert availability requires HEAD");
+                return vec![Effect::Insert {
                     source,
                     base: source,
-                    target: self.rows[self.selected.expect("move requires a selection")].id,
+                    target: self.rows[self.selected.expect("move-insert requires a selection")].id,
+                    copy: false,
                 }];
             }
-            Action::MoveStack => {
-                if let Some((source, base, base_parent, stack)) = self.cherry_stack() {
+            Action::StackInsert => {
+                if let Some((source, base, base_parent, stack)) = self.stack_insert() {
                     let reachable: Vec<_> = self
                         .rows
                         .iter()
                         .enumerate()
-                        .map(|(index, row)| self.is_cherry_stack_target(index, row.id, base, base_parent, &stack))
+                        .map(|(index, row)| self.is_stack_insert_target(index, row.id, base, base_parent, &stack))
                         .collect();
                     if reachable.iter().any(|reachable| *reachable) {
-                        debug_assert_eq!(source, self.worktree_head.expect("a cherry-stack has HEAD"));
-                        self.move_stack_base = Some(base);
+                        debug_assert_eq!(source, self.worktree_head.expect("a stack insertion has HEAD"));
+                        self.stack_insert_base = Some(base);
                         self.reachable_rows = Some(reachable);
                     }
                 }
@@ -1554,7 +1572,7 @@ impl App {
                 if self.review_tip.is_some()
                     || self.review_return.is_some()
                     || self.squash_source.is_some()
-                    || self.move_stack_base.is_some() =>
+                    || self.stack_insert_base.is_some() =>
             {
                 self.clear_reachability_selection();
             }
@@ -1724,7 +1742,7 @@ impl App {
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
         self.forget_confirmation = None;
-        if self.move_stack_base.is_some() {
+        if self.stack_insert_base.is_some() {
             self.clear_reachability_selection();
         }
         drop(self.store_commits(commits));
@@ -1931,7 +1949,7 @@ impl App {
         self.review_tip = None;
         self.review_return = None;
         self.squash_source = None;
-        self.move_stack_base = None;
+        self.stack_insert_base = None;
         self.reachability_anchor = None;
         self.reachable_rows = None;
     }
@@ -2233,7 +2251,15 @@ impl App {
                 })
     }
 
-    pub(crate) fn can_move(&self) -> bool {
+    pub(crate) fn can_copy_insert(&self) -> bool {
+        self.can_insert(true)
+    }
+
+    pub(crate) fn can_move_insert(&self) -> bool {
+        self.can_insert(false)
+    }
+
+    fn can_insert(&self, copy: bool) -> bool {
         if self.state != State::Complete
             || self.changes_focus.is_some()
             || self.deferred_history_state.unwrap_or(self.state) != State::Complete
@@ -2254,22 +2280,23 @@ impl App {
         };
         source.parent_ids.len() == 1
             && source.id != target.id
-            && source.parent_ids.first().copied() != Some(target.id)
+            && (copy || source.parent_ids.first().copied() != Some(target.id))
+            && (!copy || !source.is_review)
             && !self.is_row_hidden(target_index)
-            && !self.known_merge_descendants.contains(&source.id)
+            && (copy || !self.known_merge_descendants.contains(&source.id))
             && !self.known_merge_descendants.contains(&target.id)
     }
 
-    pub(crate) fn can_cherry_stack(&self) -> bool {
-        self.cherry_stack().is_some_and(|(_, base, base_parent, stack)| {
+    pub(crate) fn can_stack_insert(&self) -> bool {
+        self.stack_insert().is_some_and(|(_, base, base_parent, stack)| {
             self.rows
                 .iter()
                 .enumerate()
-                .any(|(index, row)| self.is_cherry_stack_target(index, row.id, base, base_parent, &stack))
+                .any(|(index, row)| self.is_stack_insert_target(index, row.id, base, base_parent, &stack))
         })
     }
 
-    fn cherry_stack(&self) -> Option<(ObjectId, ObjectId, ObjectId, HashSet<ObjectId>)> {
+    fn stack_insert(&self) -> Option<(ObjectId, ObjectId, ObjectId, HashSet<ObjectId>)> {
         if self.state != State::Complete
             || self.changes_focus.is_some()
             || self.deferred_history_state.unwrap_or(self.state) != State::Complete
@@ -2299,7 +2326,7 @@ impl App {
         }
     }
 
-    fn is_cherry_stack_target(
+    fn is_stack_insert_target(
         &self,
         index: usize,
         id: ObjectId,
@@ -3933,7 +3960,7 @@ mod tests {
     }
 
     #[test]
-    fn move_uses_current_head_and_the_selected_target() {
+    fn single_commit_inserts_use_current_head_and_the_selected_target() {
         let mut app = App::new(10);
         app.extend_commits(vec![
             row_with_parents(5, &[4]),
@@ -3946,21 +3973,55 @@ mod tests {
         complete(&mut app);
         app.selected = app.rows.iter().position(|row| row.id == id(3));
 
-        assert!(app.can_move());
+        assert!(app.can_copy_insert());
+        assert!(app.can_move_insert());
         assert_eq!(
-            app.update(Action::Move),
-            vec![Effect::Move {
+            app.update(Action::CopyInsert),
+            vec![Effect::Insert {
                 source: id(5),
                 base: id(5),
                 target: id(3),
+                copy: true,
+            }]
+        );
+        assert_eq!(
+            app.update(Action::MoveInsert),
+            vec![Effect::Insert {
+                source: id(5),
+                base: id(5),
+                target: id(3),
+                copy: false,
             }]
         );
 
         app.selected = app.rows.iter().position(|row| row.id == id(4));
-        assert!(!app.can_move(), "the current parent is already directly below HEAD");
+        assert!(
+            app.can_copy_insert(),
+            "copying directly above the current parent adds another occurrence"
+        );
+        assert!(
+            !app.can_move_insert(),
+            "the current parent is already directly below HEAD"
+        );
         app.set_known_merge_descendants(HashSet::from([id(3)]));
         app.selected = app.rows.iter().position(|row| row.id == id(3));
-        assert!(!app.can_move(), "a target with an affected merge is rejected");
+        assert!(!app.can_move_insert(), "a target with an affected merge is rejected");
+
+        let mut review_head = row_with_parents(5, &[4]);
+        review_head.is_review = true;
+        let mut review_app = App::new(5);
+        review_app.extend_commits(vec![
+            review_head,
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        review_app.set_worktree_head(Some(id(5)), false);
+        complete(&mut review_app);
+        review_app.selected = review_app.rows.iter().position(|row| row.id == id(3));
+        assert!(!review_app.can_copy_insert(), "review commits cannot be duplicated");
+        assert!(review_app.can_move_insert(), "review commits can still be moved");
 
         let mut merge_target = App::new(10);
         merge_target.extend_commits(vec![
@@ -3973,11 +4034,11 @@ mod tests {
         merge_target.set_worktree_head(Some(id(5)), false);
         complete(&mut merge_target);
         merge_target.selected = merge_target.rows.iter().position(|row| row.id == id(3));
-        assert!(merge_target.can_move(), "an unchanged merge target is allowed");
+        assert!(merge_target.can_move_insert(), "an unchanged merge target is allowed");
     }
 
     #[test]
-    fn cherry_stack_selects_only_valid_insertion_targets() {
+    fn stack_insert_selects_only_valid_insertion_targets() {
         let mut app = App::new(10);
         app.extend_commits(vec![
             row_with_parents(7, &[6]),
@@ -3993,11 +4054,11 @@ mod tests {
         complete(&mut app);
         app.select_commit(id(3));
 
-        assert!(app.can_cherry_stack());
-        assert!(app.update(Action::MoveStack).is_empty());
+        assert!(app.can_stack_insert());
+        assert!(app.update(Action::StackInsert).is_empty());
         assert_eq!(
             app.notice().map(|notice| notice.text),
-            Some("cherry-move-stack target · j/k select insertion point · <enter> move · Esc cancel".into())
+            Some("stack-insert target · j/k select insertion point · <enter> insert · Esc cancel".into())
         );
         for (n, reachable) in [
             (7, true),
@@ -4020,15 +4081,16 @@ mod tests {
         assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(1)));
         assert_eq!(
             app.update(Action::OpenDiff),
-            vec![Effect::Move {
+            vec![Effect::Insert {
                 source: id(5),
                 base: id(3),
                 target: id(1),
+                copy: false,
             }]
         );
 
         app.select_commit(id(3));
-        app.update(Action::MoveStack);
+        app.update(Action::StackInsert);
         app.update(Action::Cancel);
         assert!(app.notice().is_none(), "Escape cancels insertion-target selection");
         assert!(
@@ -4040,7 +4102,7 @@ mod tests {
     }
 
     #[test]
-    fn cherry_stack_requires_a_linear_head_ancestry() {
+    fn stack_insert_requires_a_linear_head_ancestry() {
         let mut app = App::new(10);
         app.extend_commits(vec![
             row_with_parents(5, &[4]),
@@ -4053,13 +4115,13 @@ mod tests {
         complete(&mut app);
         app.select_commit(id(3));
 
-        assert!(!app.can_cherry_stack());
-        assert!(app.update(Action::MoveStack).is_empty());
+        assert!(!app.can_stack_insert());
+        assert!(app.update(Action::StackInsert).is_empty());
         assert!(app.notice().is_none());
     }
 
     #[test]
-    fn cherry_stack_hides_targets_that_would_cycle_through_an_internal_commit() {
+    fn stack_insert_hides_targets_that_would_cycle_through_an_internal_commit() {
         let mut app = App::new(10);
         app.extend_commits(vec![
             row_with_parents(8, &[4]),
@@ -4075,7 +4137,7 @@ mod tests {
         complete(&mut app);
         app.select_commit(id(3));
 
-        assert!(app.update(Action::MoveStack).is_empty());
+        assert!(app.update(Action::StackInsert).is_empty());
         for (commit, expected) in [(8, false), (7, true), (6, true)] {
             let index = app
                 .rows
@@ -4091,7 +4153,7 @@ mod tests {
     }
 
     #[test]
-    fn refresh_cancels_cherry_stack_selection_before_rows_change() {
+    fn refresh_cancels_stack_insert_selection_before_rows_change() {
         let mut app = App::new(10);
         app.extend_commits(vec![
             row_with_parents(5, &[4]),
@@ -4103,14 +4165,14 @@ mod tests {
         app.set_worktree_head(Some(id(5)), false);
         complete(&mut app);
         app.select_commit(id(3));
-        app.update(Action::MoveStack);
-        assert!(app.move_stack_base.is_some(), "target selection is active");
+        app.update(Action::StackInsert);
+        assert!(app.stack_insert_base.is_some(), "target selection is active");
 
         let rows = app
             .start_refresh(vec![row_with_parents(6, &[5])].into(), &[id(6)], &[], false)
             .expect("the changed history starts lane computation");
         assert!(
-            app.move_stack_base.is_none(),
+            app.stack_insert_base.is_none(),
             "refresh cancels the index-based selection"
         );
         assert!(
@@ -4591,8 +4653,9 @@ mod tests {
         app.update(Action::RebaseUpdate);
         app.update(Action::Review);
         app.update(Action::Squash);
-        app.update(Action::Move);
-        app.update(Action::MoveStack);
+        app.update(Action::CopyInsert);
+        app.update(Action::MoveInsert);
+        app.update(Action::StackInsert);
         assert!(app.actions_expanded, "grouped actions keep the group open");
         app.update(Action::ToggleActions);
         assert!(!app.actions_expanded, "the prefix key toggles the group");
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index b80f18cebad..d951d4c0db1 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -76,6 +76,7 @@ pub(crate) enum PlanParent {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum PlanCommit {
     Pick(ObjectId),
+    Copy(ObjectId),
     Resolved(ObjectId),
     Empty(BString),
 }
@@ -530,16 +531,110 @@ pub(crate) fn squash_plan(
     })
 }
 
-pub(crate) fn cherry_move_plan(
+pub(crate) fn copy_insert_plan(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     source: ObjectId,
     target: ObjectId,
 ) -> Result<Plan> {
-    cherry_stack_plan(repo, graph, source, source, target)
+    if repo.head_id()?.detach() != source {
+        anyhow::bail!("the copy source must be the current HEAD");
+    }
+    let source_parents = graph
+        .parents_of(source)
+        .context("the copy source is not in the loaded history")?;
+    let [_source_parent] = source_parents.as_slice() else {
+        anyhow::bail!("copying a commit requires it to have exactly one parent");
+    };
+    let source_commit = repo
+        .find_commit(source)
+        .context("could not find the copy source")?
+        .decode()
+        .context("could not decode the copy source")?
+        .into_owned()
+        .context("could not own the copy source")?;
+    if super::review::reference(&source_commit)?.is_some() {
+        anyhow::bail!("review commits cannot be copied");
+    }
+    if source == target {
+        anyhow::bail!("the copy source and target must differ");
+    }
+
+    let mut scope = graph
+        .descendants_in_parent_order(target)
+        .context("the copy target is not in the loaded history")?;
+    scope.retain(|id| *id != target);
+    let mut steps = vec![PlanStep {
+        parent: PlanParent::Existing(target),
+        commit: PlanCommit::Copy(source),
+        squash: Vec::new(),
+    }];
+    let mut step_by_id = HashMap::with_capacity(scope.len());
+    for id in &scope {
+        let parents = graph.parents_of(*id).context("an affected copy commit is incomplete")?;
+        let [parent] = parents.as_slice() else {
+            anyhow::bail!("copying a commit cannot rewrite root or merge commits");
+        };
+        let parent = if *parent == target {
+            PlanParent::Step(0)
+        } else {
+            step_by_id
+                .get(parent)
+                .copied()
+                .map_or(PlanParent::Existing(*parent), PlanParent::Step)
+        };
+        step_by_id.insert(*id, steps.len());
+        steps.push(PlanStep {
+            parent,
+            commit: PlanCommit::Pick(*id),
+            squash: Vec::new(),
+        });
+    }
+
+    let mut ref_scope = Vec::with_capacity(scope.len() + 1);
+    ref_scope.push(target);
+    ref_scope.extend(scope.iter().copied());
+    let ref_scope_set: HashSet<_> = ref_scope.iter().copied().collect();
+    let mut non_leaves = HashSet::new();
+    for id in &ref_scope {
+        non_leaves.extend(
+            graph
+                .parents_of(*id)
+                .context("an affected copy commit is incomplete")?
+                .into_iter()
+                .filter(|parent| ref_scope_set.contains(parent)),
+        );
+    }
+    let tips: Vec<_> = ref_scope
+        .iter()
+        .copied()
+        .filter(|id| !non_leaves.contains(id))
+        .collect();
+    let expected_refs = capture_refs(repo, &ref_scope, &tips)?;
+    let checkout = Some(PlanCheckout {
+        target: PlanParent::Step(0),
+        reference: None,
+    });
+
+    Ok(Plan {
+        base: target,
+        scope,
+        steps,
+        checkout,
+        expected_refs,
+    })
+}
+
+pub(crate) fn move_insert_plan(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    source: ObjectId,
+    target: ObjectId,
+) -> Result<Plan> {
+    stack_insert_plan(repo, graph, source, source, target)
 }
 
-pub(crate) fn cherry_stack_plan(
+pub(crate) fn stack_insert_plan(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     base: ObjectId,
@@ -1154,9 +1249,14 @@ pub(crate) fn perform_plan_with_progress(
     let scope: HashSet<_> = plan.scope.iter().copied().collect();
     let mut picked = HashSet::new();
     for step in &plan.steps {
+        if let PlanCommit::Copy(id) = step.commit
+            && graph.parents_of(id).context("a copied commit is incomplete")?.len() != 1
+        {
+            anyhow::bail!("copying a commit requires it to have exactly one parent");
+        }
         let ids = match step.commit {
             PlanCommit::Pick(id) | PlanCommit::Resolved(id) => Some(id).into_iter().chain(step.squash.iter().copied()),
-            PlanCommit::Empty(_) => None.into_iter().chain(step.squash.iter().copied()),
+            PlanCommit::Copy(_) | PlanCommit::Empty(_) => None.into_iter().chain(step.squash.iter().copied()),
         };
         for id in ids {
             if !scope.contains(&id) || !picked.insert(id) {
@@ -1194,9 +1294,10 @@ pub(crate) fn perform_plan_with_progress(
             }
             PlanParent::Step(parent) => *produced.get(parent).context("a fork points to a later commit")?,
         };
-        let eager = conflict.is_none() && (eager.contains(&index) || !step.squash.is_empty());
+        let eager = conflict.is_none()
+            && (matches!(step.commit, PlanCommit::Copy(_)) || eager.contains(&index) || !step.squash.is_empty());
         let mut commit = match &step.commit {
-            PlanCommit::Pick(id) => repo
+            PlanCommit::Pick(id) | PlanCommit::Copy(id) => repo
                 .find_commit(*id)
                 .context("could not find a picked commit")?
                 .decode()
@@ -1236,7 +1337,7 @@ pub(crate) fn perform_plan_with_progress(
             },
         };
         let graph_parents = match step.commit {
-            PlanCommit::Pick(id) | PlanCommit::Resolved(id) => {
+            PlanCommit::Pick(id) | PlanCommit::Copy(id) | PlanCommit::Resolved(id) => {
                 graph.parents_of(id).context("a picked commit is incomplete")?
             }
             PlanCommit::Empty(_) => vec![parent],
@@ -1262,8 +1363,12 @@ pub(crate) fn perform_plan_with_progress(
         } else {
             Tree::LeaveAsIsAndMark
         };
-        let cherry_pick_started =
-            (eager && matches!(step.commit, PlanCommit::Pick(_) | PlanCommit::Resolved(_))).then(Instant::now);
+        let cherry_pick_started = (eager
+            && matches!(
+                step.commit,
+                PlanCommit::Pick(_) | PlanCommit::Copy(_) | PlanCommit::Resolved(_)
+            ))
+        .then(Instant::now);
         let mut step_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &replay_parents, &[parent], mode)? {
             TreeRewrite::Complete(tree) => tree,
@@ -1272,7 +1377,9 @@ pub(crate) fn perform_plan_with_progress(
                 merged,
                 conflicts,
             } => {
-                let (PlanCommit::Pick(original) | PlanCommit::Resolved(original)) = step.commit else {
+                let (PlanCommit::Pick(original) | PlanCommit::Copy(original) | PlanCommit::Resolved(original)) =
+                    step.commit
+                else {
                     unreachable!("empty commits cannot conflict")
                 };
                 step_conflict = Some((original, merged, conflicts, None));
@@ -1283,7 +1390,10 @@ pub(crate) fn perform_plan_with_progress(
             progress.cherry_picked += 1;
             progress.cherry_pick_time += started.elapsed();
         }
-        if matches!(step.commit, PlanCommit::Pick(_) | PlanCommit::Resolved(_)) {
+        if matches!(
+            step.commit,
+            PlanCommit::Pick(_) | PlanCommit::Copy(_) | PlanCommit::Resolved(_)
+        ) {
             progress.processed += 1;
             report(progress);
         }
@@ -1344,7 +1454,7 @@ pub(crate) fn perform_plan_with_progress(
             }
         };
         let predecessor = match step.commit {
-            PlanCommit::Pick(id) | PlanCommit::Resolved(id) => Some(id),
+            PlanCommit::Pick(id) | PlanCommit::Copy(id) | PlanCommit::Resolved(id) => Some(id),
             PlanCommit::Empty(_) => None,
         };
         let (new_id, signing_time) =
@@ -1362,6 +1472,10 @@ pub(crate) fn perform_plan_with_progress(
             if old_id != new_id {
                 note_rewrites.push((old_id, new_id));
             }
+        } else if let PlanCommit::Copy(old_id) = step.commit
+            && old_id != new_id
+        {
+            note_rewrites.push((old_id, new_id));
         }
         for old_id in step.squash.iter().take(applied_squash) {
             rewritten.insert(*old_id, Some(new_id));
@@ -3509,7 +3623,7 @@ mod tests {
     }
 
     #[test]
-    fn cherry_stack_moves_the_linear_range_and_reconnects_side_children() -> gix_testtools::Result {
+    fn stack_insert_moves_the_linear_range_and_reconnects_side_children() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         git(fixture.path(), &["checkout", "-q", "-b", "fork", "HEAD~1"])?;
         std::fs::write(fixture.path().join("fork"), b"fork\n")?;
@@ -3533,7 +3647,7 @@ mod tests {
         let target = repo.rev_parse_single("destination~1")?.detach();
         let target_child = repo.rev_parse_single("destination")?.detach();
 
-        let outcome = perform_plan(&repo, &graph, cherry_stack_plan(&repo, &graph, base, head, target)?)?.complete()?;
+        let outcome = perform_plan(&repo, &graph, stack_insert_plan(&repo, &graph, base, head, target)?)?.complete()?;
         let moved_base = outcome.map(base).context("the stack base is retained")?;
         let moved_head = outcome.map(head).context("HEAD is retained")?;
         let rewritten_fork = outcome.map(fork).context("the side child is retained")?;
@@ -3578,7 +3692,7 @@ mod tests {
     }
 
     #[test]
-    fn cherry_stack_rejects_invalid_ranges_and_cycles() -> gix_testtools::Result {
+    fn stack_insert_rejects_invalid_ranges_and_cycles() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         git(fixture.path(), &["checkout", "-q", "-b", "cycle-target"])?;
         std::fs::write(fixture.path().join("cycle-target"), b"cycle target\n")?;
@@ -3592,20 +3706,183 @@ mod tests {
         let base = repo.rev_parse_single("main~1")?.detach();
         let head = repo.head_id()?.detach();
         let target = repo.rev_parse_single("cycle-target")?.detach();
-        let err = cherry_stack_plan(&repo, &graph, target, head, root)
+        let err = stack_insert_plan(&repo, &graph, target, head, root)
             .expect_err("the selected base must be in HEAD's ancestry");
         assert!(err.to_string().contains("ancestor"), "{err:#}");
-        let err = cherry_stack_plan(&repo, &graph, base, head, base)
+        let err = stack_insert_plan(&repo, &graph, base, head, base)
             .expect_err("the insertion target cannot be part of the stack");
         assert!(err.to_string().contains("moved stack"), "{err:#}");
-        let err = cherry_stack_plan(&repo, &graph, base, head, target)
+        let err = stack_insert_plan(&repo, &graph, base, head, target)
             .expect_err("inserting a stack into its own side descendant would cycle");
         assert!(err.to_string().contains("cycle"), "{err:#}");
         Ok(())
     }
 
     #[test]
-    fn cherry_move_inserts_head_before_every_target_child_and_keeps_its_refs() -> gix_testtools::Result {
+    fn copy_insert_preserves_the_source_and_inserts_above_target_children() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let source = repo.head_id()?.detach();
+        drop(repo);
+
+        git(fixture.path(), &["checkout", "-q", "--orphan", "destination"])?;
+        git(fixture.path(), &["rm", "-q", "-r", "-f", "."])?;
+        std::fs::write(fixture.path().join("destination"), b"destination\n")?;
+        git(fixture.path(), &["add", "destination"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "destination"])?;
+        let target = open(fixture.path())?.head_id()?.detach();
+        std::fs::write(fixture.path().join("destination-child"), b"child\n")?;
+        git(fixture.path(), &["add", "destination-child"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "destination child"])?;
+        let target_child = open(fixture.path())?.head_id()?.detach();
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+
+        let repo = open(fixture.path())?;
+        set_git_note(&repo, source, b"source note")?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let outcome = perform_plan(&repo, &graph, copy_insert_plan(&repo, &graph, source, target)?)?.complete()?;
+        let rewritten_child = outcome.map(target_child).context("the target child is retained")?;
+        let copied = repo
+            .find_commit(rewritten_child)?
+            .parent_ids()
+            .next()
+            .map(gix::Id::detach)
+            .context("the rewritten target child has a parent")?;
+
+        assert_eq!(
+            repo.find_commit(copied)?.parent_ids().next().map(gix::Id::detach),
+            Some(target)
+        );
+        assert_eq!(outcome.selected, Some(copied), "copy-insert selects the new copy");
+        assert!(
+            outcome.checkout_reference.is_none(),
+            "copy-insert detaches instead of moving the source branch"
+        );
+        assert_eq!(outcome.map(source), Some(source), "copying does not rewrite the source");
+        assert_eq!(
+            repo.head_id()?.detach(),
+            source,
+            "copying elsewhere leaves HEAD at the source"
+        );
+        assert_eq!(repo.find_reference("refs/heads/main")?.id().detach(), source);
+        assert_eq!(
+            repo.find_reference("refs/heads/destination")?.id().detach(),
+            rewritten_child
+        );
+        assert_eq!(git_note(&repo, source)?.as_deref(), Some(b"source note".as_slice()));
+        assert_eq!(git_note(&repo, copied)?.as_deref(), Some(b"source note".as_slice()));
+        let repository_path = repo.git_dir().to_owned();
+        drop(repo);
+        super::super::time_travel::checkout_plan(&repository_path, false, &outcome, &[], false)?;
+        let repo = open(fixture.path())?;
+        assert!(
+            repo.head()?.is_detached(),
+            "the destination copy becomes the detached checkout"
+        );
+        assert_eq!(repo.head_id()?.detach(), copied);
+        assert_eq!(repo.find_reference("refs/heads/main")?.id().detach(), source);
+        let pins = crate::history::all_pins(&repo)?;
+        assert_eq!(pins.len(), 1, "the source branch stays visible through a HEAD pin");
+        assert_eq!(
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(b"refs/heads/main".as_bstr())
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn copy_insert_keeps_the_source_occurrence_above_its_current_parent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("HEAD~1")?.detach();
+        let source = repo.head_id()?.detach();
+
+        let outcome = perform_plan(&repo, &graph, copy_insert_plan(&repo, &graph, source, target)?)?.complete()?;
+        let copied = outcome
+            .selected
+            .context("copy-insert selects the inserted occurrence")?;
+        let retained_source = outcome.map(source).context("the source occurrence is retained")?;
+        assert_ne!(copied, retained_source, "copy and source remain separate occurrences");
+        assert_eq!(
+            repo.find_commit(copied)?.parent_ids().next().map(gix::Id::detach),
+            Some(target)
+        );
+        assert_eq!(
+            repo.find_reference("refs/heads/main")?.id().detach(),
+            retained_source,
+            "the source branch follows the ordinary source rewrite"
+        );
+        assert_eq!(
+            repo.find_commit(retained_source)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(copied),
+            "copying at the current parent creates two consecutive occurrences"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn copy_insert_rejects_review_sources() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let target = repo.rev_parse_single("HEAD~2")?.detach();
+        let old_source = repo.head_id()?.detach();
+        let mut source = repo.find_commit(old_source)?.decode()?.into_owned()?;
+        source
+            .extra_headers
+            .push(("tix-rebase".into(), "onto refs/worktree/tix/review/1".into()));
+        let source = repo.write_object(&source)?.detach();
+        repo.reference(
+            "refs/heads/main",
+            source,
+            PreviousValue::ExistingMustMatch(Target::Object(old_source)),
+            "prepare review source",
+        )?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let err = copy_insert_plan(&repo, &graph, source, target)
+            .expect_err("copying a review commit would duplicate its resource identity");
+        assert!(err.to_string().contains("review commits cannot be copied"), "{err:#}");
+        Ok(())
+    }
+
+    #[test]
+    fn a_conflicting_copy_insert_produces_a_materializable_continuation() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let target = repo.rev_parse_single("HEAD~2")?.detach();
+        let source = repo.head_id()?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+
+        let PlanPerform::Conflict(conflict) =
+            perform_plan(&repo, &graph, copy_insert_plan(&repo, &graph, source, target)?)?
+        else {
+            return Err("copying the tip delta onto the root should conflict".into());
+        };
+        assert_eq!(conflict.original(), source);
+        assert!(
+            conflict
+                .continuation_plan()
+                .steps
+                .iter()
+                .any(|step| matches!(step.commit, PlanCommit::Resolved(_))),
+            "the ordinary todo continuation can resume copy-insert"
+        );
+        drop(conflict);
+        assert_eq!(
+            gix_testtools::repository::snapshot(fixture.path())?,
+            before,
+            "an unmaterialized copy conflict leaves the repository unchanged"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn move_insert_places_head_before_every_target_child_and_keeps_its_refs() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         git(fixture.path(), &["checkout", "-q", "-b", "side", "HEAD~2"])?;
         std::fs::write(fixture.path().join("side"), b"side\n")?;
@@ -3621,7 +3898,7 @@ mod tests {
         let side = repo.rev_parse_single("side")?.detach();
         set_git_note(&repo, source, b"source note")?;
 
-        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?.complete()?;
+        let outcome = perform_plan(&repo, &graph, move_insert_plan(&repo, &graph, source, target)?)?.complete()?;
         let moved = outcome.map(source).context("HEAD is retained")?;
         let rewritten_middle = outcome.map(middle).context("the old source ancestry is retained")?;
         let rewritten_side = outcome.map(side).context("the target's side child is retained")?;
@@ -3648,7 +3925,7 @@ mod tests {
     }
 
     #[test]
-    fn cherry_move_can_cross_a_descendant_or_unrelated_history() -> gix_testtools::Result {
+    fn move_insert_can_cross_a_descendant_or_unrelated_history() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let middle = repo.rev_parse_single("main~1")?.detach();
@@ -3659,7 +3936,7 @@ mod tests {
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
         let base = repo.rev_parse_single("main~2")?.detach();
-        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, middle, tip)?)?.complete()?;
+        let outcome = perform_plan(&repo, &graph, move_insert_plan(&repo, &graph, middle, tip)?)?.complete()?;
         let moved = outcome.map(middle).context("detached HEAD is retained")?;
         let rewritten_tip = outcome.map(tip).context("the descendant target is retained")?;
         assert_eq!(
@@ -3693,7 +3970,7 @@ mod tests {
         let repo = open(fixture.path())?;
         let source = repo.head_id()?.detach();
         let graph = super::super::loaded_graph(&repo)?;
-        let outcome = perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?.complete()?;
+        let outcome = perform_plan(&repo, &graph, move_insert_plan(&repo, &graph, source, target)?)?.complete()?;
         let moved = outcome.map(source).context("HEAD is retained across histories")?;
         assert_eq!(
             repo.find_commit(moved)?.parent_ids().next().map(gix::Id::detach),
@@ -3705,7 +3982,7 @@ mod tests {
     }
 
     #[test]
-    fn a_conflicting_cherry_move_produces_a_materializable_continuation() -> gix_testtools::Result {
+    fn a_conflicting_move_insert_produces_a_materializable_continuation() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
@@ -3714,7 +3991,7 @@ mod tests {
         let before = gix_testtools::repository::snapshot(fixture.path())?;
 
         let PlanPerform::Conflict(conflict) =
-            perform_plan(&repo, &graph, cherry_move_plan(&repo, &graph, source, target)?)?
+            perform_plan(&repo, &graph, move_insert_plan(&repo, &graph, source, target)?)?
         else {
             return Err("moving the tip delta onto the root should conflict".into());
         };
@@ -3737,7 +4014,7 @@ mod tests {
     }
 
     #[test]
-    fn cherry_move_rejects_a_root_head() -> gix_testtools::Result {
+    fn move_insert_rejects_a_root_head() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let root = repo.rev_parse_single("main~2")?.detach();
@@ -3746,7 +4023,7 @@ mod tests {
         git(fixture.path(), &["checkout", "-q", "--detach", &root.to_string()])?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
-        let err = cherry_move_plan(&repo, &graph, root, target)
+        let err = move_insert_plan(&repo, &graph, root, target)
             .expect_err("root HEAD cannot be removed from its old position");
         assert!(err.to_string().contains("exactly one parent"), "{err:#}");
         Ok(())
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 8bd5b0142ed..b9d8c5c8b2b 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -291,7 +291,9 @@ pub(crate) fn prepare_continuation(
             let parent = match step.parent {
                 rebase::PlanParent::Existing(id) => id,
                 rebase::PlanParent::Step(parent) => match plan.steps[parent].commit {
-                    rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => id,
+                    rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Copy(id) | rebase::PlanCommit::Resolved(id) => {
+                        id
+                    }
                     rebase::PlanCommit::Empty(_) => {
                         anyhow::bail!("a continuation fork cannot target an unwritten empty commit")
                     }
@@ -322,7 +324,7 @@ pub(crate) fn prepare_continuation(
             ""
         };
         match step.commit {
-            rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Resolved(id) => {
+            rebase::PlanCommit::Pick(id) | rebase::PlanCommit::Copy(id) | rebase::PlanCommit::Resolved(id) => {
                 let value = if matches!(step.commit, rebase::PlanCommit::Resolved(_)) {
                     let hash = ObjectId::null(id.kind()).to_string();
                     if show_change_ids {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index eb81f810f2b..c537183a5d5 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2472,26 +2472,37 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("squash: {err:#}")),
                     }
                 }
-                Effect::Move { source, base, target } => {
+                Effect::Insert {
+                    source,
+                    base,
+                    target,
+                    copy,
+                } => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let result = (|| {
                         let graph = history_graph
                             .as_ref()
-                            .context("moving HEAD requires a completed history graph")?;
+                            .context("inserting commits requires a completed history graph")?;
                         let mut repository = open_repository(&repository_path, repository_is_bare, false)
-                            .context("could not open repository to move HEAD")?;
+                            .context("could not open repository to insert commits")?;
                         repository.object_cache_size(None);
-                        let plan = if base == source {
-                            edit::rebase::cherry_move_plan(&repository, graph, source, target)?
+                        let plan = if copy {
+                            edit::rebase::copy_insert_plan(&repository, graph, source, target)?
+                        } else if base == source {
+                            edit::rebase::move_insert_plan(&repository, graph, source, target)?
                         } else {
-                            edit::rebase::cherry_stack_plan(&repository, graph, base, source, target)?
+                            edit::rebase::stack_insert_plan(&repository, graph, base, source, target)?
                         };
                         run_rebase_plan(terminal, repository.into_sync(), graph, plan)
                     })();
                     match result {
                         Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
-                            let moved = outcome.map(source).unwrap_or(source);
+                            let inserted = if copy {
+                                outcome.selected.expect("copy-insert selects the copied commit")
+                            } else {
+                                outcome.map(source).unwrap_or(source)
+                            };
                             let notice = edit::time_travel::checkout_plan(
                                 &repository_path,
                                 repository_is_bare,
@@ -2501,11 +2512,24 @@ fn event_loop(
                             );
                             match notice {
                                 Ok(notice) => app.leave_success(notice.unwrap_or_else(|| {
-                                    format!("moved {} above {}", moved.to_hex_with_len(7), target.to_hex_with_len(7))
+                                    if copy {
+                                        format!(
+                                            "copied {} as {} above {}",
+                                            source.to_hex_with_len(7),
+                                            inserted.to_hex_with_len(7),
+                                            target.to_hex_with_len(7)
+                                        )
+                                    } else {
+                                        format!(
+                                            "inserted {} above {}",
+                                            inserted.to_hex_with_len(7),
+                                            target.to_hex_with_len(7)
+                                        )
+                                    }
                                 })),
-                                Err(err) => app.leave_attention(format!("move applied, checkout failed: {err:#}")),
+                                Err(err) => app.leave_attention(format!("insert applied, checkout failed: {err:#}")),
                             }
-                            app.select_commit_after_refresh(moved);
+                            app.select_commit_after_refresh(inserted);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
@@ -2522,7 +2546,7 @@ fn event_loop(
                             app.select_commit(id);
                             pending_todo_rebase_conflict = Some(conflict);
                         }
-                        Err(err) => app.leave_error(format!("move: {err:#}")),
+                        Err(err) => app.leave_error(format!("insert: {err:#}")),
                     }
                 }
                 Effect::StartReview { tip, base } => {
@@ -5209,8 +5233,9 @@ fn action_with_shortcut_groups(
         }
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
-        KeyCode::Char('m') if actions_expanded => Some(Action::Move),
-        KeyCode::Char('v') if actions_expanded => Some(Action::MoveStack),
+        KeyCode::Char('c') if actions_expanded => Some(Action::CopyInsert),
+        KeyCode::Char('m') if actions_expanded => Some(Action::MoveInsert),
+        KeyCode::Char('t') if actions_expanded => Some(Action::StackInsert),
         KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Forkpoint)
         }
@@ -6537,8 +6562,9 @@ mod tests {
             ('u', Action::RebaseUpdate),
             ('r', Action::Review),
             ('s', Action::Squash),
-            ('m', Action::Move),
-            ('v', Action::MoveStack),
+            ('c', Action::CopyInsert),
+            ('m', Action::MoveInsert),
+            ('t', Action::StackInsert),
             ('f', Action::Forkpoint),
         ] {
             assert_eq!(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index bb6ee08a98d..29893025cf6 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1064,8 +1064,11 @@ pub(crate) fn draw_with_worktree(
             if app.can_squash() {
                 options.push(("squash", 's'));
             }
-            if app.can_move() {
-                options.push(("cherry-move", 'm'));
+            if app.can_copy_insert() {
+                options.push(("copy-insert", 'c'));
+            }
+            if app.can_move_insert() {
+                options.push(("move-insert", 'm'));
             }
             let mut items = Vec::new();
             for (label, key) in options {
@@ -1074,12 +1077,12 @@ pub(crate) fn draw_with_worktree(
                 }
                 items.extend(shortcut(label, key, true));
             }
-            if app.can_cherry_stack() {
+            if app.can_stack_insert() {
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
-                items.push(Span::styled("v", Style::default().add_modifier(Modifier::UNDERLINED)));
-                items.push(Span::raw(" cherry-move-stack"));
+                items.push(Span::styled("t", Style::default().add_modifier(Modifier::UNDERLINED)));
+                items.push(Span::raw(" stack-insert"));
             }
             if app.can_forkpoint() {
                 if !items.is_empty() {
@@ -3965,11 +3968,12 @@ mod tests {
     }
 
     #[test]
-    fn actions_popup_shows_the_prefixed_cherry_stack_shortcut() -> Result<(), Box<dyn std::error::Error>> {
+    fn actions_popup_shows_insert_shortcuts_without_the_cherry_prefix() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);
         let base = gix::ObjectId::Sha1([2; 20]);
         let parent = gix::ObjectId::Sha1([3; 20]);
         let target = gix::ObjectId::Sha1([4; 20]);
+        let root = gix::ObjectId::Sha1([5; 20]);
         let commit = |id, parent: Option<gix::ObjectId>| Commit {
             id,
             parent_ids: parent.into_iter().collect(),
@@ -3983,24 +3987,28 @@ mod tests {
             is_review: false,
             signature: SignatureState::Unsigned,
         };
-        let mut app = App::new(4);
+        let mut app = App::new(5);
         app.set_worktree_head(Some(head), false);
         app.extend_commits(vec![
             commit(head, Some(base)),
             commit(base, Some(parent)),
-            commit(parent, None),
+            commit(parent, Some(root)),
+            commit(root, None),
             commit(target, None),
         ]);
         complete(&mut app);
-        app.selected = app.rows.iter().position(|row| row.id == base);
+        app.selected = app.rows.iter().position(|row| row.id == parent);
         app.actions_expanded = true;
         let mut terminal = Terminal::new(TestBackend::new(160, 5))?;
 
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let popup = rendered_line(&terminal, 3);
-        let label = "v cherry-move-stack";
-        let start = popup[..popup.find(label).expect("the cherry-move-stack action is visible")]
+        assert!(popup.contains("copy-insert"));
+        assert!(popup.contains("move-insert"));
+        assert!(!popup.contains("cherry-"));
+        let label = "t stack-insert";
+        let start = popup[..popup.find(label).expect("the stack-insert action is visible")]
             .chars()
             .count() as u16;
         assert!(
@@ -4012,7 +4020,7 @@ mod tests {
             (start + 1..start + label.len() as u16).all(|x| !terminal.backend().buffer()[(x, 3)]
                 .modifier
                 .contains(Modifier::UNDERLINED)),
-            "only the prefixed v is underlined"
+            "only the prefixed t is underlined"
         );
         Ok(())
     }

From c7f9d3f0d4a37a88bc1ee5132802cb40846df299 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 08:28:30 +0200
Subject: [PATCH 234/282] =?UTF-8?q?feat:=20show=20dirty=20HEAD=20with=20?=
 =?UTF-8?q?=F0=9F=AB=9F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Replace the ASCII dirty-worktree marker with the requested two-column glyph while preserving the existing status gutter, selection styling, and conflict-marker precedence.

Update the rendering regression and behavioral specification so deletion statistics continue to use D independently.
---
 gix-tix/spec.md   |  4 ++--
 gix-tix/src/ui.rs | 10 +++++-----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index bd19e80318d..8aaf7b6e24c 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -210,7 +210,7 @@ without trading responsiveness for metadata that is not visible.
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
 - The selected row uses `>` at the left. If the displayed worktree block is dirty,
-  `D` is shown at the `HEAD` row instead; a separately selected row retains `>`.
+  `🫟` is shown at the `HEAD` row instead; a separately selected row retains `>`.
 - Selection inversion covers the left marker, graph, commit marker, and hash.
   Its graph background is derived from the commit-marker color. The selected
   row's right-hand tail and contextual information always have blank margins and
@@ -751,7 +751,7 @@ space first; changes blocks adapt within the remaining history width.
   and refresh are blocked. Key-release events are not actions and leave it armed.
   Diagnostics warn when a conflict suspends the rebase and record whether it is
   accepted, discarded, or fails during checkout.
-- A checked-out unresolved index keeps `C` at `@`, overrides dirty `D`, and
+- A checked-out unresolved index keeps `C` at `@`, overrides dirty `🫟`, and
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
 - A materialized todo conflict keeps a high-contrast `REBASE PAUSED` attention notice until
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 29893025cf6..633e6673573 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -767,7 +767,7 @@ pub(crate) fn draw_with_worktree(
         }
         frame.render_widget(
             Paragraph::new(if head && worktree_dirty {
-                "D "
+                "🫟"
             } else if selected {
                 "> "
             } else {
@@ -4637,7 +4637,7 @@ mod tests {
                 Some(&dirty),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("D @"));
+        assert!(rendered_line(&terminal, 0).starts_with("🫟 @"));
         assert!(rendered_line(&terminal, 1).starts_with("> ●"));
         assert_eq!(terminal.backend().buffer()[(0, 0)].modifier, Modifier::empty());
         assert!(
@@ -4658,7 +4658,7 @@ mod tests {
                 Some(&dirty),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("D @"));
+        assert!(rendered_line(&terminal, 0).starts_with("🫟 @"));
         assert!(
             terminal.backend().buffer()[(0, 0)]
                 .modifier
@@ -4687,7 +4687,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("💥 D @"),
+            rendered_line(&terminal, 0).starts_with("💥 🫟 @"),
             "the conflict gutter precedes the ordinary status: {:?}",
             rendered_line(&terminal, 0)
         );
@@ -4711,7 +4711,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("D @"),
+            rendered_line(&terminal, 0).starts_with("🫟 @"),
             "resolving the index restores the ordinary dirty marker"
         );
 

From 0b8c64aab566976232b48dd1af54c5e5c672ce79 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 08:43:42 +0200
Subject: [PATCH 235/282] change!: replace tix forkpoint with attach and fork

Rename the ref-only forkpoint action to attach at a h. Restore a f as an independent commit fork that reuses new-commit preparation, preserves enrichments, pins the new leaf atomically, and travels to it without rewriting the source stack.
---
 gix-tix/spec.md                 |  26 ++++++--
 gix-tix/src/app.rs              |  56 ++++++++++++++---
 gix-tix/src/edit/create.rs      | 108 ++++++++++++++++++++++++++++++++
 gix-tix/src/edit/rebase.rs      |  50 ++++++++++-----
 gix-tix/src/edit/time_travel.rs |  95 ++++++++++++----------------
 gix-tix/src/lib.rs              |  85 ++++++++++++++++++++++---
 gix-tix/src/ui.rs               |  13 +++-
 7 files changed, 341 insertions(+), 92 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8aaf7b6e24c..97389a4ccbd 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -426,13 +426,13 @@ The Enter key is written as `<enter>` throughout.
 
 - On a completed, focused history in a worktree repository, `@` on a non-`HEAD`
   row runs `git checkout --detach <commit>` without forcing local changes.
-- `a f` is available while `HEAD` is detached with a valid symbolic HEAD pin.
+- `a h` is available while `HEAD` is detached with a valid symbolic HEAD pin.
   It atomically moves the remembered local branch to the current `HEAD` commit
   and attaches `HEAD` without changing the index or worktree. The symbolic HEAD
   pin remains and follows the moved branch. The branch's previous tip receives
   an ordinary pin only when no other normal view tip still reaches it; an
   ordinary destination pin is consumed normally.
-- Forkpoint refuses a remembered branch checked out by another worktree. It is
+- Attach refuses a remembered branch checked out by another worktree. It is
   unavailable during conflicts or incomplete history, but otherwise permits
   dirty index and worktree state because the operation changes only refs.
 - When tix detaches an attached local branch, it records that branch symbolically
@@ -441,7 +441,7 @@ The Enter key is written as `<enter>` throughout.
   Further detached travel preserves the singleton. After each successful tix
   checkout, landing on the remembered branch tip reattaches `HEAD` to that branch
   and removes the HEAD pin; explicitly attaching another branch also removes it.
-  Forkpoint is the exception: it deliberately retains the symbolic HEAD pin
+  Attach is the exception: it deliberately retains the symbolic HEAD pin
   after attaching its remembered branch.
   A failed automatic reattachment leaves both detached `HEAD` and the HEAD pin
   intact and reports a warning. External Git checkouts do not reconcile it.
@@ -681,6 +681,22 @@ space first; changes blocks adapt within the remaining history width.
   tags and remote-tracking refs. Checked-out affected worktrees are preflighted;
   inaccessible or conflicting affected worktrees abort safely.
 
+### Fork commits
+
+- `a f` creates an independent child of any selected commit, including a hidden
+  boundary or merge commit. It requires completed history and a live,
+  conflict-free worktree, but unlike `c n` it is not restricted by descendants
+  because it rewrites none of them. It is unavailable for unborn history.
+- Fork preparation reuses the new-commit editor, candidate-tree, identity,
+  enrichment, and signing rules. Empty-delta children are allowed so historical
+  commits can be forked without borrowing the current worktree's changes.
+- Saving writes only the new commit and a temporary direct
+  `refs/worktree/tix/pins/*` ref; existing refs, descendants, indexes, and
+  worktrees do not move during creation.
+- Tix immediately time-travels to the new fork. A successful checkout consumes
+  its temporary pin and reconciles the departed `HEAD` through the standard pin
+  primitive. If checkout fails, the fork remains pinned and visible.
+
 ### Amend, spill, and split
 
 - `c a` amends the current worktree's `@` commit with the changed index, or
@@ -1014,8 +1030,8 @@ space first; changes blocks adapt within the remaining history width.
   or finishes a review, `a s` squashes the selected commit, `a c` copy-inserts
   current `HEAD` above the selected commit, `a m` move-inserts it, `a t` starts
   stack-insert for the linear ancestry from the selected commit through `HEAD`,
-  and `a f` establishes
-  the remembered branch's forkpoint at detached `HEAD` when available.
+  `a f` creates and travels to a standalone child of the selected commit, and
+  `a h` attaches the remembered branch at detached `HEAD` when available.
 - Squash accepts any visible strict ancestor whose affected descendants contain no merges. With one eligible
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 5b1c2f54eb6..30521479efc 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -381,7 +381,8 @@ pub(crate) enum Action {
     MoveInsert,
     StackInsert,
     Review,
-    Forkpoint,
+    ForkCommit,
+    Attach,
     TimeTravel,
     TogglePin,
     VerifySignatures,
@@ -436,7 +437,8 @@ pub(crate) enum Effect {
         review: ObjectId,
         return_to: Option<ObjectId>,
     },
-    Forkpoint,
+    ForkCommit(ObjectId),
+    Attach,
     TimeTravel(ObjectId),
     TogglePin(ObjectId),
     ToggleTodo(ObjectId),
@@ -1101,7 +1103,8 @@ impl App {
                 | Action::MoveInsert
                 | Action::StackInsert
                 | Action::Review
-                | Action::Forkpoint
+                | Action::ForkCommit
+                | Action::Attach
         ) {
             self.actions_expanded = false;
         }
@@ -1516,7 +1519,12 @@ impl App {
                     return vec![Effect::StartReview { tip, base }];
                 }
             }
-            Action::Forkpoint if self.can_forkpoint() => return vec![Effect::Forkpoint],
+            Action::ForkCommit if self.can_fork_commit() => {
+                return vec![Effect::ForkCommit(
+                    self.rows[self.selected.expect("fork requires a selection")].id,
+                )];
+            }
+            Action::Attach if self.can_attach() => return vec![Effect::Attach],
             Action::TimeTravel if self.time_travel_shortcut_visible() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
@@ -2371,7 +2379,18 @@ impl App {
             })
     }
 
-    pub(crate) fn can_forkpoint(&self) -> bool {
+    pub(crate) fn can_fork_commit(&self) -> bool {
+        self.state == State::Complete
+            && self.worktree_changes_available
+            && !self.worktree_conflicted
+            && self.pending_rebase_conflict.is_none()
+            && self.changes_focus.is_none()
+            && self.deferred_history_state.unwrap_or(self.state) == State::Complete
+            && self.worktree_head.is_some()
+            && self.selected.and_then(|index| self.rows.get(index)).is_some()
+    }
+
+    pub(crate) fn can_attach(&self) -> bool {
         self.state == State::Complete
             && self.worktree_changes_available
             && !self.worktree_conflicted
@@ -3546,6 +3565,7 @@ mod tests {
     fn editing_rejects_merge_descendants_and_new_commits_support_unborn_head() {
         let mut app = App::new(10);
         app.extend_commits(vec![row(2)]);
+        app.set_worktree_head(Some(id(2)), false);
         complete(&mut app);
         app.set_known_descendants(HashSet::from([id(2)]));
         app.set_known_merge_descendants(HashSet::from([id(2)]));
@@ -3557,6 +3577,8 @@ mod tests {
             !app.can_create_commit(),
             "a merge descendant outside the visible projection prevents a child"
         );
+        assert!(app.can_fork_commit(), "a fork does not rewrite merge descendants");
+        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(2))]);
 
         let mut unborn = App::new(10);
         unborn.set_worktree_head_unborn(true);
@@ -3572,6 +3594,16 @@ mod tests {
                 empty: false,
             }]
         );
+        assert!(!unborn.can_fork_commit(), "a fork requires a selected parent");
+
+        let mut unborn_with_history = App::new(10);
+        unborn_with_history.set_worktree_head_unborn(true);
+        unborn_with_history.extend_commits(vec![row(1)]);
+        complete(&mut unborn_with_history);
+        assert!(
+            !unborn_with_history.can_fork_commit(),
+            "a fork requires an existing worktree HEAD even when another ref is selected"
+        );
     }
 
     #[test]
@@ -3628,11 +3660,11 @@ mod tests {
         assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
         app.set_worktree_branch(Some((id(1), true)));
         app.set_worktree_head(Some(id(1)), false);
-        assert!(app.can_forkpoint());
-        assert_eq!(app.update(Action::Forkpoint), vec![Effect::Forkpoint]);
+        assert!(app.can_attach());
+        assert_eq!(app.update(Action::Attach), vec![Effect::Attach]);
         app.set_worktree_changes_available(false);
         assert!(app.update(Action::TimeTravel).is_empty());
-        assert!(app.update(Action::Forkpoint).is_empty());
+        assert!(app.update(Action::Attach).is_empty());
         assert_eq!(app.update(Action::TogglePin), vec![Effect::TogglePin(id(1))]);
     }
 
@@ -3644,14 +3676,17 @@ mod tests {
         complete(&mut app);
         app.update(Action::MoveDown);
         assert!(app.time_travel_shortcut_visible());
+        assert!(app.can_fork_commit());
 
         app.set_worktree_conflicted(true);
         assert!(!app.time_travel_shortcut_visible());
+        assert!(!app.can_fork_commit());
         assert!(app.update(Action::TimeTravel).is_empty());
         app.set_worktree_conflicted(false);
         assert!(app.changes_visible(), "changes are normally shown while enabled");
         app.arm_rebase_conflict(id(1));
         assert!(!app.time_travel_shortcut_visible());
+        assert!(!app.can_fork_commit());
         assert!(
             !app.changes_visible(),
             "an in-memory conflict preview cannot be loaded by an on-disk changes view"
@@ -4300,6 +4335,7 @@ mod tests {
         let mut app = App::new(4);
         app.extend_commits(vec![row(1), row(2), row(3)]);
         app.extend_hidden_commits(vec![row(4)]);
+        app.set_worktree_head(Some(id(1)), false);
         complete(&mut app);
         Arc::make_mut(&mut app.rows[3]).signature = SignatureState::Unverified;
 
@@ -4309,6 +4345,8 @@ mod tests {
         assert_eq!(app.update(Action::Copy), vec![Effect::CopyId(id(4))]);
         assert!(!app.can_reword());
         assert!(!app.can_forget());
+        assert!(app.can_fork_commit());
+        assert_eq!(app.update(Action::ForkCommit), vec![Effect::ForkCommit(id(4))]);
         assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(4))]);
         assert!(
             app.update(Action::VerifySignatures).is_empty(),
@@ -4656,6 +4694,8 @@ mod tests {
         app.update(Action::CopyInsert);
         app.update(Action::MoveInsert);
         app.update(Action::StackInsert);
+        app.update(Action::ForkCommit);
+        app.update(Action::Attach);
         assert!(app.actions_expanded, "grouped actions keep the group open");
         app.update(Action::ToggleActions);
         assert!(!app.actions_expanded, "the prefix key toggles the group");
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 9bcf4870995..13f6250a8e8 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -336,6 +336,34 @@ fn apply_commit(
     Ok(outcome)
 }
 
+#[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
+pub(crate) fn apply_fork(
+    mut repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    mut prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    let repository_path = repo.git_dir().to_owned();
+    let bare = repo.is_bare();
+    repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
+    let parent = prepared.parent.context("a fork commit requires a parent")?;
+    let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
+    let id = rebase::perform(
+        &repo,
+        graph,
+        rebase::Edit::Fork { anchor: parent, commit },
+        rebase::Signature::RedoIfNeeded,
+        rebase::Tree::LeaveAsIs,
+    )?
+    .complete()?
+    .selected
+    .context("forking a commit did not produce a selection")?;
+    drop(repo);
+    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+        .context("the fork was created, but its enrichment could not be saved")?;
+    Ok(id)
+}
+
 pub(super) fn commit_from_edit(
     prepared: &Prepared,
     edited: &[u8],
@@ -540,6 +568,86 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn fork_creates_an_independent_pinned_child_then_time_travels_to_it() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        for args in [
+            ["reset", "--hard", "-q", "HEAD"].as_slice(),
+            ["clean", "-fdq"].as_slice(),
+            ["commit", "--allow-empty", "-q", "-m", "descendant"].as_slice(),
+        ] {
+            assert!(
+                Command::new("git")
+                    .arg("-C")
+                    .arg(fixture.path())
+                    .args(args)
+                    .status()?
+                    .success(),
+                "the fork fixture has a clean descendant"
+            );
+        }
+        let repository = open(fixture.path())?;
+        let main = repository.head_id()?.detach();
+        let parent = repository.rev_parse_single("HEAD~1")?.detach();
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let prepared = prepare(open(fixture.path())?, Some(parent))?;
+        let edited = prepared
+            .document
+            .replacen(b"what\n\nwhy", b"fork\n\nreason", 1)
+            .replacen(b";Todo\n;Message:", b"Todo\nMessage: fork enrichment", 1);
+        let graph = super::super::loaded_graph(&open(fixture.path())?)?;
+        let fork = apply_fork(open(fixture.path())?, &graph, prepared, &edited)?;
+
+        let repository = open(fixture.path())?;
+        assert_eq!(
+            crate::enrich::load(
+                &mut crate::enrich::open(&repository)?,
+                crate::change_id::for_commit(&repository, fork)?
+            )?,
+            crate::enrich::Enrichment {
+                todo: true,
+                note: Some("fork enrichment".into()),
+            }
+        );
+        assert_eq!(repository.head_id()?.detach(), main, "forking does not move HEAD");
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            main,
+            "forking does not move the source branch"
+        );
+        assert_eq!(
+            repository.find_commit(fork)?.parent_ids().next().map(gix::Id::detach),
+            Some(parent),
+            "the fork is a direct child of the selected commit"
+        );
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the new leaf is retained until checkout");
+        assert_eq!(pins[0].id, fork);
+        let after = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            after.index, before.index,
+            "creating the fork leaves the index untouched"
+        );
+        assert_eq!(after.index_tree, before.index_tree, "the index tree remains unchanged");
+        assert_eq!(
+            after.worktree, before.worktree,
+            "creating the fork leaves worktree files untouched"
+        );
+
+        let repository_path = repository.git_dir().to_owned();
+        let graph = super::super::loaded_graph(&repository)?;
+        drop(repository);
+        super::super::time_travel::perform(&repository_path, false, fork, &graph, &[], &[], false)?.complete()?;
+        let repository = open(fixture.path())?;
+        assert!(repository.head()?.is_detached(), "automatic fork travel detaches HEAD");
+        assert_eq!(repository.head_id()?.detach(), fork);
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the checkout consumes the temporary fork pin");
+        assert!(pins[0].is_head(), "the singleton remembers the departed branch");
+        assert_eq!(pins[0].id, main);
+        Ok(())
+    }
+
     #[test]
     fn creates_an_empty_root_commit_for_an_unborn_head() -> gix_testtools::Result {
         let fixture = gix_testtools::tempfile::tempdir()?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index d951d4c0db1..76c9d5d10dd 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -53,6 +53,10 @@ pub(crate) enum Edit {
         commit: gix::objs::Commit,
         reset_index: bool,
     },
+    Fork {
+        anchor: ObjectId,
+        commit: gix::objs::Commit,
+    },
     Remove {
         target: ObjectId,
     },
@@ -851,19 +855,29 @@ fn perform_inner(
         Edit::Repeat { checkout, .. } => Some(*checkout),
         _ => None,
     };
-    let (root, replacement, inserted, reset_index, removed, repeat, mut split_upper) = match edit {
-        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, None),
+    let (root, replacement, inserted, reset_index, forked, removed, repeat, mut split_upper) = match edit {
+        Edit::Replace { target, commit } => (Some(target), Some(commit), false, false, false, false, false, None),
         Edit::Insert {
             anchor,
             commit,
             reset_index,
-        } => (anchor, Some(commit), true, reset_index, false, false, None),
-        Edit::Remove { target } => (Some(target), None, false, false, true, false, None),
-        Edit::Split { target, source, upper } => (Some(target), Some(source), false, false, false, false, Some(upper)),
-        Edit::Repeat { base, .. } => (Some(base), None, false, false, false, true, None),
+        } => (anchor, Some(commit), true, reset_index, false, false, false, None),
+        Edit::Fork { anchor, commit } => (Some(anchor), Some(commit), false, false, true, false, false, None),
+        Edit::Remove { target } => (Some(target), None, false, false, false, true, false, None),
+        Edit::Split { target, source, upper } => (
+            Some(target),
+            Some(source),
+            false,
+            false,
+            false,
+            false,
+            false,
+            Some(upper),
+        ),
+        Edit::Repeat { base, .. } => (Some(base), None, false, false, false, false, true, None),
     };
 
-    let affected = match root {
+    let affected = match root.filter(|_| !forked) {
         Some(root) => graph
             .descendants_in_parent_order(root)
             .context("the edited commit is not in the loaded history")?,
@@ -886,7 +900,7 @@ fn perform_inner(
     let mut note_rewrites = Vec::new();
     let mut selected = None;
     let mut conflict = None;
-    if inserted {
+    if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
         let id = write_commit(
@@ -898,10 +912,12 @@ fn perform_inner(
             signing.clone(),
         )?;
         selected = Some(id);
-        if let Some(root) = root {
-            rewritten.insert(root, Some(id));
-        } else {
-            rewritten.insert(id, Some(id));
+        if inserted {
+            if let Some(root) = root {
+                rewritten.insert(root, Some(id));
+            } else {
+                rewritten.insert(id, Some(id));
+            }
         }
     } else if removed {
         let root = root.context("a removed commit is required")?;
@@ -1026,7 +1042,8 @@ fn perform_inner(
         }
     }
 
-    let marked = matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) || conflict.is_some();
+    let marked = (!forked && matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants))
+        || conflict.is_some();
     let checkout_after_finish = conflict.is_some();
     let mut prepared = Prepared {
         repo,
@@ -1034,6 +1051,7 @@ fn perform_inner(
         reset_index: if inserted { reset_index } else { marked },
         reset_index_paths,
         skip_worktree_transitions: inserted
+            || forked
             || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
         selected,
         note_rewrites,
@@ -1048,7 +1066,11 @@ fn perform_inner(
         expected_refs: None,
         checkout_reference: None,
         checkout_after_finish,
-        pins: Vec::new(),
+        pins: if forked {
+            selected.into_iter().collect()
+        } else {
+            Vec::new()
+        },
         delete_refs,
     };
     match conflict {
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index f5439959bbf..0336d318388 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -322,7 +322,7 @@ fn remembered_branch(repository: &gix::Repository) -> Result<RememberedBranch> {
     let pin = history::all_pins(repository)?
         .into_iter()
         .find(history::Pin::is_head)
-        .context("setting a forkpoint requires a valid HEAD pin")?;
+        .context("attaching requires a valid HEAD pin")?;
     let branch = pin
         .target
         .try_name()
@@ -337,57 +337,51 @@ fn remembered_branch(repository: &gix::Repository) -> Result<RememberedBranch> {
     })
 }
 
-fn validate_forkpoint(repository: &gix::Repository, head_id: ObjectId, remembered: &RememberedBranch) -> Result<()> {
-    let head = repository
-        .head()
-        .context("could not read HEAD before setting the forkpoint")?;
+fn validate_attach(repository: &gix::Repository, head_id: ObjectId, remembered: &RememberedBranch) -> Result<()> {
+    let head = repository.head().context("could not read HEAD before attaching")?;
     if !head.is_detached() || head.id().map(gix::Id::detach) != Some(head_id) {
-        anyhow::bail!("HEAD changed while preparing the forkpoint");
+        anyhow::bail!("HEAD changed while preparing to attach");
     }
     drop(head);
     let pin = history::all_pins(repository)?
         .into_iter()
         .find(history::Pin::is_head)
-        .context("the HEAD pin disappeared while preparing the forkpoint")?;
+        .context("the HEAD pin disappeared while preparing to attach")?;
     if pin.target.try_name() != Some(remembered.branch.as_ref()) || pin.id != remembered.branch_tip {
-        anyhow::bail!("the HEAD pin changed while preparing the forkpoint");
+        anyhow::bail!("the HEAD pin changed while preparing to attach");
     }
     let branch_id = repository
         .find_reference(remembered.branch.as_ref())
-        .context("the remembered branch disappeared while preparing the forkpoint")?
+        .context("the remembered branch disappeared while preparing to attach")?
         .try_id()
         .context("the remembered branch must be a direct reference")?
         .detach();
     if branch_id != remembered.branch_tip {
-        anyhow::bail!("the remembered branch changed while preparing the forkpoint");
+        anyhow::bail!("the remembered branch changed while preparing to attach");
     }
     ensure_branch_is_available(repository, remembered.branch.as_ref())
 }
 
-pub(crate) fn forkpoint(
+pub(crate) fn attach(
     repository_path: &Path,
     bare: bool,
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<String> {
-    let repository =
-        open_repository(repository_path, bare, false).context("could not open repository to set the forkpoint")?;
-    repository
-        .workdir()
-        .context("setting a forkpoint requires a worktree")?;
-    let head = repository
-        .head()
-        .context("could not read HEAD before setting the forkpoint")?;
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not open repository to attach the remembered branch")?;
+    repository.workdir().context("attaching requires a worktree")?;
+    let head = repository.head().context("could not read HEAD before attaching")?;
     if !head.is_detached() {
-        anyhow::bail!("setting a forkpoint requires detached HEAD");
+        anyhow::bail!("attaching requires detached HEAD");
     }
     let head_id = head
         .id()
         .map(gix::Id::detach)
-        .context("setting a forkpoint requires an existing HEAD commit")?;
+        .context("attaching requires an existing HEAD commit")?;
     drop(head);
     let remembered = remembered_branch(&repository)?;
-    validate_forkpoint(&repository, head_id, &remembered)?;
+    validate_attach(&repository, head_id, &remembered)?;
 
     let destination_pin = selected_pin(&repository, head_id)?;
     let provisional = (remembered.branch_tip != head_id && !contains(&repository, remembered.branch_tip, head_id))
@@ -396,7 +390,7 @@ pub(crate) fn forkpoint(
                 &repository,
                 Target::Object(remembered.branch_tip),
                 remembered.branch_tip,
-                "tix forkpoint departure",
+                "tix attach departure",
             )
         })
         .transpose()?;
@@ -406,18 +400,18 @@ pub(crate) fn forkpoint(
             remembered.branch.clone(),
             Target::Object(remembered.branch_tip),
             Target::Object(head_id),
-            "tix forkpoint",
+            "tix attach",
         ));
     }
     edits.push(checked_ref_edit(
         "HEAD".try_into().expect("valid reference name"),
         Target::Object(head_id),
         Target::Symbolic(remembered.branch.clone()),
-        "tix forkpoint",
+        "tix attach",
     ));
     if let Err(err) = repository
         .edit_references(edits)
-        .context("could not move the remembered branch to the forkpoint")
+        .context("could not move and attach the remembered branch")
     {
         return Err(match provisional.as_ref() {
             Some(pin) => cleanup_new_pins(&repository, std::slice::from_ref(pin), err),
@@ -426,7 +420,7 @@ pub(crate) fn forkpoint(
     }
 
     let mut notice = format!(
-        "set {} forkpoint to {}",
+        "attached {} at {}",
         remembered.branch.shorten(),
         head_id.to_hex_with_len(7)
     );
@@ -483,7 +477,7 @@ fn cleanup_new_pins(
     if !edits.is_empty()
         && let Err(err) = repository
             .edit_references(edits)
-            .context("could not remove provisional forkpoint pins")
+            .context("could not remove provisional attach pins")
     {
         cause = cause.context(format!("provisional pin cleanup failed: {err:#}"));
     }
@@ -491,9 +485,7 @@ fn cleanup_new_pins(
 }
 
 fn ensure_branch_is_available(repository: &gix::Repository, branch: &gix::refs::FullNameRef) -> Result<()> {
-    let current = repository
-        .worktree()
-        .context("setting a forkpoint requires a current worktree")?;
+    let current = repository.worktree().context("attaching requires a current worktree")?;
     let current_id = current.id().map(ToOwned::to_owned);
     if current_id.is_some() {
         ensure_worktree_does_not_own_branch(
@@ -1525,7 +1517,7 @@ mod tests {
     }
 
     #[test]
-    fn forkpoint_moves_and_attaches_the_remembered_branch_without_touching_files() -> gix_testtools::Result {
+    fn attach_moves_and_attaches_the_remembered_branch_without_touching_files() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
@@ -1538,8 +1530,8 @@ mod tests {
         std::fs::write(fixture.path().join("root"), "dirty root\n")?;
         let before = gix_testtools::repository::snapshot(fixture.path())?;
 
-        let notice = forkpoint(&repository_path, false, &[], false)?;
-        assert!(notice.contains("set main forkpoint"), "{notice}");
+        let notice = attach(&repository_path, false, &[], false)?;
+        assert!(notice.contains("attached main at"), "{notice}");
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -1558,19 +1550,13 @@ mod tests {
             "the departed branch tip remains visible through an ordinary pin"
         );
         let after = gix_testtools::repository::snapshot(fixture.path())?;
-        assert_eq!(
-            after.index_tree, before.index_tree,
-            "forkpoint does not update the index"
-        );
-        assert_eq!(
-            after.worktree, before.worktree,
-            "forkpoint does not update worktree files"
-        );
+        assert_eq!(after.index_tree, before.index_tree, "attach does not update the index");
+        assert_eq!(after.worktree, before.worktree, "attach does not update worktree files");
         Ok(())
     }
 
     #[test]
-    fn forkpoint_does_not_pin_a_tip_retained_by_another_branch() -> gix_testtools::Result {
+    fn attach_does_not_pin_a_tip_retained_by_another_branch() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         git(fixture.path(), &["branch", "keep", "main"])?;
         let repository = crate::test_repository::open(fixture.path())?;
@@ -1581,7 +1567,7 @@ mod tests {
         drop(repository);
 
         perform(&repository_path, false, middle, &graph, &[], &[], false)?.complete()?;
-        forkpoint(&repository_path, false, &["keep".into()], false)?;
+        attach(&repository_path, false, &["keep".into()], false)?;
         let repository = crate::test_repository::open(fixture.path())?;
         assert!(
             history::all_pins(&repository)?
@@ -1593,7 +1579,7 @@ mod tests {
     }
 
     #[test]
-    fn forkpoint_rejects_a_branch_owned_by_another_worktree() -> gix_testtools::Result {
+    fn attach_rejects_a_branch_owned_by_another_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let repository = crate::test_repository::open(fixture.path())?;
         let repository_path = repository.git_dir().to_owned();
@@ -1613,21 +1599,18 @@ mod tests {
             .status()?;
         assert!(worktree.success(), "the remembered branch moves to another worktree");
 
-        let err = forkpoint(&repository_path, false, &[], false)
-            .expect_err("a branch cannot become attached in two worktrees");
+        let err =
+            attach(&repository_path, false, &[], false).expect_err("a branch cannot become attached in two worktrees");
         assert!(
             format!("{err:#}").contains("checked out in another worktree"),
             "{err:#}"
         );
         let repository = crate::test_repository::open(fixture.path())?;
-        assert!(
-            repository.head()?.is_detached(),
-            "failed forkpoint retains detached HEAD"
-        );
+        assert!(repository.head()?.is_detached(), "failed attach retains detached HEAD");
         assert_eq!(
             repository.head_id()?.detach(),
             middle,
-            "failed forkpoint retains its departure"
+            "failed attach retains its departure"
         );
         assert_eq!(
             repository.find_reference("refs/heads/main")?.id().detach(),
@@ -1641,7 +1624,7 @@ mod tests {
     }
 
     #[test]
-    fn forkpoint_accepts_the_branch_of_the_current_linked_worktree() -> gix_testtools::Result {
+    fn attach_accepts_the_branch_of_the_current_linked_worktree() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
         let linked = fixture.path().join("topic-wt");
         let worktree = Command::new("git")
@@ -1671,17 +1654,17 @@ mod tests {
         );
         drop(repository);
 
-        forkpoint(&git_dir, false, &[], false)?;
+        attach(&git_dir, false, &[], false)?;
         let repository = open_repository(&git_dir, false, false)?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
             Some(branch.as_bstr().to_owned()),
-            "forkpoint reattaches the current linked worktree branch"
+            "attach reattaches the current linked worktree branch"
         );
         assert_eq!(
             repository.find_reference(branch.as_ref())?.id().detach(),
             root,
-            "forkpoint moves the linked worktree branch"
+            "attach moves the linked worktree branch"
         );
         Ok(())
     }
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c537183a5d5..3672c7cc2b0 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2191,6 +2191,71 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("new commit: {err:#}")),
                     }
                 }
+                Effect::ForkCommit(parent) => {
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let created = history_graph
+                        .as_ref()
+                        .context("creating a fork requires a completed history graph")
+                        .and_then(|graph| {
+                            create_commit(
+                                terminal,
+                                &repository_path,
+                                repository_is_bare,
+                                graph,
+                                Some(parent),
+                                CreateMode::Fork,
+                                enhanced_keyboard,
+                            )
+                        });
+                    match created {
+                        Ok(Some(new_id)) => {
+                            let review_roots: Vec<_> =
+                                app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
+                            let travel = open_repository(&repository_path, repository_is_bare, false)
+                                .context("could not reopen repository before travelling to fork")
+                                .and_then(|repository| edit::loaded_graph(&repository))
+                                .and_then(|graph| {
+                                    edit::time_travel::perform(
+                                        &repository_path,
+                                        repository_is_bare,
+                                        new_id,
+                                        &graph,
+                                        &review_roots,
+                                        &revisions,
+                                        false,
+                                    )
+                                });
+                            match travel {
+                                Ok(edit::time_travel::Perform::Complete { notice, selected, .. }) => {
+                                    app.leave_success(notice.map_or_else(
+                                        || format!("created fork {}", new_id.to_hex_with_len(7)),
+                                        |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
+                                    ));
+                                    app.select_commit_after_refresh(selected);
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                                Ok(edit::time_travel::Perform::Conflict(conflict)) => {
+                                    let original = conflict.original();
+                                    app.arm_rebase_conflict(original);
+                                    app.select_commit(original);
+                                    pending_rebase_conflict = Some(conflict);
+                                }
+                                Err(err) => {
+                                    app.leave_attention(format!(
+                                        "created fork {}, but checkout failed: {err:#}",
+                                        new_id.to_hex_with_len(7)
+                                    ));
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                            }
+                        }
+                        Ok(None) => app.leave_attention("no fork created: no input was provided"),
+                        Err(err) => app.leave_error(format!("fork: {err:#}")),
+                    }
+                }
                 Effect::Split(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
@@ -2614,15 +2679,15 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("finish review: {err:#}")),
                     }
                 }
-                Effect::Forkpoint => {
+                Effect::Attach => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    match edit::time_travel::forkpoint(&repository_path, repository_is_bare, &revisions, false) {
+                    match edit::time_travel::attach(&repository_path, repository_is_bare, &revisions, false) {
                         Ok(notice) => {
                             app.leave_success(notice);
                             refresh_pending = true;
                         }
-                        Err(err) => app.leave_error(format!("forkpoint: {err:#}")),
+                        Err(err) => app.leave_error(format!("attach: {err:#}")),
                     }
                 }
                 Effect::TimeTravel(id) => {
@@ -4353,9 +4418,10 @@ fn todo_progress_visible(elapsed: Duration) -> bool {
 enum CreateMode {
     Insert,
     InsertEmpty,
+    Fork,
 }
 
-#[tracing::instrument(skip_all, fields(parent = ?parent))]
+#[tracing::instrument(skip_all, fields(parent = ?parent, fork = matches!(mode, CreateMode::Fork)))]
 fn create_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
@@ -4389,7 +4455,10 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    let id = edit::create::apply(repository, graph, prepared, &edited)?;
+    let id = match mode {
+        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited),
+        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited),
+    }?;
     Ok(Some(id))
 }
 
@@ -5237,8 +5306,9 @@ fn action_with_shortcut_groups(
         KeyCode::Char('m') if actions_expanded => Some(Action::MoveInsert),
         KeyCode::Char('t') if actions_expanded => Some(Action::StackInsert),
         KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
-            Some(Action::Forkpoint)
+            Some(Action::ForkCommit)
         }
+        KeyCode::Char('h') if actions_expanded => Some(Action::Attach),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -6565,7 +6635,8 @@ mod tests {
             ('c', Action::CopyInsert),
             ('m', Action::MoveInsert),
             ('t', Action::StackInsert),
-            ('f', Action::Forkpoint),
+            ('f', Action::ForkCommit),
+            ('h', Action::Attach),
         ] {
             assert_eq!(
                 action_with_shortcut_groups(
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 633e6673573..08149d05382 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1084,11 +1084,17 @@ pub(crate) fn draw_with_worktree(
                 items.push(Span::styled("t", Style::default().add_modifier(Modifier::UNDERLINED)));
                 items.push(Span::raw(" stack-insert"));
             }
-            if app.can_forkpoint() {
+            if app.can_fork_commit() {
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
-                items.extend(shortcut("forkpoint", 'f', true));
+                items.extend(shortcut("fork", 'f', true));
+            }
+            if app.can_attach() {
+                if !items.is_empty() {
+                    items.push(Span::raw(" · "));
+                }
+                items.extend(shortcut("attach", 'h', true));
             }
             if items.is_empty() {
                 items.push(Span::raw("no actions"));
@@ -3989,6 +3995,7 @@ mod tests {
         };
         let mut app = App::new(5);
         app.set_worktree_head(Some(head), false);
+        app.set_worktree_branch(Some((head, true)));
         app.extend_commits(vec![
             commit(head, Some(base)),
             commit(base, Some(parent)),
@@ -4006,6 +4013,8 @@ mod tests {
         let popup = rendered_line(&terminal, 3);
         assert!(popup.contains("copy-insert"));
         assert!(popup.contains("move-insert"));
+        assert!(popup.contains("fork"));
+        assert!(popup.contains("attach"));
         assert!(!popup.contains("cherry-"));
         let label = "t stack-insert";
         let start = popup[..popup.find(label).expect("the stack-insert action is visible")]

From 73b76249b1b2224faf4acff1374f0a910e2e2007 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 09:02:32 +0200
Subject: [PATCH 236/282] feat: highlight foreign worktree heads in tix

Shade titles at attached and detached foreign worktree HEADs while keeping the current HEAD and selection more prominent. Preserve both attached-checkout and remembered-branch decorations when they share a branch.
---
 gix-tix/spec.md        |   5 ++
 gix-tix/src/history.rs |  45 +++++++++++--
 gix-tix/src/ui.rs      | 148 ++++++++++++++++++++++++++++++++++++++---
 3 files changed, 183 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 97389a4ccbd..c6caa6b018a 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -206,6 +206,11 @@ without trading responsiveness for metadata that is not visible.
   directory basename is available. A detached current worktree is identified by
   the graph `@` alone and has no redundant `@directory` label. Identical labels
   are deduplicated.
+- An unselected commit checked out by any foreign worktree gives only its title
+  a dark-gray background, whether that worktree is attached or detached and even
+  when reference labels are hidden. The current worktree's reverse-video title
+  takes precedence when both point to the same commit; selection clears either
+  title emphasis.
 - When reference labels are hidden, worktree labels are visible only on the
   selected row. Stale, malformed, unborn, and otherwise unreadable worktree
   entries are skipped without failing history loading.
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 2b359d01945..ed0fcf3739f 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1904,6 +1904,26 @@ pub(crate) fn decorations_excluding(
         }
         out.entry(id).or_default().push(Decoration { name, kind });
     }
+    for worktree in worktrees
+        .iter()
+        .filter(|worktree| !worktree.is_current && !worktree.is_detached)
+    {
+        let Some(reference) = &worktree.reference else { continue };
+        if excluded.contains(reference.as_bstr()) {
+            continue;
+        }
+        let name = reference.shorten().to_owned();
+        let decorations = out.entry(worktree.id).or_default();
+        if !decorations
+            .iter()
+            .any(|decoration| decoration.kind == DecorationKind::WorktreeBranch && decoration.name == name)
+        {
+            decorations.push(Decoration {
+                name,
+                kind: DecorationKind::WorktreeBranch,
+            });
+        }
+    }
     for worktree in worktrees
         .iter()
         .filter(|worktree| worktree.reference.is_none() || worktree.is_detached && !worktree.is_current)
@@ -2282,6 +2302,14 @@ mod tests {
             .args(["branch", "remembered", "main~1"])
             .status()?;
         assert!(remembered_branch.success(), "git creates the remembered branch");
+        let remembered_worktree = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["worktree", "add", "-q", "remembered-wt", "remembered"])
+            .status()?;
+        assert!(
+            remembered_worktree.success(),
+            "git checks out the branch remembered by another worktree"
+        );
         let remembered_pin = Command::new("git")
             .current_dir(fixture.path().join("detached-wt"))
             .args(["symbolic-ref", "refs/worktree/tix/pins/HEAD", "refs/heads/remembered"])
@@ -2331,7 +2359,7 @@ mod tests {
                 && !worktree.is_current
                 && worktree.is_detached
         }));
-        assert_eq!(worktrees.len(), 3, "the malformed worktree is ignored");
+        assert_eq!(worktrees.len(), 4, "the malformed worktree is ignored");
 
         let main_repo_decorations = decorations(&repo, &[], &worktrees)?;
         let main_decorations = main_repo_decorations.get(&main).expect("main is decorated");
@@ -2353,11 +2381,16 @@ mod tests {
                 decoration.kind == DecorationKind::WorktreeDetached && decoration.name == "detached-wt"
             })
         }));
-        assert!(main_repo_decorations.get(&remembered).is_some_and(|decorations| {
-            decorations
-                .iter()
-                .any(|decoration| decoration.kind == DecorationKind::HeadPinBranch && decoration.name == "remembered")
-        }));
+        assert!(
+            main_repo_decorations.get(&remembered).is_some_and(|decorations| {
+                decorations.iter().any(|decoration| {
+                    decoration.kind == DecorationKind::HeadPinBranch && decoration.name == "remembered"
+                }) && decorations.iter().any(|decoration| {
+                    decoration.kind == DecorationKind::WorktreeBranch && decoration.name == "remembered"
+                })
+            }),
+            "a remembered branch can simultaneously identify an attached foreign worktree"
+        );
 
         let explicit = [OsString::from("main")];
         let without = snapshot(&repo, &explicit, &[], false)?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 08149d05382..592495d2873 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -600,15 +600,24 @@ pub(crate) fn draw_with_worktree(
                     copy_feedback: if row_selected { copy_feedback } else { None },
                 },
             );
-            if !row_selected
-                && decorations.get(&row.id).is_some_and(|decorations| {
-                    decorations
-                        .iter()
-                        .any(|decoration| decoration.kind == DecorationKind::Head)
-                })
-            {
-                for span in &mut metadata.fields[5].spans {
-                    span.style = span.style.add_modifier(Modifier::REVERSED);
+            if !row_selected && let Some(decorations) = decorations.get(&row.id) {
+                let current_head = decorations
+                    .iter()
+                    .any(|decoration| decoration.kind == DecorationKind::Head);
+                let foreign_head = decorations.iter().any(|decoration| {
+                    matches!(
+                        decoration.kind,
+                        DecorationKind::WorktreeBranch | DecorationKind::WorktreeDetached
+                    )
+                });
+                if current_head || foreign_head {
+                    for span in &mut metadata.fields[5].spans {
+                        span.style = if current_head {
+                            span.style.add_modifier(Modifier::REVERSED)
+                        } else {
+                            span.style.bg(Color::DarkGray)
+                        };
+                    }
                 }
             }
             metadata
@@ -4591,6 +4600,127 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn highlights_foreign_worktree_head_titles_without_competing_with_current_head()
+    -> Result<(), Box<dyn std::error::Error>> {
+        let current = gix::ObjectId::Sha1([1; 20]);
+        let attached = gix::ObjectId::Sha1([2; 20]);
+        let detached = gix::ObjectId::Sha1([3; 20]);
+        let ordinary = gix::ObjectId::Sha1([4; 20]);
+        let commit = |id: gix::ObjectId, title: &'static str| Commit {
+            id,
+            parent_ids: Default::default(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: title.into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(4);
+        app.id_mode = IdMode::Commit;
+        app.ref_mode = RefMode::None;
+        app.set_worktree_head(Some(current), false);
+        app.extend_commits(vec![
+            commit(current, "current title"),
+            commit(attached, "attached title"),
+            commit(detached, "detached title"),
+            commit(ordinary, "ordinary title"),
+        ]);
+        complete(&mut app);
+        app.selected = None;
+        let decorations = Decorations::from([
+            (
+                current,
+                vec![
+                    Decoration {
+                        name: "HEAD".into(),
+                        kind: DecorationKind::Head,
+                    },
+                    Decoration {
+                        name: "shared".into(),
+                        kind: DecorationKind::WorktreeBranch,
+                    },
+                ],
+            ),
+            (
+                attached,
+                vec![Decoration {
+                    name: "topic".into(),
+                    kind: DecorationKind::WorktreeBranch,
+                }],
+            ),
+            (
+                detached,
+                vec![Decoration {
+                    name: "agent-wt".into(),
+                    kind: DecorationKind::WorktreeDetached,
+                }],
+            ),
+        ]);
+        let mut terminal = Terminal::new(TestBackend::new(100, 5))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let current_x = rendered_line(&terminal, 0)
+            .find("current title")
+            .expect("the current HEAD title is visible") as u16;
+        assert!(
+            terminal.backend().buffer()[(current_x, 0)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the current HEAD keeps its stronger reverse-video title"
+        );
+        assert_eq!(
+            terminal.backend().buffer()[(current_x, 0)].bg,
+            Color::Reset,
+            "foreign worktrees do not replace current HEAD reverse video"
+        );
+        for (row, title) in [(1, "attached title"), (2, "detached title")] {
+            let line = rendered_line(&terminal, row);
+            let title_x = line.find(title).expect("the foreign worktree title is visible") as u16;
+            let title_cell = &terminal.backend().buffer()[(title_x, row)];
+            assert_eq!(title_cell.bg, Color::DarkGray, "the foreign HEAD title is shaded");
+            assert!(
+                !title_cell.modifier.contains(Modifier::REVERSED),
+                "foreign HEAD titles remain less prominent than current HEAD"
+            );
+            assert_eq!(
+                terminal.backend().buffer()[(0, row)].bg,
+                Color::Reset,
+                "the foreign HEAD background is limited to its title"
+            );
+            assert!(
+                !line.contains('@'),
+                "hidden reference labels do not provide the highlight"
+            );
+        }
+        let ordinary_line = rendered_line(&terminal, 3);
+        let ordinary_x = ordinary_line
+            .find("ordinary title")
+            .expect("the ordinary title is visible") as u16;
+        assert_eq!(
+            terminal.backend().buffer()[(ordinary_x, 3)].bg,
+            Color::Reset,
+            "ordinary commit titles keep the terminal background"
+        );
+
+        app.selected = Some(1);
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
+        let selected_line = rendered_line(&terminal, 1);
+        let selected_title = selected_line
+            .find("attached title")
+            .expect("the selected foreign worktree title is visible") as u16;
+        assert_eq!(
+            terminal.backend().buffer()[(selected_title, 1)].bg,
+            Color::Reset,
+            "selection takes precedence over foreign HEAD emphasis"
+        );
+        Ok(())
+    }
+
     #[test]
     fn marks_dirty_head_independently_of_history_selection() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);

From dfe4541f723cd75a8d1e3203e7a91d44664aa5ee Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 09:36:17 +0200
Subject: [PATCH 237/282] feat: add relative tix travel destinations

Add first, parent, child, and tip destinations resolved within HEAD's visible default-view component. Report ambiguous endpoints with directly usable commit and change IDs while preserving the existing travel pipeline.
---
 gix-tix/spec.md               |  13 +-
 gix-tix/src/command.rs        |  51 ++++-
 gix-tix/src/command/travel.rs | 350 +++++++++++++++++++++++++++++++++-
 gix-tix/src/history.rs        |   4 +
 4 files changed, 408 insertions(+), 10 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c6caa6b018a..74b892672d9 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -24,10 +24,15 @@ without trading responsiveness for metadata that is not visible.
   seven-character commit hash is followed by its seven-character reverse-hex
   change ID. Colliding or duplicated prefixes remain visible and receive a `💥`
   gutter marker.
-- `tix travel [--materialize-conflicts] REVSPEC` performs the same detached
-  checkout, pending-rebase replay, stash handling, and pin reconciliation as
-  TUI time travel. Its target may also be an unambiguous reverse-hex change-ID
-  prefix from the default Tix view. Travelling to the current `HEAD` is a no-op.
+- `tix travel [--materialize-conflicts] (REVSPEC | --to first|parent|child|tip)`
+  performs the same detached checkout, pending-rebase replay, stash handling,
+  and pin reconciliation as TUI time travel. Its target may also be an
+  unambiguous reverse-hex change-ID prefix from the default Tix view. `parent`
+  and `child` move one edge from `HEAD`; `first` selects its oldest reachable
+  root and `tip` its reachable leaf, considering only commits visible in the
+  default view. Multiple direct or terminal candidates are reported with their
+  commit and change IDs and must be selected with a direct `tix travel REVSPEC`.
+  Travelling to the current `HEAD` is a no-op.
   A detached source may travel to a descendant without a pin, but travelling to
   an ancestor or unrelated commit requires an existing current-worktree pin at
   `HEAD` or a descendant. An attached source is preserved through the singleton
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index b0c117517d1..8e39b960a20 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -827,7 +827,56 @@ mod tests {
             panic!("travel was expected")
         };
         assert!(travel.materialize_conflicts);
-        assert_eq!(travel.revision, "HEAD~1");
+        assert_eq!(travel.revision.as_deref(), Some(std::ffi::OsStr::new("HEAD~1")));
+        assert_eq!(travel.to, None);
+        for (value, expected) in [
+            ("first", travel::To::First),
+            ("parent", travel::To::Parent),
+            ("child", travel::To::Child),
+            ("tip", travel::To::Tip),
+        ] {
+            let parsed = Cli::try_parse_from(["tix", "travel", "--to", value])
+                .expect("relative travel parses")
+                .platform
+                .command;
+            let Some(Command::Travel(travel)) = parsed else {
+                panic!("travel was expected")
+            };
+            assert_eq!(travel.revision, None);
+            assert_eq!(travel.to, Some(expected));
+        }
+        assert_eq!(
+            Cli::try_parse_from(["tix", "travel"])
+                .expect_err("travel requires one destination")
+                .kind(),
+            ErrorKind::MissingRequiredArgument
+        );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "travel", "HEAD", "--to", "tip"])
+                .expect_err("relative and explicit travel are mutually exclusive")
+                .kind(),
+            ErrorKind::ArgumentConflict
+        );
+        assert_eq!(
+            Cli::try_parse_from(["tix", "travel", "--to", "last"])
+                .expect_err("tip is the sole name for the upper endpoint")
+                .kind(),
+            ErrorKind::InvalidValue
+        );
+        let travel_help = Cli::try_parse_from(["tix", "travel", "--help"])
+            .expect_err("help exits through clap")
+            .to_string();
+        for description in [
+            "Visit the oldest reachable root",
+            "Visit HEAD's direct visible parent",
+            "Visit HEAD's direct visible child",
+            "Visit the reachable leaf",
+        ] {
+            assert!(
+                travel_help.contains(description),
+                "travel help describes every relative destination: {travel_help}"
+            );
+        }
         let reword = Cli::try_parse_from(["tix", "reword", "HEAD~2"])
             .expect("reword parses")
             .platform
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 1d98dd47ef2..525e8bfac74 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -1,19 +1,53 @@
-use std::ffi::OsString;
+use std::{
+    collections::{HashMap, HashSet},
+    ffi::OsString,
+};
 
 use anyhow::{Context, Result};
 
+#[derive(Clone, Copy, Debug, Eq, PartialEq, clap::ValueEnum)]
+pub(super) enum To {
+    /// Visit the oldest reachable root in HEAD's visible history.
+    First,
+    /// Visit HEAD's direct visible parent.
+    Parent,
+    /// Visit HEAD's direct visible child.
+    Child,
+    /// Visit the reachable leaf in HEAD's visible history.
+    Tip,
+}
+
+impl To {
+    fn name(self) -> &'static str {
+        match self {
+            To::First => "first",
+            To::Parent => "parent",
+            To::Child => "child",
+            To::Tip => "tip",
+        }
+    }
+}
+
 #[derive(Debug, clap::Args)]
+#[command(group(
+    clap::ArgGroup::new("destination")
+        .required(true)
+        .multiple(false)
+        .args(["revision", "to"])
+))]
 pub(super) struct Args {
     /// Check out an encountered replay conflict and write its unmerged index.
     #[arg(long)]
     pub(super) materialize_conflicts: bool,
     /// Revision resolving to the commit to visit.
     #[arg(value_name = "REVSPEC")]
-    pub(super) revision: OsString,
+    pub(super) revision: Option<OsString>,
+    /// Visit a commit relative to HEAD in the default Tix view.
+    #[arg(long, value_enum, value_name = "DESTINATION")]
+    pub(super) to: Option<To>,
 }
 
 pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
-    let (selected, resolved_graph) = super::resolve_commit(&repository, &args.revision, "time-travel destination")?;
     let head = repository.head().context("could not read HEAD before time-travel")?;
     let head_id = head
         .id()
@@ -21,6 +55,15 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("cannot time-travel from an unborn HEAD")?;
     let detached = head.is_detached();
     drop(head);
+    let (selected, resolved_graph) = match (&args.revision, args.to) {
+        (Some(revision), None) => super::resolve_commit(&repository, revision, "time-travel destination")?,
+        (None, Some(to)) => {
+            let graph = crate::edit::loaded_view_graph(&repository)?;
+            let selected = relative_destination(&repository, &graph, head_id, to)?;
+            (selected, Some(graph))
+        }
+        _ => anyhow::bail!("exactly one time-travel destination is required"),
+    };
     if selected == head_id {
         println!("already at {}", crate::change_id::display(&repository, selected, 7)?);
         return Ok(());
@@ -82,6 +125,117 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     Ok(())
 }
 
+fn relative_destination(
+    repository: &gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    head: gix::ObjectId,
+    to: To,
+) -> Result<gix::ObjectId> {
+    let order = graph.stored_commit_ids().collect::<Vec<_>>();
+    let stored = order.iter().copied().collect::<HashSet<_>>();
+    if !stored.contains(&head) {
+        anyhow::bail!("HEAD is not present in the default Tix view");
+    }
+
+    let candidates = match to {
+        To::Parent => visible_parents(graph, head, &stored),
+        To::Child => order
+            .iter()
+            .copied()
+            .filter(|id| graph.parents_of(*id).is_some_and(|parents| parents.contains(&head)))
+            .collect(),
+        To::First => first_candidates(graph, head, &stored, &order),
+        To::Tip => terminal_candidates(head, &children_by_parent(graph, &stored, &order), &order),
+    };
+    match candidates.as_slice() {
+        [candidate] => Ok(*candidate),
+        [] => anyhow::bail!("HEAD has no {} in the default Tix view", to.name()),
+        candidates => {
+            let candidates = candidates
+                .iter()
+                .map(|id| crate::change_id::display_short(repository, *id))
+                .collect::<Result<Vec<_>>>()?
+                .join("\n  ");
+            anyhow::bail!(
+                "--to {} is ambiguous; candidates:\n  {candidates}\ntravel to one directly with `tix travel REVSPEC`",
+                to.name()
+            )
+        }
+    }
+}
+
+fn visible_parents(
+    graph: &crate::history::HistoryGraph,
+    id: gix::ObjectId,
+    stored: &HashSet<gix::ObjectId>,
+) -> Vec<gix::ObjectId> {
+    graph
+        .parents_of(id)
+        .unwrap_or_default()
+        .into_iter()
+        .filter(|parent| stored.contains(parent))
+        .collect()
+}
+
+fn first_candidates(
+    graph: &crate::history::HistoryGraph,
+    start: gix::ObjectId,
+    stored: &HashSet<gix::ObjectId>,
+    order: &[gix::ObjectId],
+) -> Vec<gix::ObjectId> {
+    let mut pending = vec![start];
+    let mut seen = HashSet::new();
+    let mut terminals = HashSet::new();
+    while let Some(id) = pending.pop() {
+        if !seen.insert(id) {
+            continue;
+        }
+        let parents = visible_parents(graph, id, stored);
+        if parents.is_empty() {
+            terminals.insert(id);
+        } else {
+            pending.extend(parents);
+        }
+    }
+    order.iter().copied().filter(|id| terminals.contains(id)).collect()
+}
+
+fn children_by_parent(
+    graph: &crate::history::HistoryGraph,
+    stored: &HashSet<gix::ObjectId>,
+    order: &[gix::ObjectId],
+) -> HashMap<gix::ObjectId, Vec<gix::ObjectId>> {
+    let mut children = HashMap::<_, Vec<_>>::new();
+    for &id in order {
+        for parent in visible_parents(graph, id, stored) {
+            children.entry(parent).or_default().push(id);
+        }
+    }
+    children
+}
+
+fn terminal_candidates(
+    start: gix::ObjectId,
+    adjacent: &HashMap<gix::ObjectId, Vec<gix::ObjectId>>,
+    order: &[gix::ObjectId],
+) -> Vec<gix::ObjectId> {
+    let mut pending = vec![start];
+    let mut seen = HashSet::new();
+    let mut terminals = HashSet::new();
+    while let Some(id) = pending.pop() {
+        if !seen.insert(id) {
+            continue;
+        }
+        match adjacent.get(&id).filter(|next| !next.is_empty()) {
+            Some(next) => pending.extend(next),
+            None => {
+                terminals.insert(id);
+            }
+        }
+    }
+    order.iter().copied().filter(|id| terminals.contains(id)).collect()
+}
+
 #[cfg(test)]
 mod tests {
     use std::{path::Path, process::Command};
@@ -98,10 +252,26 @@ mod tests {
         Ok(output.stdout)
     }
 
+    fn observable_state(path: &Path) -> gix_testtools::Result<(Vec<u8>, Vec<u8>)> {
+        Ok((
+            git(path, &["status", "--porcelain=v2", "--branch"])?,
+            git(path, &["show-ref"])?,
+        ))
+    }
+
     fn args(revision: &str) -> Args {
         Args {
             materialize_conflicts: false,
-            revision: revision.into(),
+            revision: Some(revision.into()),
+            to: None,
+        }
+    }
+
+    fn relative_args(to: To) -> Args {
+        Args {
+            materialize_conflicts: false,
+            revision: None,
+            to: Some(to),
         }
     }
 
@@ -181,6 +351,175 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn relative_targets_follow_the_current_default_view_component() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open(path)?;
+        let tip = repository.head_id()?.detach();
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        drop(repository);
+
+        let orphan = gix::ObjectId::from_hex(git(path, &["commit-tree", "HEAD^{tree}", "-m", "orphan"])?.trim())?;
+        let orphan = orphan.to_string();
+        git(path, &["update-ref", "refs/worktree/tix/pins/unrelated", &orphan])?;
+        let tip_hex = tip.to_string();
+        let upstream = gix::ObjectId::from_hex(
+            git(path, &["commit-tree", "HEAD^{tree}", "-p", &tip_hex, "-m", "upstream"])?.trim(),
+        )?
+        .to_string();
+        git(path, &["update-ref", "refs/remotes/origin/main", &upstream])?;
+        git(path, &["config", "branch.main.remote", "origin"])?;
+        git(path, &["config", "branch.main.merge", "refs/heads/main"])?;
+
+        run(crate::test_repository::open(path)?, relative_args(To::Tip))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            tip,
+            "tip travel at the attached tip is a no-op"
+        );
+        let before = observable_state(path)?;
+        let err = run(crate::test_repository::open(path)?, relative_args(To::Child))
+            .expect_err("the visible tip has no child");
+        assert!(format!("{err:#}").contains("no child"));
+        assert_eq!(
+            observable_state(path)?,
+            before,
+            "a missing child leaves the repository unchanged"
+        );
+
+        run(crate::test_repository::open(path)?, relative_args(To::Parent))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            middle,
+            "parent travels down by one commit"
+        );
+        run(crate::test_repository::open(path)?, relative_args(To::First))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            root,
+            "first reaches this component's oldest commit"
+        );
+        run(crate::test_repository::open(path)?, relative_args(To::First))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            root,
+            "first travel at the oldest commit is a no-op"
+        );
+
+        let before = observable_state(path)?;
+        let err = run(crate::test_repository::open(path)?, relative_args(To::Parent))
+            .expect_err("the visible root has no parent");
+        assert!(format!("{err:#}").contains("no parent"));
+        assert_eq!(
+            observable_state(path)?,
+            before,
+            "a missing parent leaves the repository unchanged"
+        );
+
+        run(crate::test_repository::open(path)?, relative_args(To::Child))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            middle,
+            "child travels up by one commit"
+        );
+        run(crate::test_repository::open(path)?, relative_args(To::Tip))?;
+        let repository = crate::test_repository::open(path)?;
+        assert_eq!(repository.head_id()?.detach(), tip, "tip reaches this component's leaf");
+        assert_eq!(
+            repository.head()?.referent_name().map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".as_bstr().to_owned()),
+            "travelling to the branch tip reattaches HEAD"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn relative_target_ambiguity_lists_every_candidate() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open(path)?;
+        let old_tip = repository.head_id()?.detach();
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        drop(repository);
+
+        let orphan = gix::ObjectId::from_hex(git(path, &["commit-tree", "HEAD^{tree}", "-m", "orphan"])?.trim())?;
+        let old_tip_hex = old_tip.to_string();
+        let orphan_hex = orphan.to_string();
+        let merge = gix::ObjectId::from_hex(
+            git(
+                path,
+                &[
+                    "commit-tree",
+                    "HEAD^{tree}",
+                    "-p",
+                    &old_tip_hex,
+                    "-p",
+                    &orphan_hex,
+                    "-m",
+                    "merge",
+                ],
+            )?
+            .trim(),
+        )?;
+        let merge_hex = merge.to_string();
+        let left = gix::ObjectId::from_hex(
+            git(path, &["commit-tree", "HEAD^{tree}", "-p", &merge_hex, "-m", "left"])?.trim(),
+        )?;
+        let right = gix::ObjectId::from_hex(
+            git(path, &["commit-tree", "HEAD^{tree}", "-p", &merge_hex, "-m", "right"])?.trim(),
+        )?;
+        git(path, &["update-ref", "refs/heads/main", &merge_hex, &old_tip_hex])?;
+        let left_hex = left.to_string();
+        let right_hex = right.to_string();
+        git(path, &["update-ref", "refs/worktree/tix/pins/left", &left_hex])?;
+        git(path, &["update-ref", "refs/worktree/tix/pins/right", &right_hex])?;
+
+        let repository = crate::test_repository::open(path)?;
+        let cases = [
+            (To::First, vec![root, orphan]),
+            (To::Parent, vec![old_tip, orphan]),
+            (To::Child, vec![left, right]),
+            (To::Tip, vec![left, right]),
+        ];
+        let expected = cases
+            .iter()
+            .map(|(to, candidates)| {
+                Ok::<_, anyhow::Error>((
+                    *to,
+                    candidates
+                        .iter()
+                        .map(|id| crate::change_id::display_short(&repository, *id))
+                        .collect::<Result<Vec<_>>>()?,
+                ))
+            })
+            .collect::<Result<Vec<_>>>()?;
+        drop(repository);
+        let before = observable_state(path)?;
+        for (to, candidates) in expected {
+            let err = run(crate::test_repository::open(path)?, relative_args(to))
+                .expect_err("multiple relative destinations are ambiguous");
+            let message = format!("{err:#}");
+            for candidate in candidates {
+                assert!(
+                    message.contains(&candidate),
+                    "{to:?} ambiguity lists candidate {candidate}: {message}"
+                );
+            }
+            assert!(
+                message.contains("tix travel REVSPEC"),
+                "ambiguity suggests direct travel: {message}"
+            );
+            assert_eq!(
+                observable_state(path)?,
+                before,
+                "ambiguity leaves the repository unchanged"
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn replay_conflicts_are_unobservable_until_materialization_is_requested() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
@@ -222,7 +561,8 @@ mod tests {
             crate::test_repository::open(path)?,
             Args {
                 materialize_conflicts: true,
-                revision: tip.to_string().into(),
+                revision: Some(tip.to_string().into()),
+                to: None,
             },
         )
         .expect_err("a materialized conflict remains an incomplete command");
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index ed0fcf3739f..118b289d1af 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -241,6 +241,10 @@ impl HistoryGraph {
         self.commits.iter().map(|commit| commit.id)
     }
 
+    pub(crate) fn stored_commit_ids(&self) -> impl Iterator<Item = ObjectId> + '_ {
+        self.stored_order.iter().map(|index| self.id(*index))
+    }
+
     pub(crate) fn is_ancestor(&self, ancestor: ObjectId, descendant: ObjectId) -> bool {
         let (Some(ancestor), Some(descendant)) = (self.index(ancestor), self.index(descendant)) else {
             return false;

From 087113f73d4c1f3dfe470aaa1dda0ab7dc3260c0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 09:42:30 +0200
Subject: [PATCH 238/282] fix: keep change panes behind prefix popups

Keep pane content above the floating popup while extending each cleared overlay to its original bottom, so no history row shows through.
---
 gix-tix/src/ui.rs | 57 +++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 50 insertions(+), 7 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 592495d2873..530d5b07aac 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -471,6 +471,18 @@ pub(crate) fn draw_with_worktree(
             }
         }
     }
+    // Keep pane content above the popup while its underlay still covers the history row beneath it.
+    let changes_pane_underlays = changes_panes
+        .iter()
+        .zip(&history_changes_panes)
+        .map(|(pane, unshifted)| {
+            let mut area = pane.outer;
+            if prefix_popup_allowed {
+                area.height = unshifted.outer.bottom().saturating_sub(area.y);
+            }
+            area
+        })
+        .collect::<Vec<_>>();
     let worktree_dirty = worktree_changes.is_some_and(|changes| !changes.paths.is_empty())
         && changes_panes
             .iter()
@@ -873,7 +885,7 @@ pub(crate) fn draw_with_worktree(
             frame.render_widget(Paragraph::new(selection_info), area);
         }
     }
-    for pane_area in &changes_panes {
+    for (pane_area, underlay) in changes_panes.iter().zip(&changes_pane_underlays) {
         let outer = pane_area.outer;
         let pane = pane_area.pane;
         let changes = match pane {
@@ -888,7 +900,7 @@ pub(crate) fn draw_with_worktree(
             horizontal: 2,
             vertical: 1,
         });
-        frame.render_widget(Clear, outer);
+        frame.render_widget(Clear, *underlay);
         frame.render_widget(Block::new().borders(Borders::TOP).title(summary), outer);
         render_changes(frame, area, changes, pane, app);
         if app.changes_focus == Some(pane) {
@@ -1290,9 +1302,8 @@ pub(crate) fn draw_with_worktree(
         .and_then(|(anchor, items)| render_prefix_popup(frame, footer, anchor, items));
     FrameLayout {
         history: body,
-        overlays: changes_panes
-            .iter()
-            .map(|pane| pane.outer)
+        overlays: changes_pane_underlays
+            .into_iter()
             .chain(commit_pane.map(|(outer, _)| outer))
             .chain(notice_area)
             .chain(prefix_popup_area)
@@ -5166,6 +5177,25 @@ mod tests {
     #[test]
     fn popup_keeps_a_focused_changes_error_visible() -> Result<(), Box<dyn std::error::Error>> {
         let mut app = App::new(1);
+        app.id_mode = IdMode::Commit;
+        app.extend_commits(
+            (1..=5)
+                .map(|n| Commit {
+                    id: gix::ObjectId::Sha1([n; 20]),
+                    parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: format!("history {n}").into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
         app.changes_focus = Some(ChangePane::Tree);
         app.tree_changes.error = Some("failed deliberately".into());
         app.information_expanded = true;
@@ -5197,11 +5227,24 @@ mod tests {
         assert!(rendered_line(&terminal, 3).contains("diff: failed deliberately"));
         assert_eq!(terminal.backend().buffer()[(2, 3)].bg, PANE_STATUS_BACKGROUND);
         assert!(rendered_line(&terminal, 4).contains("[ title"));
+        let layout = layout.expect("drawing returns its layout");
         assert_eq!(
-            layout.expect("drawing returns its layout").history.height,
-            5,
+            layout.history.height, 5,
             "moving the changes pane leaves history geometry unchanged"
         );
+        let popup = layout
+            .overlays
+            .iter()
+            .copied()
+            .find(|area| area.y == 4 && area.height == 1)
+            .expect("the popup is a one-line overlay above the footer");
+        assert!(popup.width < 120, "the popup leaves pane underlay visible on its row");
+        assert!(
+            (0..popup.x)
+                .chain(popup.right()..120)
+                .all(|x| terminal.backend().buffer()[(x, popup.y)].symbol() == " "),
+            "the grown changes pane keeps history covered beneath the floating popup"
+        );
         Ok(())
     }
 

From 05306d9e1b64f6837ff457acdba7fb5dc30434dd Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 09:52:15 +0200
Subject: [PATCH 239/282] fix: resolve tix change IDs only in visible history

Exclude tracking-only graph nodes from reverse-hex change-ID resolution so command selectors match rendered history rows. Cover the duplicated-upstream case that made tix travel report false ambiguity.
---
 gix-tix/src/command.rs        |  2 +-
 gix-tix/src/command/travel.rs | 49 +++++++++++++++++++++++++++++++++++
 gix-tix/src/history.rs        |  4 ---
 3 files changed, 50 insertions(+), 5 deletions(-)

diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 8e39b960a20..512ce4eba08 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -435,7 +435,7 @@ fn resolve_commit(
             let graph = crate::edit::loaded_view_graph(repository)?;
             let resolved = std::str::from_utf8(revision)
                 .ok()
-                .map(|prefix| crate::change_id::resolve_prefix(repository, prefix, graph.commit_ids()))
+                .map(|prefix| crate::change_id::resolve_prefix(repository, prefix, graph.stored_commit_ids()))
                 .transpose()?
                 .flatten();
             match resolved {
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 525e8bfac74..12ad08dbb6e 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -275,6 +275,55 @@ mod tests {
         }
     }
 
+    #[test]
+    fn change_ids_ignore_non_visible_tracking_history() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open(path)?;
+        let main = repository.rev_parse_single("main")?.detach();
+        let original_topic = repository.rev_parse_single("topic")?.detach();
+        let change_id = crate::change_id::for_commit(&repository, main)?;
+        let mut topic = repository.find_commit(original_topic)?.decode()?.into_owned()?;
+        topic
+            .extra_headers
+            .push((crate::change_id::HEADER.into(), change_id.to_string().into()));
+        let topic = repository.write_object(&topic)?.detach();
+        drop(repository);
+
+        git(path, &["update-ref", "refs/heads/topic", &topic.to_string()])?;
+        git(path, &["config", "remote.origin.url", "https://example.com/repo"])?;
+        git(
+            path,
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+        )?;
+        git(path, &["config", "branch.topic.remote", "origin"])?;
+        git(path, &["config", "branch.topic.merge", "refs/heads/main"])?;
+        git(path, &["update-ref", "refs/remotes/origin/main", &main.to_string()])?;
+        git(path, &["switch", "-q", "topic"])?;
+
+        let repository = crate::test_repository::open(path)?;
+        let graph = crate::edit::loaded_view_graph(&repository)?;
+        assert!(
+            graph.index(main).is_some(),
+            "the tracking commit is loaded for topology"
+        );
+        assert!(
+            !graph.stored_commit_ids().any(|id| id == main),
+            "the tracking commit is absent from the visible view"
+        );
+        assert!(
+            graph.stored_commit_ids().any(|id| id == topic),
+            "the checked-out topic is visible"
+        );
+        run(repository, args(&change_id.to_reverse_hex().to_string()))?;
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            topic,
+            "the visible change ID resolves to the already checked-out topic"
+        );
+        Ok(())
+    }
+
     #[test]
     fn attached_past_travel_saves_and_returns_to_the_branch() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 118b289d1af..665506e4897 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -237,10 +237,6 @@ impl HistoryGraph {
         self.commits.len()
     }
 
-    pub(crate) fn commit_ids(&self) -> impl Iterator<Item = ObjectId> + '_ {
-        self.commits.iter().map(|commit| commit.id)
-    }
-
     pub(crate) fn stored_commit_ids(&self) -> impl Iterator<Item = ObjectId> + '_ {
         self.stored_order.iter().map(|index| self.id(*index))
     }

From c98a39e5b0c95682c067ac6373068c55e589a015 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 10:28:28 +0200
Subject: [PATCH 240/282] feat: add a compressed Tix history view

Collapse non-tip history segments into nonselectable ring rows while preserving visible tips, selection, and graph topology.

Keep rewrite and conflict selection workflows on the full history.
---
 gix-tix/spec.md    |  10 +-
 gix-tix/src/app.rs | 458 ++++++++++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs |  42 +++--
 gix-tix/src/ui.rs  | 262 +++++++++++++++++++-------
 4 files changed, 656 insertions(+), 116 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 74b892672d9..c0c3d152b74 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -386,7 +386,7 @@ without trading responsiveness for metadata that is not visible.
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. |
 | `t` | Toggle the rounded ref-tree overview. |
-| `[` | Cycle viewport-local title alignment, full-column alignment, and no alignment. |
+| `[` | Cycle viewport-local title alignment, full-column alignment, no alignment, and compressed history. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Cycle author dates, committer dates, and no dates. |
 | `v e` | Toggle full actors/emails and titles. |
@@ -409,6 +409,14 @@ Alignment uses only rows in the current viewport to determine widths and starts
 in title mode. Horizontal navigation pans the complete padded row in title and
 full-column alignment so clipped fields can be reached.
 
+Compressed history keeps the visible reference, pin, and worktree tips plus the
+commit selected when compression begins. Every maximal hidden segment is shown
+as a nonselectable hollow node followed by its exact commit count, such as
+`○ [12]`; navigation skips these summaries. Retained commits use title
+alignment, and cycling `[` again restores the normal title-aligned history.
+Review, rewrite-target, and rebase-conflict selection temporarily expand the
+history without leaving compressed mode.
+
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
 for signature verification, alignment, message, and changes actions. The footer
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 30521479efc..f44738c6cbd 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -454,6 +454,21 @@ pub(crate) enum Alignment {
     None,
     Title,
     Columns,
+    Compressed,
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub(crate) enum HistoryEntry {
+    Commit(usize),
+    Segment { count: usize },
+}
+
+#[derive(Debug)]
+struct CompressedHistory {
+    entries: Vec<HistoryEntry>,
+    display_indices: HashMap<usize, usize>,
+    rows: Vec<SharedCommitRow>,
+    graph: Graph,
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -485,6 +500,9 @@ pub(crate) struct App {
     enrichments: HashMap<ObjectId, crate::enrich::Enrichment>,
     tree_enrichments: HashMap<ObjectId, crate::enrich::TreeEnrichment>,
     graph: Option<Graph>,
+    view_tips: HashSet<ObjectId>,
+    compressed_history: Option<CompressedHistory>,
+    compressed_anchor: Option<ObjectId>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
     test_lanes: Vec<String>,
@@ -587,6 +605,9 @@ impl App {
             enrichments: HashMap::new(),
             tree_enrichments: HashMap::new(),
             graph: None,
+            view_tips: HashSet::new(),
+            compressed_history: None,
+            compressed_anchor: None,
             attributions: Vec::new(),
             #[cfg(test)]
             test_lanes: Vec::new(),
@@ -783,6 +804,14 @@ impl App {
         self.worktree_head_unborn = unborn;
     }
 
+    pub(crate) fn set_view_tips(&mut self, tips: &[ObjectId]) {
+        self.view_tips.clear();
+        self.view_tips.extend(tips.iter().copied());
+        if self.alignment == Alignment::Compressed {
+            self.rebuild_compressed_history();
+        }
+    }
+
     pub(crate) fn arm_rebase_conflict(&mut self, id: ObjectId) {
         tracing::warn!(
             commit_id = %id,
@@ -805,6 +834,7 @@ impl App {
     pub(crate) fn clear_rebase_conflict(&mut self) {
         self.pending_rebase_conflict = None;
         self.notice = None;
+        self.restore_compressed_history_around_selection();
     }
 
     pub(crate) fn begin_conflict_resolution(&mut self) {
@@ -812,14 +842,17 @@ impl App {
         self.worktree_conflicted = true;
         self.changes_mode = Some(ChangesMode::Both);
         self.changes_focus = None;
+        self.restore_compressed_history_around_selection();
     }
 
     pub(crate) fn arm_rebase_continuation(&mut self) {
         self.rebase_continuation_pending = true;
+        self.ensure_visible();
     }
 
     pub(crate) fn clear_rebase_continuation(&mut self) {
         self.rebase_continuation_pending = false;
+        self.restore_compressed_history_around_selection();
     }
 
     pub(crate) fn rebase_continuation_pending(&self) -> bool {
@@ -831,7 +864,15 @@ impl App {
     }
 
     pub(crate) fn set_worktree_conflicted(&mut self, conflicted: bool) {
+        if self.worktree_conflicted == conflicted {
+            return;
+        }
         self.worktree_conflicted = conflicted;
+        if conflicted {
+            self.ensure_visible();
+        } else {
+            self.restore_compressed_history_around_selection();
+        }
     }
 
     pub(crate) fn conflict_marker(&self, id: ObjectId, head: bool) -> bool {
@@ -1033,13 +1074,86 @@ impl App {
         self.tree_enrichments.clear();
     }
 
+    pub(crate) fn history_len(&self) -> usize {
+        self.active_compressed_history()
+            .map_or(self.rows.len(), |history| history.entries.len())
+    }
+
+    pub(crate) fn history_entry(&self, index: usize) -> Option<HistoryEntry> {
+        self.active_compressed_history().map_or_else(
+            || (index < self.rows.len()).then_some(HistoryEntry::Commit(index)),
+            |history| history.entries.get(index).copied(),
+        )
+    }
+
+    pub(crate) fn history_index(&self, canonical_index: usize) -> Option<usize> {
+        self.active_compressed_history().map_or_else(
+            || (canonical_index < self.rows.len()).then_some(canonical_index),
+            |history| history.display_indices.get(&canonical_index).copied(),
+        )
+    }
+
+    pub(crate) fn selected_history_index(&self) -> Option<usize> {
+        self.selected.and_then(|selected| self.history_index(selected))
+    }
+
+    pub(crate) fn visible_history_indices(&self, range: Range<usize>) -> Vec<usize> {
+        let start = range.start.min(self.history_len());
+        let end = range.end.min(self.history_len());
+        (start..end)
+            .filter_map(|index| match self.history_entry(index) {
+                Some(HistoryEntry::Commit(index)) => Some(index),
+                Some(HistoryEntry::Segment { .. }) | None => None,
+            })
+            .collect()
+    }
+
+    fn active_compressed_history(&self) -> Option<&CompressedHistory> {
+        (self.alignment == Alignment::Compressed && !self.compressed_history_suspended())
+            .then_some(self.compressed_history.as_ref())
+            .flatten()
+    }
+
+    fn compressed_history_suspended(&self) -> bool {
+        self.pending_rebase_conflict.is_some()
+            || self.rebase_continuation_pending
+            || self.worktree_conflicted
+            || self.reachability_anchor.is_some()
+            || self.review_return.is_some()
+            || self.stack_insert_base.is_some()
+            || self.reachable_rows.is_some()
+    }
+
+    fn rebuild_compressed_history(&mut self) {
+        self.compressed_history = (self.graph.is_some() && !self.rows.is_empty())
+            .then(|| CompressedHistory::new(&self.rows, &self.view_tips, self.compressed_anchor));
+    }
+
+    fn restore_compressed_history_around_selection(&mut self) {
+        if self.alignment != Alignment::Compressed {
+            return;
+        }
+        self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        self.rebuild_compressed_history();
+        self.ensure_visible();
+    }
+
     pub(crate) fn render_lanes(&self, range: Range<usize>) -> RenderedLanes {
         #[cfg(test)]
-        if !self.test_lanes.is_empty() {
+        if self.active_compressed_history().is_none() && !self.test_lanes.is_empty() {
             return RenderedLanes::from_lanes(
                 self.test_lanes[range.start.min(self.test_lanes.len())..range.end.min(self.test_lanes.len())].iter(),
             );
         }
+        if let Some(history) = self.active_compressed_history() {
+            return history.graph.render_with_markers(&history.rows, range, |index| {
+                if matches!(history.entries[index], HistoryEntry::Segment { .. }) {
+                    '○'
+                } else {
+                    '●'
+                }
+            });
+        }
         match &self.graph {
             Some(graph) => graph.render(&self.rows, range),
             None => RenderedLanes::empty(range.len()),
@@ -1228,10 +1342,10 @@ impl App {
             }
             Action::ToggleEmail => self.show_emails = !self.show_emails,
             Action::ToggleName => {
-                let start = self.offset.min(self.rows.len());
-                let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
-                let has_visible_attributions = self.rows[start..end]
-                    .iter()
+                let visible = self.visible_history_indices(self.offset..self.offset.saturating_add(self.viewport_rows));
+                let has_visible_attributions = visible
+                    .into_iter()
+                    .filter_map(|index| self.rows.get(index))
                     .any(|row| row.metadata_loaded && !row.attributions.is_empty());
                 self.name_mode = match self.name_mode {
                     NameMode::All if has_visible_attributions => NameMode::Author,
@@ -1273,8 +1387,14 @@ impl App {
                 self.alignment = match self.alignment {
                     Alignment::Title => Alignment::Columns,
                     Alignment::Columns => Alignment::None,
-                    Alignment::None => Alignment::Title,
+                    Alignment::None => Alignment::Compressed,
+                    Alignment::Compressed => Alignment::Title,
                 };
+                if self.alignment == Alignment::Compressed {
+                    self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+                    self.rebuild_compressed_history();
+                }
+                self.ensure_visible();
             }
             Action::ToggleCommit => {
                 self.show_commit = !self.show_commit;
@@ -1492,6 +1612,7 @@ impl App {
                         debug_assert_eq!(source, self.worktree_head.expect("a stack insertion has HEAD"));
                         self.stack_insert_base = Some(base);
                         self.reachable_rows = Some(reachable);
+                        self.ensure_visible();
                     }
                 }
             }
@@ -1556,16 +1677,15 @@ impl App {
                 }
             }
             Action::VerifySignatures if !self.signature_verification_running => {
-                let start = self.offset.min(self.rows.len());
-                let end = start.saturating_add(self.viewport_rows).min(self.rows.len());
-                let changed: Vec<_> = self.rows[start..end]
-                    .iter_mut()
-                    .filter(|row| !self.hidden_rows.contains(&row.id) && row.signature == SignatureState::Unverified)
-                    .map(|row| {
+                let visible = self.visible_history_indices(self.offset..self.offset.saturating_add(self.viewport_rows));
+                let mut changed = Vec::new();
+                for index in visible {
+                    let row = &mut self.rows[index];
+                    if !self.hidden_rows.contains(&row.id) && row.signature == SignatureState::Unverified {
                         Arc::make_mut(row).signature = SignatureState::Verifying;
-                        (row.id, Arc::clone(row))
-                    })
-                    .collect();
+                        changed.push((row.id, Arc::clone(row)));
+                    }
+                }
                 for (id, row) in &changed {
                     self.all_rows.insert(*id, Arc::clone(row));
                 }
@@ -1750,6 +1870,7 @@ impl App {
         select_top: bool,
     ) -> Option<Vec<SharedCommitRow>> {
         self.forget_confirmation = None;
+        self.set_view_tips(view_tips);
         if self.stack_insert_base.is_some() {
             self.clear_reachability_selection();
         }
@@ -1868,7 +1989,11 @@ impl App {
         self.update_worktree_head_descendants();
         self.selected = selected
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
-            .or_else(|| self.first_selectable());
+            .or_else(|| (!self.rows.is_empty()).then_some(0));
+        if self.alignment == Alignment::Compressed {
+            self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+            self.rebuild_compressed_history();
+        }
         self.state = State::Complete;
         if self.reachability_anchor.is_some() {
             self.compute_reachable_rows();
@@ -1900,6 +2025,9 @@ impl App {
         self.notes.clear();
         self.clear_enrichments();
         self.graph = None;
+        self.view_tips.clear();
+        self.compressed_history = None;
+        self.compressed_anchor = None;
         self.attributions = Vec::new();
         #[cfg(test)]
         self.test_lanes.clear();
@@ -1960,6 +2088,7 @@ impl App {
         self.stack_insert_base = None;
         self.reachability_anchor = None;
         self.reachable_rows = None;
+        self.restore_compressed_history_around_selection();
     }
 
     pub(crate) fn select_review_return(&mut self, review: ObjectId, tip: ObjectId) -> bool {
@@ -2031,10 +2160,15 @@ impl App {
     fn move_selection(&mut self, distance: usize, down: bool) {
         self.pending_initial_selection = None;
         let Some(selected) = self.selected else { return };
+        let Some(display_selected) = self.history_index(selected) else {
+            return;
+        };
         let target = if down {
-            selected.saturating_add(distance).min(self.rows.len() - 1)
+            display_selected
+                .saturating_add(distance)
+                .min(self.history_len().saturating_sub(1))
         } else {
-            selected.saturating_sub(distance)
+            display_selected.saturating_sub(distance)
         };
         self.selected = self.nearest_selectable(target, down);
         if self.selected != Some(selected) {
@@ -2104,6 +2238,9 @@ impl App {
             })
             .collect();
         self.reachable_rows = Some(reachable);
+        if self.alignment == Alignment::Compressed {
+            self.ensure_visible();
+        }
     }
 
     pub(crate) fn is_row_reachable(&self, index: usize) -> bool {
@@ -2137,8 +2274,16 @@ impl App {
     fn select(&mut self, selected: usize) {
         self.pending_initial_selection = None;
         if !self.rows.is_empty() {
+            let selected = selected.min(self.rows.len() - 1);
+            if self.alignment == Alignment::Compressed
+                && !self.compressed_history_suspended()
+                && self.history_index(selected).is_none()
+            {
+                self.compressed_anchor = Some(self.rows[selected].id);
+                self.rebuild_compressed_history();
+            }
             let previous = self.selected;
-            self.selected = Some(selected.min(self.rows.len() - 1));
+            self.selected = Some(selected);
             if self.selected != previous {
                 self.retry_failed_signatures();
             }
@@ -2148,7 +2293,10 @@ impl App {
     }
 
     fn first_selectable(&self) -> Option<usize> {
-        (!self.rows.is_empty()).then_some(0)
+        (0..self.history_len()).find_map(|index| match self.history_entry(index) {
+            Some(HistoryEntry::Commit(index)) => Some(index),
+            Some(HistoryEntry::Segment { .. }) | None => None,
+        })
     }
 
     fn update_worktree_head_descendants(&mut self) {
@@ -2512,11 +2660,34 @@ impl App {
     }
 
     fn last_selectable(&self) -> Option<usize> {
-        self.rows.len().checked_sub(1)
+        (0..self.history_len())
+            .rev()
+            .find_map(|index| match self.history_entry(index) {
+                Some(HistoryEntry::Commit(index)) => Some(index),
+                Some(HistoryEntry::Segment { .. }) | None => None,
+            })
     }
 
-    fn nearest_selectable(&self, target: usize, _down: bool) -> Option<usize> {
-        (!self.rows.is_empty()).then_some(target.min(self.rows.len() - 1))
+    fn nearest_selectable(&self, target: usize, down: bool) -> Option<usize> {
+        let len = self.history_len();
+        if len == 0 {
+            return None;
+        }
+        let target = target.min(len - 1);
+        let entry = |index| match self.history_entry(index) {
+            Some(HistoryEntry::Commit(index)) => Some(index),
+            Some(HistoryEntry::Segment { .. }) | None => None,
+        };
+        if down {
+            (target..len)
+                .find_map(entry)
+                .or_else(|| (0..target).rev().find_map(entry))
+        } else {
+            (0..=target)
+                .rev()
+                .find_map(entry)
+                .or_else(|| (target + 1..len).find_map(entry))
+        }
     }
 
     fn retry_failed_signatures(&mut self) {
@@ -2537,13 +2708,16 @@ impl App {
     }
 
     pub(crate) fn ensure_visible(&mut self) {
-        let Some(selected) = self.selected else { return };
+        let Some(selected) = self.selected_history_index() else {
+            return;
+        };
         let height = self.viewport_rows.max(1);
         if selected < self.offset {
             self.offset = selected;
         } else if selected >= self.offset.saturating_add(height) {
             self.offset = selected + 1 - height;
         }
+        self.offset = self.offset.min(self.history_len().saturating_sub(height));
     }
 
     pub(crate) fn center_initial_selection(&mut self) {
@@ -2557,6 +2731,13 @@ impl App {
             return;
         };
         self.selected = Some(selected);
+        if self.alignment == Alignment::Compressed
+            && !self.compressed_history_suspended()
+            && self.history_index(selected).is_none()
+        {
+            self.compressed_anchor = Some(self.rows[selected].id);
+            self.rebuild_compressed_history();
+        }
         self.center_selection();
         if matches!(self.state, State::Complete | State::Cancelled) {
             self.pending_initial_selection = None;
@@ -2564,11 +2745,13 @@ impl App {
     }
 
     fn center_selection(&mut self) {
-        let Some(selected) = self.selected else { return };
+        let Some(selected) = self.selected_history_index() else {
+            return;
+        };
         let height = self.viewport_rows.max(1);
         self.offset = selected
             .saturating_sub(height / 2)
-            .min(self.rows.len().saturating_sub(height));
+            .min(self.history_len().saturating_sub(height));
     }
 
     pub(crate) fn set_horizontal_bounds(&mut self, page: usize, max: usize) {
@@ -2676,6 +2859,88 @@ impl App {
     }
 }
 
+impl CompressedHistory {
+    fn new(rows: &[SharedCommitRow], view_tips: &HashSet<ObjectId>, selected: Option<ObjectId>) -> Self {
+        let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
+        let mut children = vec![(0usize, 0usize); rows.len()];
+        for (child, row) in rows.iter().enumerate() {
+            for parent in &row.parent_ids {
+                if let Some(parent) = positions.get(parent) {
+                    children[*parent] = (children[*parent].0 + 1, child);
+                }
+            }
+        }
+        let is_anchor = |id| view_tips.contains(&id) || selected == Some(id);
+        let mut representatives = Vec::new();
+        let mut counts = Vec::new();
+        let mut group_of = vec![usize::MAX; rows.len()];
+        for (index, row) in rows.iter().enumerate() {
+            let joined = (!is_anchor(row.id))
+                .then_some(children[index])
+                .and_then(|(count, child)| match count {
+                    1 if !is_anchor(rows[child].id)
+                        && rows[child].parent_ids.len() == 1
+                        && rows[child].parent_ids[0] == row.id
+                        && group_of[child] != usize::MAX =>
+                    {
+                        Some(group_of[child])
+                    }
+                    _ => None,
+                });
+            let group = joined.unwrap_or_else(|| {
+                representatives.push(index);
+                counts.push(0);
+                representatives.len() - 1
+            });
+            group_of[index] = group;
+            counts[group] += 1;
+        }
+
+        let representative_ids: Vec<_> = representatives.iter().map(|index| rows[*index].id).collect();
+        let mut parents: Vec<ParentIds> = representatives.iter().map(|_| ParentIds::new()).collect();
+        for (member, row) in rows.iter().enumerate() {
+            let group = group_of[member];
+            for parent in &row.parent_ids {
+                let Some(parent_index) = positions.get(parent) else {
+                    continue;
+                };
+                let parent_group = group_of[*parent_index];
+                if parent_group != group && !parents[group].contains(&representative_ids[parent_group]) {
+                    parents[group].push(representative_ids[parent_group]);
+                }
+            }
+        }
+
+        let mut compact_rows = Vec::with_capacity(representatives.len());
+        let mut entries = Vec::with_capacity(representatives.len());
+        for (group, representative) in representatives.into_iter().enumerate() {
+            let mut row = rows[representative].as_ref().clone();
+            row.parent_ids = std::mem::take(&mut parents[group]);
+            compact_rows.push(Arc::new(row));
+            entries.push(if is_anchor(rows[representative].id) {
+                HistoryEntry::Commit(representative)
+            } else {
+                HistoryEntry::Segment { count: counts[group] }
+            });
+        }
+        let graph = Graph::new(&compact_rows);
+        let display_indices = entries
+            .iter()
+            .enumerate()
+            .filter_map(|(display, entry)| match entry {
+                HistoryEntry::Commit(canonical) => Some((*canonical, display)),
+                HistoryEntry::Segment { .. } => None,
+            })
+            .collect();
+        CompressedHistory {
+            entries,
+            display_indices,
+            rows: compact_rows,
+            graph,
+        }
+    }
+}
+
 fn estimate_lane_width(rows: &[SharedCommitRow]) -> usize {
     let mut rows = rows.to_vec();
     let known: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
@@ -2772,6 +3037,15 @@ impl Graph {
     }
 
     fn render(&self, rows: &[SharedCommitRow], range: Range<usize>) -> RenderedLanes {
+        self.render_with_markers(rows, range, |_| '●')
+    }
+
+    fn render_with_markers(
+        &self,
+        rows: &[SharedCommitRow],
+        range: Range<usize>,
+        marker: impl Fn(usize) -> char,
+    ) -> RenderedLanes {
         let start = range.start.min(rows.len());
         let end = range.end.min(rows.len());
         if start >= end {
@@ -2788,7 +3062,12 @@ impl Graph {
         };
         for (index, row) in rows[checkpoint * CHECKPOINT_INTERVAL..end].iter().enumerate() {
             let index = checkpoint * CHECKPOINT_INTERVAL + index;
-            if let Some(range) = state.advance(row, (index >= start).then_some(&mut rendered.data)) {
+            if let Some(range) = state.advance_ids(
+                row.id,
+                row.parent_ids.iter().copied(),
+                (index >= start).then_some(&mut rendered.data),
+                marker(index),
+            ) {
                 rendered.ranges.push(range);
             }
         }
@@ -4330,6 +4609,129 @@ mod tests {
         assert_eq!(app.selected, Some(1));
     }
 
+    #[test]
+    fn compressed_history_retains_tips_and_selection_and_skips_segments() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(6)]);
+        app.select_commit(id(3));
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        assert_eq!(
+            (0..app.history_len())
+                .filter_map(|index| app.history_entry(index))
+                .collect::<Vec<_>>(),
+            [
+                HistoryEntry::Commit(0),
+                HistoryEntry::Segment { count: 2 },
+                HistoryEntry::Commit(3),
+                HistoryEntry::Segment { count: 2 },
+            ],
+            "linear commits between explicit anchors collapse into counted segments"
+        );
+        assert_eq!(
+            app.render_lanes(0..app.history_len()).iter().collect::<Vec<_>>(),
+            ["● ", "○ ", "● ", "○ "],
+            "segments reuse the canonical graph with a quieter ring marker"
+        );
+
+        app.update(Action::MoveUp);
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(6)));
+        app.update(Action::MoveDown);
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(3)),
+            "navigation crosses nonselectable segments"
+        );
+
+        app.select_commit(id(2));
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(2)));
+        assert!(
+            app.selected_history_index().is_some(),
+            "a programmatic jump rebuilds compression around the destination"
+        );
+    }
+
+    #[test]
+    fn compressed_history_keeps_ancestor_tips_and_merge_topology() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(7, &[6, 5]),
+            row_with_parents(6, &[4]),
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[2]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(7), id(2)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        let entries: Vec<_> = (0..app.history_len())
+            .filter_map(|index| app.history_entry(index))
+            .collect();
+        assert_eq!(entries.first(), Some(&HistoryEntry::Commit(0)));
+        assert!(
+            entries.contains(&HistoryEntry::Commit(5)),
+            "an explicit ancestor tip remains visible even though it is not a graph leaf"
+        );
+        assert_eq!(
+            entries
+                .iter()
+                .filter_map(|entry| match entry {
+                    HistoryEntry::Segment { count } => Some(*count),
+                    HistoryEntry::Commit(_) => None,
+                })
+                .sum::<usize>(),
+            5,
+            "every non-anchor commit is represented exactly once"
+        );
+        let lanes = app.render_lanes(0..app.history_len());
+        assert!(
+            lanes
+                .iter()
+                .any(|lane| lane.contains('╮') || lane.contains('╯') || lane.contains('─')),
+            "the quotient graph preserves merge branches"
+        );
+    }
+
+    #[test]
+    fn compressed_history_temporarily_expands_for_target_selection() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(4)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        assert_eq!(app.history_len(), 2);
+
+        app.reachability_anchor = Some(id(4));
+        app.compute_reachable_rows();
+        assert_eq!(
+            app.history_len(),
+            app.rows.len(),
+            "target selection uses the full history"
+        );
+        app.clear_reachability_selection();
+        assert_eq!(app.history_len(), 2, "leaving target selection restores compression");
+    }
+
     #[test]
     fn hidden_boundary_rows_are_selectable_for_inspection_and_independent_edits() {
         let mut app = App::new(4);
@@ -4606,6 +5008,8 @@ mod tests {
         app.update(Action::ToggleAlign);
         assert_eq!(app.alignment, Alignment::None);
         app.update(Action::ToggleAlign);
+        assert_eq!(app.alignment, Alignment::Compressed);
+        app.update(Action::ToggleAlign);
         assert_eq!(app.alignment, Alignment::Title);
     }
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 3672c7cc2b0..9b142bddd26 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -905,6 +905,7 @@ fn event_loop(
     );
 
     let mut app = App::new(1);
+    app.set_view_tips(&ref_snapshot.view_tips);
     app.set_worktree_head_unborn(worktree_head_unborn);
     app.set_worktree_branch(current_worktree_branch(&ref_snapshot));
     app.commit_pane_background = commit_pane_background;
@@ -3223,24 +3224,28 @@ fn draw(
         focused,
         filesystem_responses.has_queued_frame(),
     );
+    if let Some((_, changes)) = worktree_changes.as_ref() {
+        app.set_worktree_conflicted(changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
+    }
     app.viewport_rows = app.viewport_rows.min(render_rows.max(1));
     app.ensure_visible();
-    let start = app.offset.min(app.rows.len());
-    let end = start.saturating_add(render_rows).min(app.rows.len());
+    let start = app.offset.min(app.history_len());
+    let end = start.saturating_add(render_rows).min(app.history_len());
+    let visible_indices = app.visible_history_indices(start..end);
     let repository_fill_allowed = !app.has_rebase_conflict();
-    let notes_to_load: Vec<_> = app.rows[start..end]
+    let notes_to_load: Vec<_> = visible_indices
         .iter()
-        .map(|row| row.id)
+        .map(|index| app.rows[*index].id)
         .filter(|id| repository_fill_allowed && !app.notes_loaded(*id))
         .collect();
-    let enrichments_to_load: Vec<_> = app.rows[start..end]
+    let enrichments_to_load: Vec<_> = visible_indices
         .iter()
-        .map(|row| row.id)
+        .map(|index| app.rows[*index].id)
         .filter(|id| repository_fill_allowed && !app.enrichment_loaded(*id))
         .collect();
-    let tree_enrichments_to_load: Vec<_> = app.rows[start..end]
+    let tree_enrichments_to_load: Vec<_> = visible_indices
         .iter()
-        .map(|row| row.id)
+        .map(|index| app.rows[*index].id)
         .filter(|id| repository_fill_allowed && !app.tree_enrichment_loaded(*id))
         .collect();
     let changes_visible = app.changes_visible();
@@ -3318,7 +3323,7 @@ fn draw(
     if !notes_to_load.is_empty()
         || !enrichments_to_load.is_empty()
         || !tree_enrichments_to_load.is_empty()
-        || app.rows[start..end].iter().any(|row| !row.metadata_loaded)
+        || visible_indices.iter().any(|index| !app.rows[*index].metadata_loaded)
         || message_to_load.is_some()
         || tree_changes_to_load.is_some()
         || worktree_changes_to_load
@@ -3378,14 +3383,6 @@ fn draw(
                 }
             }
         }
-        for index in start..end {
-            if app.rows[index].metadata_loaded {
-                continue;
-            }
-            let (metadata, attributions) = history::load_metadata(repository, app.rows[index].id, authors)
-                .context("could not load visible commit")?;
-            app.set_metadata(index, metadata, attributions);
-        }
         if let Some(id) = message_to_load {
             *commit_message = Some((id, load_commit_message(repository, id)?));
         }
@@ -3429,6 +3426,7 @@ fn draw(
                     {
                         app.worktree_changes.error = None;
                     }
+                    app.set_worktree_conflicted(loaded.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
                     restore_change_selection(&mut app.worktree_changes, &loaded, worktree_selection);
                     *worktree_changes = Some((0, loaded));
                 }
@@ -3443,6 +3441,16 @@ fn draw(
                 }
             }
         }
+        let start = app.offset.min(app.history_len());
+        let end = start.saturating_add(render_rows).min(app.history_len());
+        for index in app.visible_history_indices(start..end) {
+            if app.rows[index].metadata_loaded {
+                continue;
+            }
+            let (metadata, attributions) = history::load_metadata(repository, app.rows[index].id, authors)
+                .context("could not load visible commit")?;
+            app.set_metadata(index, metadata, attributions);
+        }
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
     let tree_changes = tree_changes.as_ref().map(|(_, changes)| changes);
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 530d5b07aac..87b843109c8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -11,8 +11,8 @@ use crate::{
     BuiltInDiff,
     app::{
         Alignment as HistoryAlignment, App, AttributionKind, ChangeGroup, ChangeKind, ChangePane, Changes,
-        ChangesLayout, ChangesMode, CommitRow, CopyKind, DateMode, IdMode, NameMode, Notice, NoticeKind, RefMode,
-        SelectionRelation, SignatureState, State,
+        ChangesLayout, ChangesMode, CommitRow, CopyKind, DateMode, HistoryEntry, IdMode, NameMode, Notice, NoticeKind,
+        RefMode, SelectionRelation, SignatureState, State,
     },
     history::{DecorationKind, Decorations},
 };
@@ -509,16 +509,28 @@ pub(crate) fn draw_with_worktree(
         .max(1) as usize;
     app.center_initial_selection();
     app.ensure_visible();
-    let start = app.offset.min(app.rows.len());
-    let render_end = start.saturating_add(body.height as usize).min(app.rows.len());
-    let visible_rows = &app.rows[start..render_end];
-    let has_verifiable_signatures = visible_rows.iter().enumerate().any(|(index, row)| {
-        !app.is_row_hidden(start + index)
-            && matches!(row.signature, SignatureState::Unverified | SignatureState::Verifying)
+    let start = app.offset.min(app.history_len());
+    let render_end = start.saturating_add(body.height as usize).min(app.history_len());
+    let visible_entries: Vec<_> = (start..render_end)
+        .filter_map(|index| app.history_entry(index))
+        .collect();
+    let has_verifiable_signatures = visible_entries.iter().any(|entry| {
+        let HistoryEntry::Commit(index) = entry else {
+            return false;
+        };
+        !app.is_row_hidden(*index)
+            && matches!(
+                app.rows[*index].signature,
+                SignatureState::Unverified | SignatureState::Verifying
+            )
     });
     let lanes = app.render_lanes(start..render_end);
-    let enrichment_gutter = visible_rows
+    let enrichment_gutter = visible_entries
         .iter()
+        .filter_map(|entry| match entry {
+            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
+            HistoryEntry::Segment { .. } => None,
+        })
         .map(|row| {
             Line::raw(crate::enrich::marker(
                 app.todo(row.id),
@@ -529,13 +541,24 @@ pub(crate) fn draw_with_worktree(
         })
         .max()
         .unwrap_or_default() as u16;
-    let change_id_gutter = visible_rows
+    let has_duplicate_change_id = visible_entries
         .iter()
-        .any(|row| app.has_duplicate_change_id(row.id))
-        .then(|| Line::raw("👯‍♂️").width() as u16)
-        .unwrap_or_default();
-    let conflict_gutter = visible_rows
+        .filter_map(|entry| match entry {
+            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
+            HistoryEntry::Segment { .. } => None,
+        })
+        .any(|row| app.has_duplicate_change_id(row.id));
+    let change_id_gutter = if has_duplicate_change_id {
+        Line::raw("👯‍♂️").width() as u16
+    } else {
+        0
+    };
+    let has_conflict = visible_entries
         .iter()
+        .filter_map(|entry| match entry {
+            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
+            HistoryEntry::Segment { .. } => None,
+        })
         .any(|row| {
             let head = decorations.get(&row.id).is_some_and(|decorations| {
                 decorations
@@ -543,9 +566,12 @@ pub(crate) fn draw_with_worktree(
                     .any(|decoration| decoration.kind == DecorationKind::Head)
             });
             app.conflict_marker(row.id, head)
-        })
-        .then(|| Line::raw("💥").width() as u16)
-        .unwrap_or_default();
+        });
+    let conflict_gutter = if has_conflict {
+        Line::raw("💥").width() as u16
+    } else {
+        0
+    };
     let status_x = body
         .x
         .saturating_add(enrichment_gutter)
@@ -581,11 +607,15 @@ pub(crate) fn draw_with_worktree(
     let show_author_name = copy_feedback == Some(CopyKind::Author) || name_mode != NameMode::None;
     let show_trailers = name_mode == NameMode::All && app.show_trailers;
     let ref_mode = app.ref_mode;
-    let selected = app.selected;
-    let metadata_columns: Vec<_> = visible_rows
+    let selected = app.selected_history_index();
+    let metadata_columns: Vec<_> = visible_entries
         .iter()
         .enumerate()
-        .map(|(index, row)| {
+        .map(|(index, entry)| {
+            let HistoryEntry::Commit(row_index) = entry else {
+                return None;
+            };
+            let row = &app.rows[*row_index];
             let row_selected = selected == Some(start + index);
             let title = row_selected.then(|| app.note(row.id)).flatten().map_or_else(
                 || app.title(row),
@@ -632,16 +662,20 @@ pub(crate) fn draw_with_worktree(
                     }
                 }
             }
-            metadata
+            Some(metadata)
         })
         .collect();
     let title_column = lanes
         .iter()
         .zip(&metadata_columns)
-        .map(|(lane, metadata)| lane.chars().count().saturating_add(metadata.prefix_width()))
+        .filter_map(|(lane, metadata)| {
+            metadata
+                .as_ref()
+                .map(|metadata| lane.chars().count().saturating_add(metadata.prefix_width()))
+        })
         .max()
         .unwrap_or_default();
-    let column_widths = metadata_columns.iter().fold([0; 5], |mut widths, metadata| {
+    let column_widths = metadata_columns.iter().flatten().fold([0; 5], |mut widths, metadata| {
         for (width, field) in widths.iter_mut().zip(&metadata.fields[..5]) {
             *width = (*width).max(field.width());
         }
@@ -650,34 +684,41 @@ pub(crate) fn draw_with_worktree(
     let metadata: Vec<_> = metadata_columns
         .into_iter()
         .enumerate()
-        .map(|(index, metadata)| match alignment {
-            HistoryAlignment::None => (metadata.into_line(), 0),
-            HistoryAlignment::Title => {
-                let lane_width = lanes.lane(index).chars().count();
-                (
-                    metadata.align_title(title_column.saturating_sub(lane_width)),
-                    lane_width,
-                )
-            }
-            HistoryAlignment::Columns => (metadata.align_columns(column_widths), max_lane_width),
+        .map(|(index, metadata)| {
+            metadata.map(|metadata| match alignment {
+                HistoryAlignment::None => (metadata.into_line(), 0),
+                HistoryAlignment::Title | HistoryAlignment::Compressed => {
+                    let lane_width = lanes.lane(index).chars().count();
+                    (
+                        metadata.align_title(title_column.saturating_sub(lane_width)),
+                        lane_width,
+                    )
+                }
+                HistoryAlignment::Columns => (metadata.align_columns(column_widths), max_lane_width),
+            })
         })
         .collect();
-    let max_offset = match alignment {
-        HistoryAlignment::None => lanes
-            .iter()
-            .zip(&metadata)
-            .map(|(lane, (metadata, _))| lane.chars().count().saturating_add(metadata.width()))
-            .max()
-            .unwrap_or_default()
-            .saturating_sub(content.width as usize),
-        HistoryAlignment::Title | HistoryAlignment::Columns => metadata
-            .iter()
-            .map(|(metadata, metadata_x)| metadata_x.saturating_add(metadata.width()))
-            .max()
-            .unwrap_or_default()
-            .saturating_sub(content.width as usize),
-    }
-    .min(u16::MAX as usize);
+    let max_offset = visible_entries
+        .iter()
+        .enumerate()
+        .map(|(index, entry)| match (entry, &metadata[index]) {
+            (HistoryEntry::Segment { count }, _) => lanes
+                .lane(index)
+                .chars()
+                .count()
+                .saturating_add(format!("[{count}]").chars().count()),
+            (HistoryEntry::Commit(_), Some((metadata, metadata_x))) => match alignment {
+                HistoryAlignment::None => lanes.lane(index).chars().count().saturating_add(metadata.width()),
+                HistoryAlignment::Title | HistoryAlignment::Columns | HistoryAlignment::Compressed => {
+                    metadata_x.saturating_add(metadata.width())
+                }
+            },
+            (HistoryEntry::Commit(_), None) => 0,
+        })
+        .max()
+        .unwrap_or_default()
+        .saturating_sub(content.width as usize)
+        .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
     let selection_info = selection_info_line(
         app.changes_visible()
@@ -689,39 +730,64 @@ pub(crate) fn draw_with_worktree(
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
 
-    let rows = visible_rows
+    let rows = visible_entries
         .iter()
         .enumerate()
-        .map(|(index, row)| (row.id, body.y.saturating_add(index as u16)))
+        .filter_map(|(index, entry)| match entry {
+            HistoryEntry::Commit(row_index) => Some((app.rows[*row_index].id, body.y.saturating_add(index as u16))),
+            HistoryEntry::Segment { .. } => None,
+        })
         .collect();
-    for (index, (metadata, metadata_x)) in metadata.into_iter().enumerate() {
+    for (index, metadata) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
         let y = body.y.saturating_add(index as u16);
-        let selected = app.selected == Some(start + index);
-        let head = decorations.get(&visible_rows[index].id).is_some_and(|decorations| {
+        let row_area = Rect::new(content.x, y, content.width, 1);
+        let row_index = match visible_entries[index] {
+            HistoryEntry::Commit(index) => index,
+            HistoryEntry::Segment { count } => {
+                frame.render_widget(
+                    Paragraph::new(format!("{lane}[{count}]")).scroll((0, horizontal_offset as u16)),
+                    row_area,
+                );
+                color_graph(
+                    frame,
+                    row_area,
+                    lane,
+                    horizontal_offset,
+                    None,
+                    SignatureState::Unsigned,
+                    None,
+                );
+                continue;
+            }
+        };
+        let row = &app.rows[row_index];
+        let (metadata, metadata_x) = metadata.expect("commit history entries have metadata");
+        let selected = app.selected == Some(row_index);
+        let head = decorations.get(&row.id).is_some_and(|decorations| {
             decorations
                 .iter()
                 .any(|decoration| decoration.kind == DecorationKind::Head)
         });
-        let attached_head = decorations.get(&visible_rows[index].id).is_some_and(|decorations| {
+        let attached_head = decorations.get(&row.id).is_some_and(|decorations| {
             decorations
                 .iter()
                 .any(|decoration| decoration.kind == DecorationKind::CurrentWorktreeBranch)
         });
-        let head_has_descendants = app.worktree_head_has_descendants(visible_rows[index].id);
+        let head_has_descendants = app.worktree_head_has_descendants(row.id);
         let head_state = head.then_some(HeadState {
             has_descendants: head_has_descendants,
             attached: attached_head,
         });
         let metadata_width = metadata.width();
-        let hidden_branch_behind = app.hidden_branch_behind(visible_rows[index].id);
+        let hidden_branch_behind = app.hidden_branch_behind(row.id);
         let line_width = match alignment {
             HistoryAlignment::None => lane
                 .chars()
                 .count()
                 .saturating_add(metadata_width)
                 .saturating_sub(horizontal_offset),
-            HistoryAlignment::Title | HistoryAlignment::Columns => metadata_x
+            HistoryAlignment::Title | HistoryAlignment::Columns | HistoryAlignment::Compressed => metadata_x
                 .saturating_add(metadata_width)
                 .saturating_sub(horizontal_offset),
         };
@@ -744,10 +810,10 @@ pub(crate) fn draw_with_worktree(
                 (marker, x, width)
             })
         });
-        let signature_color = signature_color(visible_rows[index].signature);
+        let signature_color = signature_color(row.signature);
         let highlight = if selected && app.show_selection_tail {
             Some(signature_color)
-        } else if compared_parent == Some(visible_rows[index].id) {
+        } else if compared_parent == Some(row.id) {
             Some(COMPARED_PARENT_COLOR)
         } else {
             None
@@ -755,19 +821,16 @@ pub(crate) fn draw_with_worktree(
         let style = highlight.map_or_else(Style::default, |highlight| {
             color(highlight).add_modifier(Modifier::REVERSED)
         });
-        let conflict = app.conflict_marker(visible_rows[index].id, head);
-        let enrichment_marker = crate::enrich::marker(
-            app.todo(visible_rows[index].id),
-            app.note(visible_rows[index].id).is_some(),
-            app.checks_pass(visible_rows[index].id),
-        );
+        let conflict = app.conflict_marker(row.id, head);
+        let enrichment_marker =
+            crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some(), app.checks_pass(row.id));
         if !enrichment_marker.is_empty() {
             frame.render_widget(
                 Paragraph::new(enrichment_marker),
                 Rect::new(body.x, y, enrichment_gutter, 1),
             );
         }
-        if app.has_duplicate_change_id(visible_rows[index].id) {
+        if app.has_duplicate_change_id(row.id) {
             frame.render_widget(
                 Paragraph::new("👯‍♂️"),
                 Rect::new(body.x.saturating_add(enrichment_gutter), y, change_id_gutter, 1),
@@ -798,7 +861,6 @@ pub(crate) fn draw_with_worktree(
             Rect::new(status_x, y, body.right().saturating_sub(status_x).min(2), 1),
         );
 
-        let row_area = Rect::new(content.x, y, content.width, 1);
         let mut spans = Vec::with_capacity(metadata.spans.len() + 2);
         spans.push(Span::styled(lane, style));
         if alignment != HistoryAlignment::None {
@@ -815,7 +877,7 @@ pub(crate) fn draw_with_worktree(
             lane,
             horizontal_offset,
             highlight,
-            visible_rows[index].signature,
+            row.signature,
             head_state,
         );
         if selected && app.show_selection_tail && body.width > 0 {
@@ -846,12 +908,12 @@ pub(crate) fn draw_with_worktree(
             }
             buffer[(marker_x, y)].set_symbol(" ").set_style(style);
         }
-        if !app.is_row_reachable(start + index) {
+        if !app.is_row_reachable(row_index) {
             for x in body.x..body.right() {
                 frame.buffer_mut()[(x, y)].set_style(Style::default().add_modifier(Modifier::DIM));
             }
         }
-        if app.is_row_hidden(start + index) {
+        if app.is_row_hidden(row_index) {
             for x in body.x..body.right() {
                 frame.buffer_mut()[(x, y)]
                     .set_fg(Color::Reset)
@@ -1256,6 +1318,7 @@ pub(crate) fn draw_with_worktree(
             HistoryAlignment::Title => ("[ title", true),
             HistoryAlignment::Columns => ("[ columns", true),
             HistoryAlignment::None => ("[ align", false),
+            HistoryAlignment::Compressed => ("[ compressed", true),
         };
         items.push(toggle(alignment, enabled));
         items.push(Span::raw(" · "));
@@ -6938,6 +7001,63 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn renders_compressed_segments_without_commit_metadata_or_row_identity() -> Result<(), Box<dyn std::error::Error>> {
+        let ids = [1, 2, 3, 4].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let mut app = App::new(2);
+        app.extend_commits(
+            ids.iter()
+                .enumerate()
+                .map(|(index, id)| Commit {
+                    id: *id,
+                    parent_ids: ids.get(index + 1).copied().into_iter().collect(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"Byron", b"byron@example.com"),
+                    attributions: 0..0,
+                    title: if index == 0 { "tip" } else { "hidden" }.into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.set_view_tips(&ids[..1]);
+        for _ in 0..3 {
+            app.update(Action::ToggleAlign);
+        }
+
+        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+        let mut layout = None;
+        let decorations = Decorations::new();
+        let mailmap = gix::mailmap::Snapshot::default();
+        terminal.draw(|frame| {
+            layout = Some(draw_with_worktree(
+                frame,
+                &mut app,
+                &decorations,
+                &mailmap,
+                None,
+                None,
+                None,
+            ));
+        })?;
+
+        assert!(
+            rendered_line(&terminal, 0).contains("tip"),
+            "the retained tip keeps its metadata"
+        );
+        assert_eq!(rendered_line(&terminal, 1).trim(), "○ [3]");
+        assert_eq!(
+            layout.expect("drawing returns its layout").rows,
+            vec![(ids[0], 0)],
+            "segments are not interactive or animated commit rows"
+        );
+        Ok(())
+    }
+
     fn rendered_row(terminal: &Terminal<TestBackend>) -> String {
         rendered_line(terminal, 0)
     }

From e6fb64e189757750030db8453f487eab92d20e5d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 11:09:53 +0200
Subject: [PATCH 241/282] fix: keep ref-tree pins symbolic and connected

Preserve selected symbolic ref names before peeling, and continue incremental refresh through cached ancestry when a pin makes it visible.
---
 gix-tix/src/history.rs  | 65 +++++++++++++++++++++++++++++++++++++++--
 gix-tix/src/ref_tree.rs | 28 ++++++++++++++++--
 2 files changed, 89 insertions(+), 4 deletions(-)

diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 665506e4897..a496b877a5c 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -681,9 +681,10 @@ impl HistoryGraph {
             let id = self.id(index);
             let commit = &self.commits[index.as_usize()];
             let was_stored = commit.state & NODE_STORED != 0;
-            let stop =
-                commit.state & NODE_COMPLETE != 0 && (delta & EXPAND == 0 || was_stored && !expand.contains(&id));
             let should_store = delta & (VISIBLE | EXPAND) != 0 && !was_stored;
+            let stop = !should_store
+                && commit.state & NODE_COMPLETE != 0
+                && (delta & EXPAND == 0 || was_stored && !expand.contains(&id));
             let parent_indices = self.parents(index).to_vec();
             let parent_ids = self.parent_ids(index);
             let generation = commit.generation();
@@ -2618,6 +2619,66 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn refresh_walks_cached_tracking_ancestry_when_a_symbolic_pin_makes_it_visible() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let main = crate::test_repository::open(fixture.path())?
+            .rev_parse_single("main")?
+            .detach();
+        let merged = crate::test_repository::open(fixture.path())?
+            .rev_parse_single("merged")?
+            .detach();
+        for args in [
+            &["config", "remote.origin.url", "https://example.com/repo"][..],
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"][..],
+            &["config", "branch.topic.remote", "origin"][..],
+            &["config", "branch.topic.merge", "refs/heads/main"][..],
+            &["update-ref", "refs/remotes/origin/main", &main.to_hex().to_string()][..],
+        ] {
+            let status = Command::new("git").current_dir(fixture.path()).args(args).status()?;
+            assert!(status.success(), "git configures a tracking branch");
+        }
+        let events = loaded(fixture.path(), &["topic"], &[])?;
+        let mut graph = events
+            .into_iter()
+            .find_map(|event| match event {
+                Event::Complete(graph) => Some(graph),
+                _ => None,
+            })
+            .expect("history loading returns the persistent graph");
+        let cached = graph.index(main).expect("the tracking tip was scheduled");
+        assert!(
+            graph.commits[cached.as_usize()].state & NODE_COMPLETE != 0
+                && graph.commits[cached.as_usize()].state & NODE_STORED == 0,
+            "the tracking tip is cached without being visible"
+        );
+
+        assert!(
+            Command::new("git")
+                .current_dir(fixture.path())
+                .args(["switch", "-q", "topic"])
+                .status()?
+                .success(),
+            "git moves HEAD away from the pin target"
+        );
+        let repo = crate::test_repository::open(fixture.path())?;
+        crate::edit::time_travel::create_or_reuse_pin(
+            &repo,
+            gix::refs::Target::Symbolic("refs/remotes/origin/main".try_into()?),
+            main,
+            "test symbolic ref-tree pin",
+        )?;
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let refresh = graph.refresh(&repo, &["topic".into()], &[], false, &HashSet::new(), &authors)?;
+        let refreshed: HashSet<_> = refresh.commits.rows.iter().map(|row| row.id).collect();
+        assert!(
+            refreshed.contains(&main) && refreshed.contains(&merged),
+            "a newly visible cached tip is loaded together with its missing ancestry: {refreshed:?}"
+        );
+        Ok(())
+    }
+
     #[test]
     fn hidden_history_keeps_tracking_relations_complete_and_can_be_expanded() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 151cae8fcf9..438d1b5932a 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -822,7 +822,8 @@ pub(crate) fn pin_references(
             Err(err) if crate::history::is_missing_ref(&*err) => continue,
             Err(err) => return Err(anyhow::anyhow!("could not read reference to pin: {err}")),
         };
-        let Some(kind) = pinnable_kind(crate::history::decoration_kind(reference.name().as_bstr())) else {
+        let name = reference.name().to_owned();
+        let Some(kind) = pinnable_kind(crate::history::decoration_kind(name.as_bstr())) else {
             continue;
         };
         if !kinds.contains(&kind) {
@@ -834,7 +835,7 @@ pub(crate) fn pin_references(
         if target.as_ref() != id {
             continue;
         }
-        names.push(reference.name().to_owned());
+        names.push(name);
     }
     names.sort();
     names.dedup();
@@ -2331,6 +2332,18 @@ mod tests {
                 "prepare ref-tree pin test",
             )?;
         }
+        assert!(
+            std::process::Command::new("git")
+                .current_dir(fixture.path())
+                .args([
+                    "symbolic-ref",
+                    "refs/remotes/origin/old-head",
+                    "refs/remotes/origin/old"
+                ])
+                .status()?
+                .success(),
+            "git creates a symbolic remote alias"
+        );
 
         let pins = pin_references(&repo, old, &[DecorationKind::Local, DecorationKind::Remote])?;
         let targets: Vec<_> = pins
@@ -2339,7 +2352,18 @@ mod tests {
             .collect();
         assert!(targets.contains(&b"refs/heads/old".as_bstr().to_owned()));
         assert!(targets.contains(&b"refs/remotes/origin/old".as_bstr().to_owned()));
+        assert!(
+            targets.contains(&b"refs/remotes/origin/old-head".as_bstr().to_owned()),
+            "the pin retains the selected symbolic reference instead of its referent"
+        );
         assert!(!targets.contains(&b"refs/tags/old".as_bstr().to_owned()));
+        for pin in &pins {
+            assert_eq!(
+                repo.find_reference(pin.name.as_ref())?.target().into_owned(),
+                pin.target,
+                "the stored pin itself remains symbolic"
+            );
+        }
         assert!(
             crate::history::snapshot(&repo, &[], &[], false)?
                 .view_tips

From 5a65398786c180189d92c898954231a6ce23e107 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 12:58:32 +0200
Subject: [PATCH 242/282] feat: make compressed Tix history interactive

Retain graph endpoints, junctions, and hidden boundaries as selectable commits. Let synthetic linear segments participate in navigation and expand in place while preserving modal target eligibility and refresh state.
---
 gix-tix/spec.md    |  18 +-
 gix-tix/src/app.rs | 723 ++++++++++++++++++++++++++++++++++++++-------
 gix-tix/src/ui.rs  | 172 +++++++----
 3 files changed, 751 insertions(+), 162 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c0c3d152b74..97c5a7b37bc 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -409,13 +409,17 @@ Alignment uses only rows in the current viewport to determine widths and starts
 in title mode. Horizontal navigation pans the complete padded row in title and
 full-column alignment so clipped fields can be reached.
 
-Compressed history keeps the visible reference, pin, and worktree tips plus the
-commit selected when compression begins. Every maximal hidden segment is shown
-as a nonselectable hollow node followed by its exact commit count, such as
-`○ [12]`; navigation skips these summaries. Retained commits use title
-alignment, and cycling `[` again restores the normal title-aligned history.
-Review, rewrite-target, and rebase-conflict selection temporarily expand the
-history without leaving compressed mode.
+Compressed history keeps the visible reference, pin, and worktree tips, the
+commit selected when compression begins, every graph endpoint or junction, and
+every hidden boundary as full, selectable commit rows. Each remaining maximal
+linear segment is represented by a selectable hollow node followed by its exact
+commit count, such as `○ [12]`. Pressing Enter on a summary expands that one
+segment in place; expansions accumulate until the display is the ordinary
+title-aligned history. Modal review and rewrite-target pickers retain the
+compressed projection so its points of interest remain available as targets,
+while conflict selection continues to show the full history. Leaving and
+re-entering compressed mode through the `[` cycle, or performing a full history
+reload, discards accumulated expansions.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index f44738c6cbd..cc63fc5a4e5 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -460,13 +460,15 @@ pub(crate) enum Alignment {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum HistoryEntry {
     Commit(usize),
-    Segment { count: usize },
+    Segment { representative: usize, count: usize },
 }
 
 #[derive(Debug)]
 struct CompressedHistory {
     entries: Vec<HistoryEntry>,
     display_indices: HashMap<usize, usize>,
+    member_indices: HashMap<ObjectId, usize>,
+    members: Vec<Vec<usize>>,
     rows: Vec<SharedCommitRow>,
     graph: Graph,
 }
@@ -503,6 +505,8 @@ pub(crate) struct App {
     view_tips: HashSet<ObjectId>,
     compressed_history: Option<CompressedHistory>,
     compressed_anchor: Option<ObjectId>,
+    compressed_segment: Option<ObjectId>,
+    compressed_expanded: HashSet<ObjectId>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
     test_lanes: Vec<String>,
@@ -608,6 +612,8 @@ impl App {
             view_tips: HashSet::new(),
             compressed_history: None,
             compressed_anchor: None,
+            compressed_segment: None,
+            compressed_expanded: HashSet::new(),
             attributions: Vec::new(),
             #[cfg(test)]
             test_lanes: Vec::new(),
@@ -712,7 +718,7 @@ impl App {
     }
 
     pub(crate) fn can_cycle_duplicate(&self) -> bool {
-        self.changes_focus.is_none() && self.next_duplicate().is_some()
+        self.changes_focus.is_none() && self.reachable_rows.is_none() && self.next_duplicate().is_some()
     }
 
     pub(crate) fn set_change_ids(&mut self, change_ids: HashMap<ObjectId, ChangeId>, duplicates: HashSet<ObjectId>) {
@@ -754,6 +760,8 @@ impl App {
             })
         } else if self.pending_rebase_conflict.is_some() {
             Some("rebase conflict · <enter> checkout for resolution · Esc cancel")
+        } else if self.selected_is_segment() && self.reachable_rows.is_some() {
+            Some("compressed segment · <enter> expand · Esc cancel")
         } else if self.review_return_selection_active() {
             Some("review return is missing · j/k select commit · <enter> finish detached · Esc cancel")
         } else if self.review_selection_active() {
@@ -808,11 +816,15 @@ impl App {
         self.view_tips.clear();
         self.view_tips.extend(tips.iter().copied());
         if self.alignment == Alignment::Compressed {
+            if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+                self.compressed_anchor = Some(id);
+            }
             self.rebuild_compressed_history();
         }
     }
 
     pub(crate) fn arm_rebase_conflict(&mut self, id: ObjectId) {
+        self.materialize_compressed_selection();
         tracing::warn!(
             commit_id = %id,
             "rebase suspended on conflict; press <enter> to checkout for resolution"
@@ -846,6 +858,7 @@ impl App {
     }
 
     pub(crate) fn arm_rebase_continuation(&mut self) {
+        self.materialize_compressed_selection();
         self.rebase_continuation_pending = true;
         self.ensure_visible();
     }
@@ -867,6 +880,9 @@ impl App {
         if self.worktree_conflicted == conflicted {
             return;
         }
+        if conflicted {
+            self.materialize_compressed_selection();
+        }
         self.worktree_conflicted = conflicted;
         if conflicted {
             self.ensure_visible();
@@ -1094,7 +1110,18 @@ impl App {
     }
 
     pub(crate) fn selected_history_index(&self) -> Option<usize> {
-        self.selected.and_then(|selected| self.history_index(selected))
+        self.selected
+            .and_then(|selected| self.history_index(selected))
+            .or_else(|| {
+                let history = self.active_compressed_history()?;
+                let selected = self.compressed_segment?;
+                let index = *history.member_indices.get(&selected)?;
+                matches!(history.entries[index], HistoryEntry::Segment { .. }).then_some(index)
+            })
+    }
+
+    pub(crate) fn selected_is_segment(&self) -> bool {
+        self.compressed_segment.is_some() && self.selected_history_index().is_some()
     }
 
     pub(crate) fn visible_history_indices(&self, range: Range<usize>) -> Vec<usize> {
@@ -1115,25 +1142,134 @@ impl App {
     }
 
     fn compressed_history_suspended(&self) -> bool {
-        self.pending_rebase_conflict.is_some()
-            || self.rebase_continuation_pending
-            || self.worktree_conflicted
-            || self.reachability_anchor.is_some()
-            || self.review_return.is_some()
-            || self.stack_insert_base.is_some()
-            || self.reachable_rows.is_some()
+        self.pending_rebase_conflict.is_some() || self.rebase_continuation_pending || self.worktree_conflicted
     }
 
     fn rebuild_compressed_history(&mut self) {
-        self.compressed_history = (self.graph.is_some() && !self.rows.is_empty())
-            .then(|| CompressedHistory::new(&self.rows, &self.view_tips, self.compressed_anchor));
+        let previous_display = self.selected_history_index();
+        self.compressed_expanded.retain(|id| self.all_rows.contains_key(id));
+        let history = (self.graph.is_some() && !self.rows.is_empty()).then(|| {
+            CompressedHistory::new(
+                &self.rows,
+                &self.view_tips,
+                &self.hidden_rows,
+                &self.compressed_expanded,
+                self.compressed_anchor,
+            )
+        });
+        let selection = self.compressed_segment.and_then(|id| {
+            let history = history.as_ref()?;
+            let display = *history.member_indices.get(&id)?;
+            history.entries.get(display).copied()
+        });
+        let fallback = previous_display.and_then(|display| {
+            let history = history.as_ref()?;
+            history
+                .entries
+                .get(display.min(history.entries.len().saturating_sub(1)))
+                .copied()
+        });
+        self.compressed_history = history;
+        if self.compressed_segment.is_some() {
+            match selection.or(fallback) {
+                Some(HistoryEntry::Commit(index)) => {
+                    self.selected = Some(index);
+                    self.compressed_segment = None;
+                }
+                Some(HistoryEntry::Segment { representative, .. }) => {
+                    self.selected = None;
+                    self.compressed_segment = self.rows.get(representative).map(|row| row.id);
+                }
+                None => {
+                    self.selected = (!self.rows.is_empty()).then_some(0);
+                    self.compressed_segment = None;
+                }
+            }
+        }
+    }
+
+    fn materialize_compressed_selection(&mut self) {
+        let Some(id) = self.compressed_segment.take() else {
+            return;
+        };
+        self.selected = self.rows.iter().position(|row| row.id == id);
+    }
+
+    pub(crate) fn history_entry_selectable(&self, display: usize) -> bool {
+        let selectable = |index| {
+            self.reachable_rows.as_ref().is_none()
+                || (self.is_row_reachable(index) && self.reachable_row_selectable(index))
+        };
+        match self.history_entry(display) {
+            Some(HistoryEntry::Commit(index)) => selectable(index),
+            Some(HistoryEntry::Segment { .. }) => self
+                .active_compressed_history()
+                .and_then(|history| history.members.get(display))
+                .is_some_and(|members| members.iter().copied().any(selectable)),
+            None => false,
+        }
+    }
+
+    fn select_history_index(&mut self, display: usize) {
+        if !self.history_entry_selectable(display) {
+            return;
+        }
+        match self.history_entry(display) {
+            Some(HistoryEntry::Commit(index)) => self.select(index),
+            Some(HistoryEntry::Segment { representative, .. }) => {
+                let id = self.rows[representative].id;
+                let changed = self.selected.is_some() || self.compressed_segment != Some(id);
+                self.selected = None;
+                self.compressed_segment = Some(id);
+                self.pending_initial_selection = None;
+                self.commit_expanded = false;
+                self.actions_expanded = false;
+                self.enrich_expanded = false;
+                if changed {
+                    self.retry_failed_signatures();
+                }
+                self.follow_tail = false;
+                self.ensure_visible();
+            }
+            None => {}
+        }
+    }
+
+    fn expand_selected_segment(&mut self) -> bool {
+        let Some(display) = self.selected_history_index() else {
+            return false;
+        };
+        let Some(HistoryEntry::Segment { .. }) = self.history_entry(display) else {
+            return false;
+        };
+        let Some(members) = self
+            .active_compressed_history()
+            .and_then(|history| history.members.get(display))
+            .cloned()
+        else {
+            return false;
+        };
+        let Some(selected) = members.iter().copied().find(|index| {
+            self.reachable_rows.as_ref().is_none()
+                || (self.is_row_reachable(*index) && self.reachable_row_selectable(*index))
+        }) else {
+            return false;
+        };
+        self.compressed_expanded
+            .extend(members.iter().map(|index| self.rows[*index].id));
+        self.compressed_segment = None;
+        self.rebuild_compressed_history();
+        self.select(selected);
+        true
     }
 
     fn restore_compressed_history_around_selection(&mut self) {
         if self.alignment != Alignment::Compressed {
             return;
         }
-        self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        if let Some(id) = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) {
+            self.compressed_anchor = Some(id);
+        }
         self.rebuild_compressed_history();
         self.ensure_visible();
     }
@@ -1255,6 +1391,7 @@ impl App {
             Action::MoveDownBy(distance) => self.move_reachable(distance, true),
             Action::CycleDuplicate => {
                 if self.changes_focus.is_none()
+                    && self.reachable_rows.is_none()
                     && let Some(selected) = self.next_duplicate()
                 {
                     self.select(selected);
@@ -1306,8 +1443,8 @@ impl App {
                 self.ensure_changes_visible();
             }
             Action::First => {
-                if let Some(index) = self.first_selectable() {
-                    self.select(index);
+                if let Some(index) = (0..self.history_len()).find(|index| self.history_entry_selectable(*index)) {
+                    self.select_history_index(index);
                 }
             }
             Action::Last if self.changes_focus.is_some() => {
@@ -1316,15 +1453,16 @@ impl App {
                 changes.error = None;
                 self.ensure_changes_visible();
             }
-            Action::Last if self.last_selectable().is_some() => {
-                self.pending_initial_selection = None;
-                let previous = self.selected;
-                self.selected = self.last_selectable();
-                if self.selected != previous {
-                    self.retry_failed_signatures();
+            Action::Last => {
+                if let Some(index) = (0..self.history_len())
+                    .rev()
+                    .find(|index| self.history_entry_selectable(*index))
+                {
+                    self.pending_initial_selection = None;
+                    self.select_history_index(index);
+                    self.follow_tail = self.state == State::Loading;
+                    self.ensure_visible();
                 }
-                self.follow_tail = self.state == State::Loading;
-                self.ensure_visible();
             }
             Action::ToggleDate => {
                 self.date_mode = match self.date_mode {
@@ -1357,9 +1495,9 @@ impl App {
             Action::ToggleTrailers => self.show_trailers = !self.show_trailers,
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
-            Action::ToggleCommitGroup => self.commit_expanded = !self.commit_expanded,
-            Action::ToggleActions => self.actions_expanded = !self.actions_expanded,
-            Action::ToggleEnrich => self.enrich_expanded = !self.enrich_expanded,
+            Action::ToggleCommitGroup if !self.selected_is_segment() => self.commit_expanded = !self.commit_expanded,
+            Action::ToggleActions if !self.selected_is_segment() => self.actions_expanded = !self.actions_expanded,
+            Action::ToggleEnrich if !self.selected_is_segment() => self.enrich_expanded = !self.enrich_expanded,
             Action::ToggleInformation => self.information_expanded = !self.information_expanded,
             Action::CycleRefs => {
                 self.ref_mode = match self.ref_mode {
@@ -1376,14 +1514,30 @@ impl App {
                 }
             },
             Action::Refresh if matches!(self.state, State::Complete | State::Cancelled) => {
+                self.materialize_compressed_selection();
+                self.compressed_expanded.clear();
+                self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+                if self.alignment == Alignment::Compressed {
+                    self.rebuild_compressed_history();
+                }
                 return vec![Effect::Reload(self.show_hidden)];
             }
             Action::ToggleHidden
                 if self.has_hidden_filter && matches!(self.state, State::Complete | State::Cancelled) =>
             {
+                self.materialize_compressed_selection();
+                self.compressed_expanded.clear();
+                self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+                if self.alignment == Alignment::Compressed {
+                    self.rebuild_compressed_history();
+                }
                 return vec![Effect::Reload(!self.show_hidden)];
             }
             Action::ToggleAlign => {
+                let leaving_compressed = self.alignment == Alignment::Compressed;
+                if leaving_compressed {
+                    self.materialize_compressed_selection();
+                }
                 self.alignment = match self.alignment {
                     Alignment::Title => Alignment::Columns,
                     Alignment::Columns => Alignment::None,
@@ -1391,8 +1545,14 @@ impl App {
                     Alignment::Compressed => Alignment::Title,
                 };
                 if self.alignment == Alignment::Compressed {
+                    self.compressed_expanded.clear();
+                    self.compressed_segment = None;
                     self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
                     self.rebuild_compressed_history();
+                } else if leaving_compressed {
+                    self.compressed_history = None;
+                    self.compressed_anchor = None;
+                    self.compressed_expanded.clear();
                 }
                 self.ensure_visible();
             }
@@ -1435,6 +1595,7 @@ impl App {
                 changes.error = None;
                 return vec![Effect::OpenDiff(pane, changes.selected)];
             }
+            Action::OpenDiff if self.expand_selected_segment() => {}
             Action::OpenDiff if self.review_return.is_some() => {
                 let (review, _) = self.review_return.expect("review return selection is active");
                 let Some(return_to) = self
@@ -1936,7 +2097,11 @@ impl App {
         if self.state != State::Computing {
             return;
         }
-        let selected = if std::mem::take(&mut self.select_top_after_refresh) {
+        let select_top = std::mem::take(&mut self.select_top_after_refresh);
+        let segment = (!select_top && self.selection_after_refresh.is_none())
+            .then_some(self.compressed_segment)
+            .flatten();
+        let selected = if select_top {
             self.selection_after_refresh = None;
             None
         } else {
@@ -1990,8 +2155,14 @@ impl App {
         self.selected = selected
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
             .or_else(|| (!self.rows.is_empty()).then_some(0));
+        self.compressed_segment = segment;
+        if self.compressed_segment.is_some() {
+            self.selected = None;
+        }
         if self.alignment == Alignment::Compressed {
-            self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+            if self.compressed_segment.is_none() {
+                self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+            }
             self.rebuild_compressed_history();
         }
         self.state = State::Complete;
@@ -2010,6 +2181,7 @@ impl App {
 
     #[cfg(test)]
     pub(crate) fn reload(&mut self, show_hidden: bool) {
+        self.materialize_compressed_selection();
         self.reload_selection = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
         self.select_top_after_refresh = false;
         self.rows = Vec::new();
@@ -2028,6 +2200,8 @@ impl App {
         self.view_tips.clear();
         self.compressed_history = None;
         self.compressed_anchor = None;
+        self.compressed_segment = None;
+        self.compressed_expanded.clear();
         self.attributions = Vec::new();
         #[cfg(test)]
         self.test_lanes.clear();
@@ -2159,10 +2333,10 @@ impl App {
 
     fn move_selection(&mut self, distance: usize, down: bool) {
         self.pending_initial_selection = None;
-        let Some(selected) = self.selected else { return };
-        let Some(display_selected) = self.history_index(selected) else {
+        let Some(display_selected) = self.selected_history_index() else {
             return;
         };
+        let distance = distance.max(1);
         let target = if down {
             display_selected
                 .saturating_add(distance)
@@ -2170,12 +2344,22 @@ impl App {
         } else {
             display_selected.saturating_sub(distance)
         };
-        self.selected = self.nearest_selectable(target, down);
-        if self.selected != Some(selected) {
-            self.retry_failed_signatures();
+        if self.reachable_rows.is_some() {
+            let next = if down {
+                (display_selected + 1..self.history_len())
+                    .filter(|index| self.history_entry_selectable(*index))
+                    .min_by_key(|index| index.abs_diff(target))
+            } else {
+                (0..display_selected)
+                    .filter(|index| self.history_entry_selectable(*index))
+                    .min_by_key(|index| index.abs_diff(target))
+            };
+            if let Some(next) = next {
+                self.select_history_index(next);
+            }
+            return;
         }
-        self.follow_tail = false;
-        self.ensure_visible();
+        self.select_history_index(target);
     }
 
     fn next_duplicate(&self) -> Option<usize> {
@@ -2191,25 +2375,7 @@ impl App {
     }
 
     fn move_reachable(&mut self, distance: usize, down: bool) {
-        self.pending_initial_selection = None;
-        let (Some(selected), Some(reachable)) = (self.selected, self.reachable_rows.as_ref()) else {
-            self.move_selection(distance, down);
-            return;
-        };
-        let distance = distance.max(1);
-        let next = if down {
-            (selected + 1..self.rows.len())
-                .filter(|index| self.reachable_row_selectable(*index) && reachable.get(*index) == Some(&true))
-                .nth(distance - 1)
-        } else {
-            (0..selected)
-                .rev()
-                .filter(|index| self.reachable_row_selectable(*index) && reachable.get(*index) == Some(&true))
-                .nth(distance - 1)
-        };
-        if let Some(next) = next {
-            self.select(next);
-        }
+        self.move_selection(distance, down);
     }
 
     fn compute_reachable_rows(&mut self) {
@@ -2273,6 +2439,7 @@ impl App {
 
     fn select(&mut self, selected: usize) {
         self.pending_initial_selection = None;
+        self.compressed_segment = None;
         if !self.rows.is_empty() {
             let selected = selected.min(self.rows.len() - 1);
             if self.alignment == Alignment::Compressed
@@ -2331,6 +2498,7 @@ impl App {
         self.state == State::Complete
             && self.worktree_changes_available
             && self.changes_focus.is_none()
+            && !self.selected_is_segment()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && match self.selected.and_then(|index| self.rows.get(index)) {
                 Some(row) => !self.hidden_rows.contains(&row.id) && !self.known_merge_descendants.contains(&row.id),
@@ -2668,28 +2836,6 @@ impl App {
             })
     }
 
-    fn nearest_selectable(&self, target: usize, down: bool) -> Option<usize> {
-        let len = self.history_len();
-        if len == 0 {
-            return None;
-        }
-        let target = target.min(len - 1);
-        let entry = |index| match self.history_entry(index) {
-            Some(HistoryEntry::Commit(index)) => Some(index),
-            Some(HistoryEntry::Segment { .. }) | None => None,
-        };
-        if down {
-            (target..len)
-                .find_map(entry)
-                .or_else(|| (0..target).rev().find_map(entry))
-        } else {
-            (0..=target)
-                .rev()
-                .find_map(entry)
-                .or_else(|| (target + 1..len).find_map(entry))
-        }
-    }
-
     fn retry_failed_signatures(&mut self) {
         if self.signature_failures == 0 {
             return;
@@ -2730,6 +2876,7 @@ impl App {
             }
             return;
         };
+        self.compressed_segment = None;
         self.selected = Some(selected);
         if self.alignment == Alignment::Compressed
             && !self.compressed_history_suspended()
@@ -2860,7 +3007,13 @@ impl App {
 }
 
 impl CompressedHistory {
-    fn new(rows: &[SharedCommitRow], view_tips: &HashSet<ObjectId>, selected: Option<ObjectId>) -> Self {
+    fn new(
+        rows: &[SharedCommitRow],
+        view_tips: &HashSet<ObjectId>,
+        hidden_rows: &HashSet<ObjectId>,
+        expanded: &HashSet<ObjectId>,
+        selected: Option<ObjectId>,
+    ) -> Self {
         let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
         let mut children = vec![(0usize, 0usize); rows.len()];
         for (child, row) in rows.iter().enumerate() {
@@ -2870,15 +3023,23 @@ impl CompressedHistory {
                 }
             }
         }
-        let is_anchor = |id| view_tips.contains(&id) || selected == Some(id);
+        let is_anchor = |index: usize| {
+            let row = &rows[index];
+            view_tips.contains(&row.id)
+                || hidden_rows.contains(&row.id)
+                || expanded.contains(&row.id)
+                || selected == Some(row.id)
+                || row.parent_ids.len() != 1
+                || children[index].0 != 1
+        };
         let mut representatives = Vec::new();
-        let mut counts = Vec::new();
+        let mut members = Vec::<Vec<usize>>::new();
         let mut group_of = vec![usize::MAX; rows.len()];
         for (index, row) in rows.iter().enumerate() {
-            let joined = (!is_anchor(row.id))
+            let joined = (!is_anchor(index))
                 .then_some(children[index])
                 .and_then(|(count, child)| match count {
-                    1 if !is_anchor(rows[child].id)
+                    1 if !is_anchor(child)
                         && rows[child].parent_ids.len() == 1
                         && rows[child].parent_ids[0] == row.id
                         && group_of[child] != usize::MAX =>
@@ -2889,11 +3050,11 @@ impl CompressedHistory {
                 });
             let group = joined.unwrap_or_else(|| {
                 representatives.push(index);
-                counts.push(0);
+                members.push(Vec::new());
                 representatives.len() - 1
             });
             group_of[index] = group;
-            counts[group] += 1;
+            members[group].push(index);
         }
 
         let representative_ids: Vec<_> = representatives.iter().map(|index| rows[*index].id).collect();
@@ -2905,7 +3066,7 @@ impl CompressedHistory {
                     continue;
                 };
                 let parent_group = group_of[*parent_index];
-                if parent_group != group && !parents[group].contains(&representative_ids[parent_group]) {
+                if parent_group != group {
                     parents[group].push(representative_ids[parent_group]);
                 }
             }
@@ -2917,10 +3078,13 @@ impl CompressedHistory {
             let mut row = rows[representative].as_ref().clone();
             row.parent_ids = std::mem::take(&mut parents[group]);
             compact_rows.push(Arc::new(row));
-            entries.push(if is_anchor(rows[representative].id) {
+            entries.push(if is_anchor(representative) {
                 HistoryEntry::Commit(representative)
             } else {
-                HistoryEntry::Segment { count: counts[group] }
+                HistoryEntry::Segment {
+                    representative,
+                    count: members[group].len(),
+                }
             });
         }
         let graph = Graph::new(&compact_rows);
@@ -2932,9 +3096,16 @@ impl CompressedHistory {
                 HistoryEntry::Segment { .. } => None,
             })
             .collect();
+        let member_indices = members
+            .iter()
+            .enumerate()
+            .flat_map(|(display, members)| members.iter().map(move |index| (rows[*index].id, display)))
+            .collect();
         CompressedHistory {
             entries,
             display_indices,
+            member_indices,
+            members,
             rows: compact_rows,
             graph,
         }
@@ -4610,7 +4781,7 @@ mod tests {
     }
 
     #[test]
-    fn compressed_history_retains_tips_and_selection_and_skips_segments() {
+    fn compressed_history_retains_tips_and_selection_and_selects_segments() {
         let mut app = App::new(2);
         app.extend_commits(vec![
             row_with_parents(6, &[5]),
@@ -4632,25 +4803,32 @@ mod tests {
                 .collect::<Vec<_>>(),
             [
                 HistoryEntry::Commit(0),
-                HistoryEntry::Segment { count: 2 },
+                HistoryEntry::Segment {
+                    representative: 1,
+                    count: 2,
+                },
                 HistoryEntry::Commit(3),
-                HistoryEntry::Segment { count: 2 },
+                HistoryEntry::Segment {
+                    representative: 4,
+                    count: 1,
+                },
+                HistoryEntry::Commit(5),
             ],
-            "linear commits between explicit anchors collapse into counted segments"
+            "linear commits between the retained endpoints and selection collapse into counted segments"
         );
         assert_eq!(
             app.render_lanes(0..app.history_len()).iter().collect::<Vec<_>>(),
-            ["● ", "○ ", "● ", "○ "],
+            ["● ", "○ ", "● ", "○ ", "● "],
             "segments reuse the canonical graph with a quieter ring marker"
         );
 
         app.update(Action::MoveUp);
-        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(6)));
+        assert!(app.selected_is_segment(), "navigation stops on a segment summary");
         app.update(Action::MoveDown);
         assert_eq!(
             app.selected.map(|index| app.rows[index].id),
             Some(id(3)),
-            "navigation crosses nonselectable segments"
+            "navigation returns from a summary to its adjacent retained commit"
         );
 
         app.select_commit(id(2));
@@ -4690,11 +4868,11 @@ mod tests {
             entries
                 .iter()
                 .filter_map(|entry| match entry {
-                    HistoryEntry::Segment { count } => Some(*count),
+                    HistoryEntry::Segment { count, .. } => Some(*count),
                     HistoryEntry::Commit(_) => None,
                 })
                 .sum::<usize>(),
-            5,
+            4,
             "every non-anchor commit is represented exactly once"
         );
         let lanes = app.render_lanes(0..app.history_len());
@@ -4707,7 +4885,7 @@ mod tests {
     }
 
     #[test]
-    fn compressed_history_temporarily_expands_for_target_selection() {
+    fn compressed_history_stays_active_for_target_selection() {
         let mut app = App::new(2);
         app.extend_commits(vec![
             row_with_parents(4, &[3]),
@@ -4719,17 +4897,362 @@ mod tests {
         app.set_view_tips(&[id(4)]);
         app.alignment = Alignment::None;
         app.update(Action::ToggleAlign);
-        assert_eq!(app.history_len(), 2);
+        assert_eq!(app.history_len(), 3);
 
         app.reachability_anchor = Some(id(4));
         app.compute_reachable_rows();
         assert_eq!(
             app.history_len(),
-            app.rows.len(),
-            "target selection uses the full history"
+            3,
+            "target selection retains the compressed projection"
         );
+        app.update(Action::MoveDown);
+        assert!(app.selected_is_segment(), "an eligible target segment is selectable");
+        app.update(Action::OpenDiff);
+        assert_eq!(app.history_len(), app.rows.len(), "Enter expands the eligible segment");
         app.clear_reachability_selection();
-        assert_eq!(app.history_len(), 2, "leaving target selection restores compression");
+        assert_eq!(
+            app.history_len(),
+            app.rows.len(),
+            "expanded segments remain open for the compressed cycle"
+        );
+    }
+
+    #[test]
+    fn compressed_history_keeps_graph_junctions_and_endpoints_as_commits() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(6, &[4]),
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[2]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.set_worktree_head(Some(id(6)), false);
+        complete(&mut app);
+        app.set_view_tips(&[id(6), id(5)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        for (n, description) in [
+            (6, "the current graph tip"),
+            (5, "the other graph tip"),
+            (2, "the shared merge base"),
+            (1, "the graph root"),
+        ] {
+            let canonical = app
+                .rows
+                .iter()
+                .position(|row| row.id == id(n))
+                .expect("the structural commit is present");
+            let display = app
+                .history_index(canonical)
+                .expect("structural commits have their own display row");
+            assert_eq!(
+                app.history_entry(display),
+                Some(HistoryEntry::Commit(canonical)),
+                "{description} remains a full commit"
+            );
+        }
+
+        app.select_commit(id(2));
+        assert!(
+            app.can_copy_insert(),
+            "a retained merge base is an ordinary insertion target"
+        );
+        assert_eq!(
+            app.update(Action::CopyInsert),
+            vec![Effect::Insert {
+                source: id(6),
+                base: id(6),
+                target: id(2),
+                copy: true,
+            }]
+        );
+    }
+
+    #[test]
+    fn compressed_history_keeps_the_first_hidden_boundary_as_a_commit() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[2]), row_with_parents(2, &[1])]);
+        app.extend_hidden_commits(vec![row_with_parents(1, &[0])]);
+        complete(&mut app);
+        app.set_view_tips(&[id(3)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        let boundary = app
+            .rows
+            .iter()
+            .position(|row| row.id == id(1))
+            .expect("the hidden boundary is present");
+        assert!(app.is_row_hidden(boundary));
+        let display = app
+            .history_index(boundary)
+            .expect("the hidden boundary has its own display row");
+        assert_eq!(app.history_entry(display), Some(HistoryEntry::Commit(boundary)));
+
+        app.select_commit(id(1));
+        assert!(
+            app.can_rebase(),
+            "the retained boundary keeps its existing base actions"
+        );
+        assert_eq!(
+            app.update(Action::Rebase),
+            vec![Effect::Rebase {
+                base: id(1),
+                onto: id(1),
+                commits: vec![id(3), id(2)],
+            }]
+        );
+    }
+
+    #[test]
+    fn compressed_segments_are_selectable_and_expand_in_place() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        let ordinary_lanes = app
+            .render_lanes(0..app.rows.len())
+            .iter()
+            .map(str::to_owned)
+            .collect::<Vec<_>>();
+        app.set_view_tips(&[id(6)]);
+        app.select_commit(id(3));
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        app.update(Action::MoveUp);
+        assert!(app.selected_is_segment(), "navigation stops on the upper summary");
+        assert_eq!(app.selected_history_index(), Some(1));
+        app.set_worktree_head_unborn(true);
+        for action in [Action::ToggleCommitGroup, Action::ToggleActions, Action::ToggleEnrich] {
+            app.update(action);
+        }
+        assert!(!app.commit_expanded && !app.actions_expanded && !app.enrich_expanded);
+        assert!(
+            app.update(Action::NewEmptyCommit).is_empty(),
+            "a synthetic selection is not mistaken for an unborn HEAD"
+        );
+        assert!(
+            app.update(Action::OpenDiff).is_empty(),
+            "Enter expands instead of diffing a summary"
+        );
+        assert_eq!(
+            app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
+            Some(id(5)),
+            "expansion selects the newest commit represented by the summary"
+        );
+        assert!(
+            (0..app.history_len()).any(|index| matches!(app.history_entry(index), Some(HistoryEntry::Segment { .. }))),
+            "expanding one summary leaves the other summary compressed"
+        );
+
+        app.update(Action::Last);
+        app.update(Action::MoveUp);
+        assert!(app.selected_is_segment(), "navigation stops on the remaining summary");
+        assert!(app.update(Action::OpenDiff).is_empty());
+        assert_eq!(
+            (0..app.history_len())
+                .filter_map(|index| app.history_entry(index))
+                .collect::<Vec<_>>(),
+            (0..app.rows.len()).map(HistoryEntry::Commit).collect::<Vec<_>>(),
+            "expanding every summary produces the ordinary row sequence"
+        );
+        assert_eq!(
+            app.render_lanes(0..app.history_len())
+                .iter()
+                .map(str::to_owned)
+                .collect::<Vec<_>>(),
+            ordinary_lanes,
+            "fully expanded compression uses the ordinary graph"
+        );
+        assert_eq!(
+            app.update(Action::OpenDiff),
+            vec![Effect::OpenCommitDiff(TreeDiffTarget::Commit { id: id(2), parent: 0 })],
+            "Enter resumes its normal commit behavior after expansion"
+        );
+    }
+
+    #[test]
+    fn compressed_modal_navigation_only_selects_segments_with_eligible_members() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(6)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+
+        app.viewport_rows = 10;
+        app.reachable_rows = Some(vec![false, false, false, true, false, false]);
+        app.update(Action::PageDown);
+        assert!(
+            app.selected_is_segment(),
+            "paged navigation reaches a nearby eligible segment"
+        );
+        app.reachable_rows = Some(vec![false; 6]);
+        app.update(Action::OpenDiff);
+        assert!(
+            app.selected_is_segment(),
+            "an ineligible segment keeps its selection instead of expanding without a target"
+        );
+
+        app.select_commit(id(6));
+        app.reachable_rows = Some(vec![false, false, false, false, false, true]);
+        app.update(Action::MoveDown);
+        assert_eq!(
+            app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
+            Some(id(1)),
+            "navigation skips a segment without an eligible target"
+        );
+
+        app.select_commit(id(6));
+        app.reachable_rows = Some(vec![false, false, false, true, false, false]);
+        app.update(Action::MoveDown);
+        assert!(
+            app.selected_is_segment(),
+            "a segment containing an eligible target is selectable"
+        );
+        app.update(Action::OpenDiff);
+        assert_eq!(
+            app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
+            Some(id(3)),
+            "expansion selects the newest eligible member"
+        );
+    }
+
+    #[test]
+    fn compressed_selection_and_expansions_survive_in_place_refreshes() {
+        let commits = || {
+            vec![
+                row_with_parents(5, &[4]),
+                row_with_parents(4, &[3]),
+                row_with_parents(3, &[2]),
+                row_with_parents(2, &[1]),
+                row(1),
+            ]
+        };
+        let refresh = |app: &mut App| {
+            let rows = app
+                .start_refresh(commits().into(), &[id(5)], &[], false)
+                .expect("the in-place refresh computes lanes");
+            let (rows, graph, time) = compute_lanes(rows);
+            app.finish_lane_computation(rows, graph, time);
+        };
+        let mut app = App::new(10);
+        app.extend_commits(commits());
+        complete(&mut app);
+        app.set_view_tips(&[id(5)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        app.update(Action::MoveDown);
+
+        refresh(&mut app);
+        assert!(app.selected_is_segment(), "a synthetic selection survives by object ID");
+        app.update(Action::OpenDiff);
+        refresh(&mut app);
+        assert_eq!(
+            (0..app.history_len())
+                .filter_map(|index| app.history_entry(index))
+                .collect::<Vec<_>>(),
+            (0..app.rows.len()).map(HistoryEntry::Commit).collect::<Vec<_>>(),
+            "expanded members survive an in-place refresh"
+        );
+    }
+
+    #[test]
+    fn suspending_compression_materializes_a_segment_selection() {
+        let mut app = App::new(2);
+        app.extend_commits(vec![
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(5)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        app.update(Action::MoveDown);
+        assert!(app.selected_is_segment());
+
+        app.set_worktree_conflicted(true);
+        assert_eq!(
+            app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
+            Some(id(4)),
+            "the segment representative becomes the full-history selection"
+        );
+        app.update(Action::MoveDown);
+        assert_eq!(
+            app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
+            Some(id(3))
+        );
+    }
+
+    #[test]
+    fn compressed_expansions_reset_on_mode_exit_and_full_reload() {
+        let commits = || {
+            vec![
+                row_with_parents(5, &[4]),
+                row_with_parents(4, &[3]),
+                row_with_parents(3, &[2]),
+                row_with_parents(2, &[1]),
+                row(1),
+            ]
+        };
+        let has_segment = |app: &App| {
+            (0..app.history_len()).any(|index| matches!(app.history_entry(index), Some(HistoryEntry::Segment { .. })))
+        };
+
+        let mut app = App::new(10);
+        app.extend_commits(commits());
+        complete(&mut app);
+        app.set_view_tips(&[id(5)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        app.update(Action::MoveDown);
+        assert!(app.selected_is_segment());
+        app.update(Action::OpenDiff);
+        assert!(!has_segment(&app), "the only linear summary is expanded");
+
+        app.update(Action::ToggleAlign);
+        app.update(Action::ToggleAlign);
+        app.update(Action::ToggleAlign);
+        app.update(Action::ToggleAlign);
+        assert_eq!(app.alignment, Alignment::Compressed);
+        assert!(has_segment(&app), "leaving compressed mode discards expansions");
+
+        app.update(Action::MoveDown);
+        if !app.selected_is_segment() {
+            app.update(Action::MoveDown);
+        }
+        assert!(app.selected_is_segment(), "a summary is available to expand again");
+        app.update(Action::OpenDiff);
+        app.reload(false);
+        app.set_view_tips(&[id(5)]);
+        app.extend_commits(commits());
+        complete(&mut app);
+        assert_eq!(app.alignment, Alignment::Compressed);
+        assert!(
+            has_segment(&app),
+            "a full reload discards expansions even for unchanged commit IDs"
+        );
     }
 
     #[test]
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 87b843109c8..689e22ec925 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -324,17 +324,18 @@ pub(crate) fn draw_with_worktree(
 ) -> FrameLayout {
     let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
     let full_body = body;
-    let compared_parent = if app.changes_visible() {
+    let selected_segment = app.selected_is_segment();
+    let compared_parent = if app.changes_visible() && !selected_segment {
         tree_changes.and_then(|changes| changes.parent.map(|parent| parent.id))
     } else {
         None
     };
-    let tree_shown = app.changes_visible() && tree_changes.is_some();
+    let tree_shown = app.changes_visible() && !selected_segment && tree_changes.is_some();
     let worktree_shown =
         app.changes_visible() && app.changes_mode == Some(ChangesMode::Both) && worktree_changes.is_some();
     let tree_summary = tree_changes.map(|changes| changes_summary(ChangePane::Tree, app, changes));
     let worktree_summary = worktree_changes.map(|changes| changes_summary(ChangePane::Worktree, app, changes));
-    let mut commit_pane = app.show_commit.then(|| {
+    let mut commit_pane = (app.show_commit && !selected_segment).then(|| {
         let width = COMMIT_PANE_WIDTH.min(full_body.width / 2);
         let [commits, message] = Layout::horizontal([Constraint::Min(0), Constraint::Length(width)]).areas(full_body);
         body.width = body.width.min(commits.width);
@@ -702,7 +703,7 @@ pub(crate) fn draw_with_worktree(
         .iter()
         .enumerate()
         .map(|(index, entry)| match (entry, &metadata[index]) {
-            (HistoryEntry::Segment { count }, _) => lanes
+            (HistoryEntry::Segment { count, .. }, _) => lanes
                 .lane(index)
                 .chars()
                 .count()
@@ -721,11 +722,11 @@ pub(crate) fn draw_with_worktree(
         .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
     let selection_info = selection_info_line(
-        app.changes_visible()
+        (!selected_segment && app.changes_visible())
             .then_some(tree_changes)
             .flatten()
             .filter(|changes| changes.is_visible()),
-        app.selection_relation,
+        (!selected_segment).then_some(app.selection_relation).flatten(),
     );
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
@@ -744,9 +745,23 @@ pub(crate) fn draw_with_worktree(
         let row_area = Rect::new(content.x, y, content.width, 1);
         let row_index = match visible_entries[index] {
             HistoryEntry::Commit(index) => index,
-            HistoryEntry::Segment { count } => {
+            HistoryEntry::Segment { count, .. } => {
+                let selected = selected_segment && selected == Some(start + index);
+                let selectable = app.history_entry_selectable(start + index);
+                let style = if selected {
+                    Style::default().add_modifier(Modifier::REVERSED)
+                } else {
+                    Style::default()
+                };
+                if selected {
+                    frame.render_widget(
+                        Paragraph::new(Line::styled("> ", style)),
+                        Rect::new(status_x, y, body.right().saturating_sub(status_x).min(2), 1),
+                    );
+                }
                 frame.render_widget(
-                    Paragraph::new(format!("{lane}[{count}]")).scroll((0, horizontal_offset as u16)),
+                    Paragraph::new(Line::styled(format!("{lane}[{count}]"), style))
+                        .scroll((0, horizontal_offset as u16)),
                     row_area,
                 );
                 color_graph(
@@ -754,10 +769,16 @@ pub(crate) fn draw_with_worktree(
                     row_area,
                     lane,
                     horizontal_offset,
-                    None,
+                    selected.then_some(Color::Reset),
                     SignatureState::Unsigned,
                     None,
                 );
+                if !selectable {
+                    frame.buffer_mut().set_style(
+                        Rect::new(body.x, y, body.width, 1),
+                        Style::default().add_modifier(Modifier::DIM),
+                    );
+                }
                 continue;
             }
         };
@@ -1067,7 +1088,7 @@ pub(crate) fn draw_with_worktree(
     let mut commit_popup = None;
     let mut actions_prefix_spans = Vec::new();
     let mut actions_popup = None;
-    if app.changes_focus != Some(ChangePane::Worktree) || app.can_amend() {
+    if !selected_segment && (app.changes_focus != Some(ChangePane::Worktree) || app.can_amend()) {
         time_travel = time_travel_label(app, decorations);
         if app.commit_expanded {
             let mut options = Vec::new();
@@ -1127,7 +1148,7 @@ pub(crate) fn draw_with_worktree(
             emphasize_prefix(&mut commit_prefix_spans[1..]);
         }
     }
-    if app.changes_focus.is_none() {
+    if !selected_segment && app.changes_focus.is_none() {
         actions_prefix_spans.push(Span::raw(" · "));
         actions_prefix_spans.push(Span::styled("a", Style::default().add_modifier(Modifier::UNDERLINED)));
         actions_prefix_spans.push(Span::raw("ctions"));
@@ -1243,6 +1264,9 @@ pub(crate) fn draw_with_worktree(
         emphasize_prefix(&mut view_prefix_spans[1..]);
     }
     let mut ordered = vec![Span::raw(history_position(app))];
+    if selected_segment {
+        ordered.push(Span::raw(" · <enter> expand"));
+    }
     let mut prefix_popup = None;
     let view_anchor = spans_width(&ordered).saturating_add(view_prefix_spans[0].width());
     ordered.append(&mut view_prefix_spans);
@@ -1259,27 +1283,29 @@ pub(crate) fn draw_with_worktree(
     if let Some(items) = actions_popup {
         prefix_popup = Some((actions_anchor, items));
     }
-    ordered.push(Span::raw(" · "));
-    let enrich_anchor = spans_width(&ordered);
-    let enrich_prefix_start = ordered.len();
-    ordered.extend(shortcut("enrich", 'n', true));
-    if app.enrich_expanded {
-        let mut items = Vec::new();
-        if let Some(row) = app.selected.and_then(|index| app.rows.get(index)) {
-            if app.can_reword() {
-                items.extend(shortcut("todo", 't', app.todo(row.id)));
-                items.push(Span::raw(" · "));
-                items.extend(shortcut("note", 'o', app.note(row.id).is_some()));
+    if !selected_segment {
+        ordered.push(Span::raw(" · "));
+        let enrich_anchor = spans_width(&ordered);
+        let enrich_prefix_start = ordered.len();
+        ordered.extend(shortcut("enrich", 'n', true));
+        if app.enrich_expanded {
+            let mut items = Vec::new();
+            if let Some(row) = app.selected.and_then(|index| app.rows.get(index)) {
+                if app.can_reword() {
+                    items.extend(shortcut("todo", 't', app.todo(row.id)));
+                    items.push(Span::raw(" · "));
+                    items.extend(shortcut("note", 'o', app.note(row.id).is_some()));
+                    items.push(Span::raw(" · "));
+                }
+                items.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
                 items.push(Span::raw(" · "));
+                items.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
+            } else {
+                items.push(Span::raw("no actions"));
             }
-            items.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
-            items.push(Span::raw(" · "));
-            items.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
-        } else {
-            items.push(Span::raw("no actions"));
+            emphasize_prefix(&mut ordered[enrich_prefix_start..]);
+            prefix_popup = Some((enrich_anchor, items));
         }
-        emphasize_prefix(&mut ordered[enrich_prefix_start..]);
-        prefix_popup = Some((enrich_anchor, items));
     }
     if let Some(label) = time_travel {
         ordered.push(Span::raw(" · "));
@@ -1289,8 +1315,10 @@ pub(crate) fn draw_with_worktree(
         ordered.push(Span::raw(" · "));
         ordered.extend(shortcut("next duplicate", 'x', true));
     }
-    ordered.push(Span::raw(" · "));
-    ordered.extend(shortcut("copy", 'y', true));
+    if !selected_segment {
+        ordered.push(Span::raw(" · "));
+        ordered.extend(shortcut("copy", 'y', true));
+    }
     ordered.push(Span::raw(" · "));
     ordered.extend(shortcut("refs", 'r', app.ref_mode != RefMode::None));
     ordered.push(Span::raw(" · "));
@@ -1323,20 +1351,26 @@ pub(crate) fn draw_with_worktree(
         items.push(toggle(alignment, enabled));
         items.push(Span::raw(" · "));
         items.extend(shortcut("ref-tree", 't', false));
-        items.push(Span::raw(" · "));
-        items.extend(shortcut("message", 'm', app.show_commit));
-        items.push(Span::raw(" · "));
-        items.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
-        if app.tree_changes_visible || app.worktree_changes_visible {
+        if !selected_segment {
             items.push(Span::raw(" · "));
-            items.push(match focus_feedback {
-                Some(destination) => Span::raw(format!("<tab> → {destination}")),
-                None => Span::raw("<tab> switch"),
-            });
+            items.extend(shortcut("message", 'm', app.show_commit));
+            items.push(Span::raw(" · "));
+            items.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
+            if app.tree_changes_visible || app.worktree_changes_visible {
+                items.push(Span::raw(" · "));
+                items.push(match focus_feedback {
+                    Some(destination) => Span::raw(format!("<tab> → {destination}")),
+                    None => Span::raw("<tab> switch"),
+                });
+            }
         }
         items.push(Span::raw(" · ↑↓/jk move · h/l pan"));
         if app.changes_focus.is_none() {
-            items.push(Span::raw(" · <enter> diff"));
+            items.push(Span::raw(if selected_segment {
+                " · <enter> expand"
+            } else {
+                " · <enter> diff"
+            }));
         }
         emphasize_prefix(&mut ordered[information_prefix_start..]);
         prefix_popup = Some((information_anchor, items));
@@ -1413,12 +1447,16 @@ fn time_travel_label(app: &App, decorations: &Decorations) -> Option<&'static st
 
 fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<usize> {
     let mut width = history_position(app).chars().count();
+    let selected_segment = app.selected_is_segment();
+    if selected_segment {
+        width += " · <enter> expand".chars().count();
+    }
     width += 3;
     let view = width;
     width += "view".len();
     let mut active = app.history_display_expanded.then_some(view);
 
-    let commit_visible = app.changes_focus != Some(ChangePane::Worktree) || app.can_amend();
+    let commit_visible = !selected_segment && (app.changes_focus != Some(ChangePane::Worktree) || app.can_amend());
     if commit_visible {
         width += 3;
         let commit = width;
@@ -1427,7 +1465,7 @@ fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<us
             active = Some(commit);
         }
     }
-    if app.changes_focus.is_none() {
+    if !selected_segment && app.changes_focus.is_none() {
         width += 3;
         let actions = width;
         width += "actions".len();
@@ -1435,11 +1473,13 @@ fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<us
             active = Some(actions);
         }
     }
-    width += 3;
-    let enrich = width;
-    width += "enrich".len();
-    if app.enrich_expanded {
-        active = Some(enrich);
+    if !selected_segment {
+        width += 3;
+        let enrich = width;
+        width += "enrich".len();
+        if app.enrich_expanded {
+            active = Some(enrich);
+        }
     }
     if commit_visible && let Some(label) = time_travel_label(app, decorations) {
         width += 3 + label.len();
@@ -1447,7 +1487,9 @@ fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<us
     if app.can_cycle_duplicate() {
         width += 3 + "next duplicate".len();
     }
-    width += 3 + "copy".len();
+    if !selected_segment {
+        width += 3 + "copy".len();
+    }
     width += 3 + "refs".len();
     width += 3;
     if app.information_expanded {
@@ -7002,7 +7044,8 @@ mod tests {
     }
 
     #[test]
-    fn renders_compressed_segments_without_commit_metadata_or_row_identity() -> Result<(), Box<dyn std::error::Error>> {
+    fn renders_selected_compressed_segments_as_expandable_without_stale_commit_ui()
+    -> Result<(), Box<dyn std::error::Error>> {
         let ids = [1, 2, 3, 4].map(|byte| gix::ObjectId::Sha1([byte; 20]));
         let mut app = App::new(2);
         app.extend_commits(
@@ -7028,19 +7071,22 @@ mod tests {
         for _ in 0..3 {
             app.update(Action::ToggleAlign);
         }
+        app.update(Action::MoveDown);
+        app.show_commit = true;
 
         let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
         let mut layout = None;
         let decorations = Decorations::new();
         let mailmap = gix::mailmap::Snapshot::default();
+        let stale_tree_changes = Changes::default();
         terminal.draw(|frame| {
             layout = Some(draw_with_worktree(
                 frame,
                 &mut app,
                 &decorations,
                 &mailmap,
-                None,
-                None,
+                Some(BStr::new(b"stale commit message")),
+                Some(&stale_tree_changes),
                 None,
             ));
         })?;
@@ -7049,11 +7095,27 @@ mod tests {
             rendered_line(&terminal, 0).contains("tip"),
             "the retained tip keeps its metadata"
         );
-        assert_eq!(rendered_line(&terminal, 1).trim(), "○ [3]");
+        assert_eq!(rendered_line(&terminal, 1).trim(), "> ○ [2]");
+        assert!(
+            (0..7).all(|x| terminal.backend().buffer()[(x, 1)]
+                .modifier
+                .contains(Modifier::REVERSED)),
+            "the selected summary, including its status and count, is reversed"
+        );
+        let footer = rendered_line(&terminal, 2);
+        assert!(footer.contains("<enter> expand"));
+        for hidden in [" · commit", " · actions", " · enrich", " · copy"] {
+            assert!(!footer.contains(hidden), "synthetic selection hides {hidden:?}");
+        }
+        let layout = layout.expect("drawing returns its layout");
+        assert!(
+            layout.overlays.is_empty(),
+            "stale commit-message and tree-change panes stay hidden"
+        );
         assert_eq!(
-            layout.expect("drawing returns its layout").rows,
+            layout.rows,
             vec![(ids[0], 0)],
-            "segments are not interactive or animated commit rows"
+            "a selectable summary still has no commit identity for animation"
         );
         Ok(())
     }

From e52383e43b4f2a0dba4867df58fa93b55aa23180 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 13:26:16 +0200
Subject: [PATCH 243/282] fix: keep Tix history lanes stable across refreshes

Rank refreshed first-parent descendants by their current displayed branch before lane computation, so advancing a tip does not swap independent lanes. Cover successive refreshes and compressed history.
---
 gix-tix/src/app.rs | 76 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index cc63fc5a4e5..ccd60503688 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2035,6 +2035,12 @@ impl App {
         if self.stack_insert_base.is_some() {
             self.clear_reachability_selection();
         }
+        let previous_order: HashMap<_, _> = self
+            .rows
+            .iter()
+            .enumerate()
+            .map(|(index, row)| (row.id, index))
+            .collect();
         drop(self.store_commits(commits));
 
         let visible = self.reachable_from(view_tips);
@@ -2056,6 +2062,32 @@ impl App {
             .filter(|id| visible.contains(*id) || boundary.contains(*id))
             .filter_map(|id| self.all_rows.get(id).map(Arc::clone))
             .collect();
+        let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
+        let mut children = vec![Vec::new(); rows.len()];
+        let mut ranks = vec![None; rows.len()];
+        let mut pending = Vec::new();
+        for (index, row) in rows.iter().enumerate() {
+            if let Some(rank) = previous_order.get(&row.id) {
+                ranks[index] = Some(*rank);
+                pending.push(index);
+                continue;
+            }
+            if let Some(parent) = row.parent_ids.iter().next().and_then(|parent| positions.get(parent)) {
+                children[*parent].push(index);
+            } else {
+                pending.push(index);
+            }
+        }
+        while let Some(parent) = pending.pop() {
+            for child in &children[parent] {
+                // First-parent ancestry identifies the old lane.
+                ranks[*child] = ranks[parent];
+                pending.push(*child);
+            }
+        }
+        let mut rows: Vec<_> = rows.into_iter().zip(ranks).collect();
+        rows.sort_by_key(|(_, rank)| (rank.is_none(), *rank));
+        let rows = rows.into_iter().map(|(row, _)| row).collect();
         self.pending_hidden_rows = Some(boundary);
         self.select_top_after_refresh = select_top;
         self.state = State::Computing;
@@ -3672,6 +3704,50 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_keeps_an_advanced_tip_on_its_existing_side() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(3, &[1]), row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(4, &[3])].into(), &[id(4), id(2)], &[], false)
+            .expect("a refresh computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(4), id(3), id(2), id(1)],
+            "advancing a tip keeps its history ahead of the independent tip"
+        );
+        assert_eq!(
+            app.render_lanes(0..app.rows.len()).iter().collect::<Vec<_>>(),
+            ["● ", "● ", "├─● ", "● "],
+            "the advanced tip stays in its existing left lane"
+        );
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(5, &[4])].into(), &[id(5), id(2)], &[], false)
+            .expect("a second refresh computes lanes");
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert_eq!(
+            app.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(5), id(4), id(3), id(2), id(1)],
+            "successive commits keep inheriting the current lane order"
+        );
+
+        app.select_commit(id(5));
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        assert_eq!(
+            app.render_lanes(0..app.history_len()).iter().collect::<Vec<_>>(),
+            ["● ", "○ ", "├─● ", "● "],
+            "compressed history inherits the stable canonical lanes"
+        );
+    }
+
     #[test]
     fn refresh_keeps_change_ids_until_the_replacement_projection_is_ready() {
         let mut app = App::new(10);

From 2847d539681f0103479617c6d536ce123176456a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 13:37:27 +0200
Subject: [PATCH 244/282] fix: preserve Tix history position across compression

Preserve the selected entry viewport row while cycling between canonical and compressed projections, clamping only when the new history cannot keep it. Cover entering on a commit and leaving from a compressed segment.
---
 gix-tix/src/app.rs | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ccd60503688..19c3f4e8d8f 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1534,6 +1534,9 @@ impl App {
                 return vec![Effect::Reload(!self.show_hidden)];
             }
             Action::ToggleAlign => {
+                let viewport_row = self
+                    .selected_history_index()
+                    .map(|selected| selected.saturating_sub(self.offset));
                 let leaving_compressed = self.alignment == Alignment::Compressed;
                 if leaving_compressed {
                     self.materialize_compressed_selection();
@@ -1554,6 +1557,9 @@ impl App {
                     self.compressed_anchor = None;
                     self.compressed_expanded.clear();
                 }
+                if let (Some(selected), Some(viewport_row)) = (self.selected_history_index(), viewport_row) {
+                    self.offset = selected.saturating_sub(viewport_row);
+                }
                 self.ensure_visible();
             }
             Action::ToggleCommit => {
@@ -4915,6 +4921,41 @@ mod tests {
         );
     }
 
+    #[test]
+    fn compressed_mode_transitions_keep_the_selected_viewport_row() {
+        let mut app = App::new(4);
+        app.extend_commits(
+            (0..=11)
+                .rev()
+                .map(|n| numbered_row(n, n.checked_sub(1)))
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.set_view_tips(&[id(11)]);
+        app.select_commit(id(5));
+        app.offset = 4;
+        let viewport_row = app.selected_history_index().expect("the commit is selected") - app.offset;
+
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        assert_eq!(
+            app.selected_history_index().map(|selected| selected - app.offset),
+            Some(viewport_row),
+            "entering compressed mode keeps the selected commit on screen"
+        );
+
+        app.update(Action::MoveDown);
+        assert!(app.selected_is_segment(), "the lower compressed segment is selected");
+        app.offset = 1;
+        let viewport_row = app.selected_history_index().expect("the segment is selected") - app.offset;
+        app.update(Action::ToggleAlign);
+        assert_eq!(
+            app.selected_history_index().map(|selected| selected - app.offset),
+            Some(viewport_row),
+            "leaving compressed mode keeps its representative on the segment's screen row"
+        );
+    }
+
     #[test]
     fn compressed_history_keeps_ancestor_tips_and_merge_topology() {
         let mut app = App::new(10);

From 73be3c672c9da00aa93f660c30a29564e6d5261d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 16:08:54 +0200
Subject: [PATCH 245/282] feat: add ref-backed undo and redo

Store per-worktree operation history as config-serialized commits, restore refs and affected worktrees with checked transactions, and expose undo/redo through the TUI.

Show the current queue position as two-tone progress in the transient message line, while keeping internal queue refs out of history and revision selection.
---
 gix-tix/spec.md                 |    7 +-
 gix-tix/src/app.rs              |   82 +++
 gix-tix/src/command.rs          |   80 +-
 gix-tix/src/command/enrich.rs   |   96 ++-
 gix-tix/src/command/new.rs      |    3 +-
 gix-tix/src/command/rebase.rs   |   44 +-
 gix-tix/src/command/reword.rs   |    7 +
 gix-tix/src/command/travel.rs   |    5 +-
 gix-tix/src/edit/create.rs      |   46 +-
 gix-tix/src/edit/forget.rs      |    5 +-
 gix-tix/src/edit/head.rs        |   10 +
 gix-tix/src/edit/mod.rs         |   23 +
 gix-tix/src/edit/rebase.rs      |   16 +-
 gix-tix/src/edit/reword.rs      |   20 +-
 gix-tix/src/edit/split.rs       |   12 +-
 gix-tix/src/edit/time_travel.rs |  651 ++++++++++++-----
 gix-tix/src/edit/todo.rs        |    1 +
 gix-tix/src/edit/undo.rs        | 1203 +++++++++++++++++++++++++++++++
 gix-tix/src/history.rs          |  127 +++-
 gix-tix/src/lib.rs              |  933 +++++++++++++++++++-----
 gix-tix/src/ref_tree.rs         |   42 +-
 gix-tix/src/ui.rs               |  124 ++++
 22 files changed, 3101 insertions(+), 436 deletions(-)
 create mode 100644 gix-tix/src/edit/undo.rs

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 97c5a7b37bc..cd8eb73df34 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1181,7 +1181,12 @@ space first; changes blocks adapt within the remaining history width.
   within that pane when visible and otherwise within the main view. It never
   covers the main or pane-local status lines. Green indicates success, yellow
   indicates attention, no-op, recovery, partial success, or an armed prompt, and
-  red indicates failure. Forget, review selection and recovery, suspended
+  red indicates failure. While undo or redo feedback retains its queue position,
+  the notice becomes a two-tone progress bar: the applied share is bright on the
+  left and the redo share is dim on the right. A fully applied queue is entirely
+  bright, while its start and an empty queue are entirely dim; attention and
+  failure notices retain the same progress in their respective hues. Forget,
+  review selection and recovery, suspended
   conflicts, and paused rebases retain their notice until resolved; pane-specific
   errors remain in their pane status line.
 - Closing the new-commit editor without changing its prepared buffer leaves the
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 19c3f4e8d8f..d5b0e6e8804 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -63,6 +63,13 @@ pub(crate) struct Notice {
     pub text: String,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct UndoPosition {
+    applied: usize,
+    total: usize,
+    title: String,
+}
+
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 pub(crate) enum ChangeKind {
     Added,
@@ -327,6 +334,8 @@ pub(crate) enum CopyKind {
 #[derive(Debug, Eq, PartialEq)]
 pub(crate) enum Action {
     Cancelled,
+    Undo,
+    Redo,
     MoveUp,
     MoveDown,
     MoveUpBy(usize),
@@ -397,6 +406,8 @@ pub(crate) enum Action {
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum Effect {
     Cancel,
+    Undo,
+    Redo,
     CopyId(ObjectId),
     CopyPath(BString),
     CopyAuthor(&'static Author),
@@ -552,6 +563,7 @@ pub(crate) struct App {
     pub copy_feedback: Option<CopyKind>,
     pub(crate) focus_feedback: Option<&'static str>,
     notice: Option<Notice>,
+    undo_position: Option<UndoPosition>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
     pub(crate) commit_expanded: bool,
@@ -659,6 +671,7 @@ impl App {
             copy_feedback: None,
             focus_feedback: None,
             notice: None,
+            undo_position: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
             commit_expanded: false,
@@ -788,6 +801,27 @@ impl App {
         }
     }
 
+    pub(crate) fn show_undo_position(&mut self, applied: usize, total: usize, title: impl Into<String>) {
+        let applied = applied.min(total);
+        let title = if applied == 0 {
+            "start of undo history".into()
+        } else {
+            title.into()
+        };
+        self.leave_success(format!("{title} · {applied} undo · {} redo", total - applied));
+        self.undo_position = Some(UndoPosition { applied, total, title });
+    }
+
+    pub(crate) fn undo_position(&self) -> Option<(usize, usize, &str)> {
+        self.undo_position
+            .as_ref()
+            .map(|position| (position.applied, position.total, position.title.as_str()))
+    }
+
+    pub(crate) fn dismiss_undo_position(&mut self) {
+        self.undo_position = None;
+    }
+
     pub(crate) fn configure_hidden_filter(&mut self, present: bool) {
         self.has_hidden_filter = present;
     }
@@ -1310,6 +1344,9 @@ impl App {
 
     pub fn update(&mut self, action: Action) -> Vec<Effect> {
         self.notice = None;
+        if !matches!(&action, Action::Undo | Action::Redo) {
+            self.undo_position = None;
+        }
         if !matches!(&action, Action::Forget) {
             self.forget_confirmation = None;
         }
@@ -1381,6 +1418,8 @@ impl App {
         }
         match action {
             Action::Cancelled if self.state == State::Cancelling => self.state = State::Cancelled,
+            Action::Undo if self.undo_redo_allowed() => return vec![Effect::Undo],
+            Action::Redo if self.undo_redo_allowed() => return vec![Effect::Redo],
             Action::MoveUp if self.changes_focus.is_some() => self.move_changes(1, false),
             Action::MoveDown if self.changes_focus.is_some() => self.move_changes(1, true),
             Action::MoveUpBy(distance) if self.changes_focus.is_some() => self.move_changes(distance, false),
@@ -1906,6 +1945,13 @@ impl App {
         Vec::new()
     }
 
+    fn undo_redo_allowed(&self) -> bool {
+        self.pending_rebase_conflict.is_none()
+            && !self.rebase_continuation_pending
+            && !self.worktree_conflicted
+            && self.reachable_rows.is_none()
+    }
+
     pub(crate) fn start_lane_computation(&mut self) -> Option<Vec<SharedCommitRow>> {
         match self.state {
             State::Loading => {
@@ -3588,6 +3634,42 @@ mod tests {
         app.finish_lane_computation(rows, graph, lane_time);
     }
 
+    #[test]
+    fn undo_and_redo_retain_their_position_until_another_action() {
+        let mut app = App::new(2);
+        app.show_undo_position(9, 4, "reword commit");
+        assert_eq!(app.undo_position(), Some((4, 4, "reword commit")));
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("reword commit · 4 undo · 0 redo".into())
+        );
+
+        assert_eq!(app.update(Action::Undo), vec![Effect::Undo]);
+        assert_eq!(app.undo_position(), Some((4, 4, "reword commit")));
+        app.leave_error("undo failed");
+        assert_eq!(app.update(Action::Redo), vec![Effect::Redo]);
+        assert_eq!(app.undo_position(), Some((4, 4, "reword commit")));
+
+        app.show_undo_position(0, 4, "ignored at the sentinel");
+        assert_eq!(app.undo_position(), Some((0, 4, "start of undo history")));
+        assert_eq!(
+            app.notice().map(|notice| notice.text),
+            Some("start of undo history · 0 undo · 4 redo".into())
+        );
+        assert!(app.update(Action::MoveDown).is_empty());
+        assert_eq!(app.undo_position(), None, "ordinary movement dismisses undo progress");
+    }
+
+    #[test]
+    fn mandatory_prompts_block_undo_without_dismissing_its_position() {
+        let mut app = App::new(2);
+        app.show_undo_position(1, 2, "reword commit");
+        app.arm_rebase_continuation();
+
+        assert!(app.update(Action::Undo).is_empty());
+        assert_eq!(app.undo_position(), Some((1, 2, "reword commit")));
+    }
+
     #[test]
     fn cycles_duplicate_change_ids_and_wraps() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 512ce4eba08..c0fb0a36b83 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -7,7 +7,6 @@ use std::{
 
 use anyhow::{Context, Result};
 use clap::Parser;
-use gix::prelude::ReferenceExt;
 use ratatui::text::Line;
 
 mod enrich;
@@ -167,6 +166,7 @@ impl Platform {
                         let selected = outcome.selected.context("amending did not produce a selection")?;
                         println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
                         print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
+                        record_undo(&output_repository, "amend", Ok(outcome.ref_changes));
                     }
                     None => println!("nothing to amend"),
                 }
@@ -421,16 +421,8 @@ fn resolve_commit(
 ) -> Result<(gix::ObjectId, Option<crate::history::HistoryGraph>)> {
     let revision = gix::path::os_str_into_bstr(revision)
         .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
-    match repository.rev_parse_single(revision) {
-        Ok(id) => {
-            let id = id
-                .object()
-                .with_context(|| format!("could not read {description}"))?
-                .peel_to_commit()
-                .with_context(|| format!("{description} does not resolve to a commit"))?
-                .id;
-            Ok((id, None))
-        }
+    match crate::history::resolve_revision(repository, revision) {
+        Ok((id, _reference)) => Ok((id, None)),
         Err(revision_error) => {
             let graph = crate::edit::loaded_view_graph(repository)?;
             let resolved = std::str::from_utf8(revision)
@@ -447,34 +439,42 @@ fn resolve_commit(
 }
 
 fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
-    for pin in create_pins(repository, &args.revisions)? {
-        println!("{}", display_pin(repository, &pin)?);
+    let pins = create_pins(repository, &args.revisions)?;
+    for (pin, _created) in &pins {
+        println!("{}", display_pin(repository, pin)?);
     }
+    record_undo(
+        repository,
+        "pin commit",
+        Ok(pins
+            .into_iter()
+            .filter_map(|(pin, created)| {
+                created.then_some(crate::edit::undo::RefChange {
+                    name: pin.name,
+                    before: crate::edit::undo::State::Missing,
+                    after: match pin.target {
+                        gix::refs::Target::Object(id) => crate::edit::undo::State::Object(id),
+                        gix::refs::Target::Symbolic(name) => crate::edit::undo::State::Symbolic(name),
+                    },
+                })
+            })
+            .collect()),
+    );
     Ok(())
 }
 
-fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<Vec<crate::history::Pin>> {
+fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<Vec<(crate::history::Pin, bool)>> {
     let mut seen = HashSet::new();
     let targets = revisions
         .iter()
         .map(|revision| {
             let revision = gix::path::os_str_into_bstr(revision)
                 .with_context(|| format!("revision {} is not valid UTF-8", revision.to_string_lossy()))?;
-            let spec = repository
-                .rev_parse(revision)
+            let (id, reference) = crate::history::resolve_revision(repository, revision)
                 .with_context(|| format!("could not resolve revision {revision:?}"))?;
-            let reference = spec.first_reference().cloned();
-            let id = spec
-                .single()
-                .with_context(|| format!("revision {revision:?} does not name a single object"))?
-                .object()
-                .context("could not read pin target")?
-                .peel_to_commit()
-                .context("pin target does not resolve to a commit")?
-                .id;
             let target = match reference {
-                Some(reference) if reference.clone().attach(repository).peel_to_commit()?.id == id => {
-                    gix::refs::Target::Symbolic(reference.name)
+                Some(reference) if repository.find_reference(reference.as_ref())?.peel_to_commit()?.id == id => {
+                    gix::refs::Target::Symbolic(reference)
                 }
                 _ => gix::refs::Target::Object(id),
             };
@@ -484,9 +484,7 @@ fn create_pins(repository: &gix::Repository, revisions: &[OsString]) -> Result<V
     targets
         .into_iter()
         .filter(|(target, _id)| seen.insert(target.clone()))
-        .map(|(target, id)| {
-            crate::edit::time_travel::create_or_reuse_pin(repository, target, id, "tix pin").map(|(pin, _created)| pin)
-        })
+        .map(|(target, id)| crate::edit::time_travel::create_or_reuse_pin(repository, target, id, "tix pin"))
         .collect()
 }
 
@@ -510,6 +508,7 @@ fn edit_head(
             let selected = outcome.selected.context("editing HEAD did not produce a selection")?;
             println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
             print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
+            record_undo(&output_repository, verb, Ok(outcome.ref_changes));
         }
         None => println!("nothing to {verb}"),
     }
@@ -538,9 +537,20 @@ fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph, args
     let selected = outcome.selected.context("splitting did not produce a selection")?;
     println!("{}", crate::change_id::display(&output_repository, selected, 7)?);
     print_ref_rewrites(&output_repository, &outcome.ref_rewrites)?;
+    record_undo(&output_repository, "split commit", Ok(outcome.ref_changes));
     Ok(())
 }
 
+pub(super) fn record_undo(
+    repository: &gix::Repository,
+    title: &str,
+    changes: Result<Vec<crate::edit::undo::RefChange>>,
+) {
+    if let Err(err) = changes.and_then(|changes| crate::edit::undo::record(repository, title, &changes).map(|_| ())) {
+        eprintln!("warning: operation completed, but undo history was not updated: {err:#}");
+    }
+}
+
 fn print_ref_rewrites(repository: &gix::Repository, rewrites: &[crate::edit::rebase::RefRewrite]) -> Result<()> {
     for line in ref_rewrite_lines(repository, rewrites)? {
         println!("{line}");
@@ -1166,13 +1176,13 @@ mod tests {
         let short_main = main.to_hex_with_len(7).to_string();
         let pins = create_pins(&repository, &revisions(&["main", "v1", "main~1", &short_main]))?;
         assert_eq!(
-            pins.iter().map(|pin| pin.id).collect::<Vec<_>>(),
+            pins.iter().map(|(pin, _created)| pin.id).collect::<Vec<_>>(),
             [main, root, parent, main],
             "distinct pin targets preserve argument order even when IDs match"
         );
         assert_eq!(
             pins.iter()
-                .map(|pin| pin.target.try_name().is_some())
+                .map(|(pin, _created)| pin.target.try_name().is_some())
                 .collect::<Vec<_>>(),
             [true, true, false, false],
             "direct reference names follow symbolically while derived revisions and IDs stay fixed"
@@ -1184,9 +1194,9 @@ mod tests {
         );
 
         let repeated = create_pins(&repository, &revisions(&["main"]))?;
-        assert_eq!(repeated[0].name, pins[0].name, "an existing symbolic pin is reused");
+        assert_eq!(repeated[0].0.name, pins[0].0.name, "an existing symbolic pin is reused");
         assert_eq!(crate::history::all_pins(&repository)?.len(), 4);
-        let display = display_pin(&repository, &pins[0])?;
+        let display = display_pin(&repository, &pins[0].0)?;
         let (label, ids) = display.split_once(' ').context("pin output has a label and IDs")?;
         assert!(label.starts_with("pin:"), "output names the pin");
         assert_eq!(
@@ -1202,7 +1212,7 @@ mod tests {
         )?;
         let followed = crate::history::all_pins(&repository)?
             .into_iter()
-            .find(|pin| pin.name == pins[0].name)
+            .find(|pin| pin.name == pins[0].0.name)
             .context("the symbolic pin remains")?;
         assert_eq!(followed.id, parent, "the symbolic pin follows the moved branch");
         Ok(())
diff --git a/gix-tix/src/command/enrich.rs b/gix-tix/src/command/enrich.rs
index 0f718a0ae14..75c47b6e6dd 100644
--- a/gix-tix/src/command/enrich.rs
+++ b/gix-tix/src/command/enrich.rs
@@ -49,7 +49,19 @@ pub(super) fn run(repository: gix::Repository, command: Command) -> Result<()> {
     match command {
         Command::Commit(Commit::Todo(args)) => {
             let target = resolve(&repository, &args.target)?;
-            let enrichment = crate::enrich::ensure_todo(&repository, target, !args.clear)?;
+            let reference = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+            let (enrichment, changes) = tracked_ref_update(&repository, reference, |repository| {
+                crate::enrich::ensure_todo(repository, target, !args.clear)
+            })?;
+            super::record_undo(
+                &repository,
+                if enrichment.todo {
+                    "mark commit todo"
+                } else {
+                    "clear commit todo"
+                },
+                changes,
+            );
             feedback(
                 &repository,
                 target,
@@ -64,7 +76,19 @@ pub(super) fn run(repository: gix::Repository, command: Command) -> Result<()> {
         Command::Commit(Commit::GitNote(args)) => edit_git_note(&repository, &args),
         Command::Tree(Tree::ChecksPass(args)) => {
             let target = resolve(&repository, &args.target)?;
-            let enrichment = crate::enrich::ensure_checks_pass(&repository, target, !args.clear)?;
+            let reference = crate::enrich::TREE_REF_NAME.try_into().expect("valid tree enrich ref");
+            let (enrichment, changes) = tracked_ref_update(&repository, reference, |repository| {
+                crate::enrich::ensure_checks_pass(repository, target, !args.clear)
+            })?;
+            super::record_undo(
+                &repository,
+                if enrichment.checks_pass {
+                    "mark tree checks-pass"
+                } else {
+                    "clear tree checks-pass"
+                },
+                changes,
+            );
             feedback(
                 &repository,
                 target,
@@ -87,6 +111,24 @@ fn feedback(repository: &gix::Repository, target: gix::ObjectId, status: &str) -
     Ok(())
 }
 
+fn tracked_ref_update<T>(
+    repository: &gix::Repository,
+    name: gix::refs::FullName,
+    update: impl FnOnce(&gix::Repository) -> Result<T>,
+) -> Result<(T, Result<Vec<crate::edit::undo::RefChange>>)> {
+    let before = crate::edit::undo::state(repository, name.as_ref());
+    let value = update(repository)?;
+    let changes = before.and_then(|before| {
+        crate::edit::undo::state(repository, name.as_ref()).map(|after| {
+            (before != after)
+                .then_some(crate::edit::undo::RefChange { name, before, after })
+                .into_iter()
+                .collect()
+        })
+    });
+    Ok((value, changes))
+}
+
 fn edit_note(repository: &gix::Repository, args: &Target) -> Result<()> {
     let target = resolve(repository, args)?;
     let enrichment = crate::enrich::load(
@@ -102,16 +144,23 @@ fn edit_note(repository: &gix::Repository, args: &Target) -> Result<()> {
     )?;
     let cleaned = crate::edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
     let desired = (!cleaned.is_empty()).then_some(cleaned.as_bstr());
-    let status = if enrichment.note.as_ref().map(|note| note.as_bstr()) == desired {
-        "note unchanged"
+    let (status, changes) = if enrichment.note.as_ref().map(|note| note.as_bstr()) == desired {
+        ("note unchanged", Ok(Vec::new()))
     } else {
-        crate::enrich::set_note(repository, target, desired.map(AsRef::as_ref))?;
-        if desired.is_some() {
-            "saved note"
-        } else {
-            "cleared note"
-        }
+        let reference = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+        let (_, changes) = tracked_ref_update(repository, reference, |repository| {
+            crate::enrich::set_note(repository, target, desired.map(AsRef::as_ref))
+        })?;
+        (
+            if desired.is_some() {
+                "saved note"
+            } else {
+                "cleared note"
+            },
+            changes,
+        )
     };
+    super::record_undo(repository, "edit commit note", changes);
     feedback(repository, target, status)
 }
 
@@ -136,18 +185,27 @@ fn edit_git_note(repository: &gix::Repository, args: &Target) -> Result<()> {
         &format!("tix-git-note-{}-{}.md", std::process::id(), target.to_hex_with_len(7)),
     )?;
     let cleaned = crate::edit::reword::cleanup_message(edited.as_deref().unwrap_or(&document), None);
-    let status = if cleaned == document {
-        "Git note unchanged"
+    let (status, changes) = if cleaned == document {
+        ("Git note unchanged", Ok(Vec::new()))
     } else {
         let saved = !cleaned.is_empty();
-        crate::set_git_note(
-            repository,
-            reference.as_ref(),
-            target,
-            saved.then_some(cleaned.as_ref()),
-        )?;
-        if saved { "saved Git note" } else { "cleared Git note" }
+        let (_, changes) = tracked_ref_update(repository, reference.clone(), |_repository| {
+            let data: Option<&[u8]> = saved.then_some(cleaned.as_ref());
+            match data {
+                Some(data) => notes
+                    .add_to_ref(reference.as_ref(), target, data)
+                    .map_err(gix::Exn::into_error)
+                    .context("could not save Git note")?,
+                None => notes
+                    .remove(reference.as_bstr(), target)
+                    .map_err(gix::Exn::into_error)
+                    .context("could not remove Git note")?,
+            };
+            Ok(())
+        })?;
+        (if saved { "saved Git note" } else { "cleared Git note" }, changes)
     };
+    super::record_undo(repository, "edit Git note", changes);
     feedback(repository, target, status)
 }
 
diff --git a/gix-tix/src/command/new.rs b/gix-tix/src/command/new.rs
index 3d6f21ed96d..3482d0c8d2e 100644
--- a/gix-tix/src/command/new.rs
+++ b/gix-tix/src/command/new.rs
@@ -46,7 +46,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("author is not valid UTF-8")?;
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
-    let prepared = crate::edit::create::prepare_from(repository, parent, source, author.as_deref(), args.todo)?;
+    let prepared = crate::edit::create::prepare_from(repository, parent, source, author, args.todo)?;
     if prepared.is_empty && !args.allow_empty {
         anyhow::bail!("the new commit would be empty; use --allow-empty to create it anyway");
     }
@@ -79,6 +79,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         .context("creating a commit did not produce a selection")?;
     println!("{}", crate::change_id::display(&repository, selected, 7)?);
     super::print_ref_rewrites(&repository, &outcome.ref_rewrites)?;
+    super::record_undo(&repository, "create commit", Ok(outcome.ref_changes));
     Ok(())
 }
 
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 40c4e4eaf64..ee519a989ed 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -173,14 +173,9 @@ fn prepare(repo: &gix::Repository, args: &Todo) -> Result<todo::Prepared> {
 fn resolve_commit(repo: &gix::Repository, revision: &OsStr, description: &str) -> Result<ObjectId> {
     let revision =
         gix::path::os_str_into_bstr(revision).with_context(|| format!("{description} is not valid UTF-8"))?;
-    let id = repo
-        .rev_parse_single(revision)
-        .with_context(|| format!("could not resolve {description}"))?;
-    id.object()
-        .with_context(|| format!("could not read {description}"))?
-        .try_into_commit()
-        .with_context(|| format!("{description} does not name a commit"))?;
-    Ok(id.detach())
+    crate::history::resolve_revision(repo, revision)
+        .with_context(|| format!("could not resolve {description}"))
+        .map(|(id, _reference)| id)
 }
 
 fn apply(repo: gix::Repository, args: Apply) -> Result<()> {
@@ -216,14 +211,29 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
     match rebase::perform_plan(&repo, &graph, parsed.plan)? {
         rebase::PlanPerform::Complete(outcome) => {
             let revisions = mapped_revisions(&tips, |id| outcome.map(id));
-            if let Some(selected) = outcome.selected {
-                let notice = edit::time_travel::checkout_plan(&repository_path, bare, &outcome, &revisions, false)?;
+            let changes = if let Some(selected) = outcome.selected {
+                let (notice, changes) = match edit::time_travel::checkout_plan_reporting(
+                    &repository_path,
+                    bare,
+                    &outcome,
+                    &revisions,
+                    false,
+                ) {
+                    Ok(result) => result,
+                    Err(err) => {
+                        super::record_undo(&repo, "rebase history", Ok(outcome.ref_changes));
+                        return Err(err);
+                    }
+                };
                 let notice = notice.unwrap_or_else(|| "rebased history".into());
                 println!("{}", super::notice_with_change_id(&repo, &notice, selected)?);
+                changes
             } else {
                 println!("rebased history");
-            }
+                outcome.ref_changes.clone()
+            };
             super::print_ref_rewrites(&repo, &outcome.ref_rewrites)?;
+            super::record_undo(&repo, "rebase history", Ok(changes));
             Ok(())
         }
         rebase::PlanPerform::Conflict(mut conflict) => {
@@ -261,9 +271,14 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
                     format!("could not write continuation rebase todo at {}", destination.display())
                 })?;
             }
-            let materialized =
-                edit::time_travel::materialize_plan_conflict(conflict, &repository_path, bare, &revisions, false);
-            let (notice, _, ref_rewrites) = match materialized {
+            let materialized = edit::time_travel::materialize_plan_conflict_reporting(
+                conflict,
+                &repository_path,
+                bare,
+                &revisions,
+                false,
+            );
+            let (notice, _, ref_rewrites, ref_changes) = match materialized {
                 Ok(materialized) => materialized,
                 Err(err) => {
                     if destination != Path::new("-") {
@@ -273,6 +288,7 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
                 }
             };
             super::print_ref_rewrites(&repo, &ref_rewrites)?;
+            super::record_undo(&repo, "materialize rebase conflict", Ok(ref_changes));
             eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
             anyhow::bail!("rebase stopped at a materialized conflict")
         }
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 362ed458abf..2efacd17535 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -137,6 +137,7 @@ fn finish(repository: &gix::Repository, outcome: crate::edit::reword::Outcome) -
         None => println!("no reword performed: the edited commit was unchanged"),
     }
     super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
+    super::record_undo(repository, "reword commit", Ok(outcome.ref_changes));
     Ok(())
 }
 
@@ -145,12 +146,18 @@ fn finish_editor(
     outcome: crate::edit::reword::Outcome,
     original: gix::ObjectId,
 ) -> Result<()> {
+    let title = if outcome.commit.is_some() {
+        "reword commit"
+    } else {
+        "edit commit enrichment"
+    };
     match (outcome.commit, outcome.enrichment) {
         (Some(id), _) => println!("{}", crate::change_id::display(repository, id, 7)?),
         (None, Some(_)) => println!("{}", crate::change_id::display(repository, original, 7)?),
         (None, None) => println!("no reword performed: the edited commit was unchanged"),
     }
     super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
+    super::record_undo(repository, title, Ok(outcome.ref_changes));
     Ok(())
 }
 
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index 12ad08dbb6e..a2ef29debfb 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -98,6 +98,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
             notice,
             selected,
             ref_rewrites,
+            ref_changes,
         } => {
             let repository = crate::open_repository(&repository_path, bare, false)
                 .context("could not reopen repository after time-travel")?;
@@ -110,12 +111,14 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
                 )?
             );
             super::print_ref_rewrites(&repository, &ref_rewrites)?;
+            super::record_undo(&repository, "time travel", Ok(ref_changes));
         }
         crate::edit::time_travel::Perform::Conflict(conflict) if args.materialize_conflicts => {
-            let (notice, _, ref_rewrites) = conflict.accept()?;
+            let (notice, _, ref_rewrites, ref_changes) = conflict.accept()?;
             let repository = crate::open_repository(&repository_path, bare, false)
                 .context("could not reopen repository after materializing time-travel")?;
             super::print_ref_rewrites(&repository, &ref_rewrites)?;
+            super::record_undo(&repository, "materialize time-travel conflict", Ok(ref_changes));
             anyhow::bail!("{notice}");
         }
         crate::edit::time_travel::Perform::Conflict(_) => {
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 13f6250a8e8..31711039d43 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -273,6 +273,7 @@ fn worktree_tree_with_changes_inner(
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
+#[cfg(test)]
 pub(crate) fn apply(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
@@ -315,7 +316,7 @@ fn apply_commit(
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let outcome = rebase::perform(
+    let mut outcome = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Insert {
@@ -331,37 +332,64 @@ fn apply_commit(
         .selected
         .context("inserting a commit did not produce a selection")?;
     drop(repo);
-    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+    let repo = crate::open_repository(&repository_path, bare, false)?;
+    let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let before = super::undo::state(&repo, name.as_ref())?;
+    crate::enrich::apply_headers(&repo, id, &enrichment)
         .context("the commit was created, but its enrichment could not be saved")?;
+    let after = super::undo::state(&repo, name.as_ref())?;
+    if before != after {
+        outcome.ref_changes.push(super::undo::RefChange { name, before, after });
+    }
     Ok(outcome)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
+#[cfg(test)]
 pub(crate) fn apply_fork(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edited: &[u8],
+) -> Result<ObjectId> {
+    apply_fork_reporting(repo, graph, prepared, edited)?
+        .selected
+        .context("forking a commit did not produce a selection")
+}
+
+pub(crate) fn apply_fork_reporting(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     edited: &[u8],
-) -> Result<ObjectId> {
+) -> Result<rebase::Outcome> {
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
     let parent = prepared.parent.context("a fork commit requires a parent")?;
     let (commit, enrichment) = commit_from_edit(&prepared, edited)?;
-    let id = rebase::perform(
+    let mut outcome = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Fork { anchor: parent, commit },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIs,
     )?
-    .complete()?
-    .selected
-    .context("forking a commit did not produce a selection")?;
+    .complete()?;
+    let id = outcome
+        .selected
+        .context("forking a commit did not produce a selection")?;
     drop(repo);
-    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+    let repo = crate::open_repository(&repository_path, bare, false)?;
+    let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let before = super::undo::state(&repo, name.as_ref())?;
+    crate::enrich::apply_headers(&repo, id, &enrichment)
         .context("the fork was created, but its enrichment could not be saved")?;
-    Ok(id)
+    let after = super::undo::state(&repo, name.as_ref())?;
+    if before != after {
+        outcome.ref_changes.push(super::undo::RefChange { name, before, after });
+    }
+    Ok(outcome)
 }
 
 pub(super) fn commit_from_edit(
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index c1335c41cb5..ed202c1082c 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -8,6 +8,7 @@ use super::rebase;
 pub(crate) struct Outcome {
     pub selected: Option<ObjectId>,
     pub review_return: Option<gix::refs::FullName>,
+    pub ref_changes: Vec<super::undo::RefChange>,
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -50,9 +51,11 @@ pub(crate) fn perform(repo: gix::Repository, graph: &crate::history::HistoryGrap
             deletions,
         )
     }?;
+    let outcome = result.complete()?;
     Ok(Outcome {
-        selected: result.complete()?.selected,
+        selected: outcome.selected,
         review_return,
+        ref_changes: outcome.ref_changes,
     })
 }
 
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 7ec4270f2e8..78e2a88be3a 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -10,6 +10,7 @@ pub enum Kind {
     Spill,
 }
 
+#[cfg(test)]
 #[tracing::instrument(skip_all, fields(?kind))]
 pub fn perform(
     repo: gix::Repository,
@@ -20,6 +21,15 @@ pub fn perform(
     Ok(perform_inner(repo, graph, kind, selected_path, false)?.and_then(|outcome| outcome.selected))
 }
 
+pub(crate) fn perform_with_changes(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    kind: Kind,
+    selected_path: Option<(&PathChange, Option<ObjectId>)>,
+) -> Result<Option<rebase::Outcome>> {
+    perform_inner(repo, graph, kind, selected_path, false)
+}
+
 pub(crate) fn perform_reporting(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 3d6ad33e2f0..14e8b814030 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -14,6 +14,7 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
                 .name()
                 .as_bstr()
                 .starts_with(crate::history::REVIEW_STASH_PREFIX)
+            || undo::is_queue_ref(reference.name().as_bstr())
         {
             continue;
         }
@@ -84,6 +85,7 @@ pub(crate) mod split;
 pub(crate) mod stash;
 pub(crate) mod time_travel;
 pub(crate) mod todo;
+pub(crate) mod undo;
 
 #[tracing::instrument(skip_all, fields(filename))]
 pub(crate) fn edit_document(
@@ -165,6 +167,27 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn edit_graph_ignores_undo_queue_retention_commits() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let path = fixture.path();
+        let retained = String::from_utf8(git(
+            path,
+            &["commit-tree", "HEAD^{tree}", "-p", "HEAD", "-m", "undo-only"],
+        )?)?;
+        let retained = retained.trim();
+        git(path, &["update-ref", undo::TIP_REF, retained])?;
+        git(path, &["update-ref", undo::CURSOR_REF, retained])?;
+
+        let repo = crate::test_repository::open(path)?;
+        let retained = gix::ObjectId::from_hex(retained.as_bytes())?;
+        assert!(
+            loaded_graph(&repo)?.parents_of(retained).is_none(),
+            "undo retention commits never enter the editable graph"
+        );
+        Ok(())
+    }
+
     #[test]
     fn edit_graph_excludes_unrelated_descendant_merges() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 76c9d5d10dd..a54d8f4604c 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -265,6 +265,7 @@ pub(crate) struct Outcome {
     pub checkout_reference: Option<gix::refs::FullName>,
     pub deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
     pub ref_rewrites: Vec<RefRewrite>,
+    pub ref_changes: Vec<super::undo::RefChange>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
@@ -317,6 +318,7 @@ impl Conflict {
             commit: self.commit,
             deferred_ref_deletions: outcome.deferred_ref_deletions,
             ref_rewrites: outcome.ref_rewrites,
+            ref_changes: outcome.ref_changes,
             rewritten: outcome.rewritten,
         })
     }
@@ -329,6 +331,7 @@ pub(crate) struct PersistedConflict {
     pub(crate) commit: ObjectId,
     pub(crate) deferred_ref_deletions: Vec<(gix::refs::FullName, ObjectId)>,
     pub(crate) ref_rewrites: Vec<RefRewrite>,
+    pub(crate) ref_changes: Vec<super::undo::RefChange>,
     rewritten: HashMap<ObjectId, Option<ObjectId>>,
 }
 
@@ -410,7 +413,8 @@ pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[O
         if matches!(
             reference.name().category(),
             Some(Category::Tag | Category::RemoteBranch)
-        ) {
+        ) || super::undo::is_queue_ref(reference.name().as_bstr())
+        {
             continue;
         }
         let Some(old) = reference.try_id().map(gix::Id::detach) else {
@@ -1786,6 +1790,7 @@ impl Prepared {
             checkout_reference: self.checkout_reference.clone(),
             deferred_ref_deletions,
             ref_rewrites: updated_refs.rewritten,
+            ref_changes: updated_refs.changes,
             rewritten: std::mem::take(&mut self.rewritten),
         })
     }
@@ -2436,7 +2441,8 @@ fn update_refs(
             if matches!(
                 reference.name().category(),
                 Some(Category::Tag | Category::RemoteBranch)
-            ) {
+            ) || super::undo::is_queue_ref(reference.name().as_bstr())
+            {
                 continue;
             }
             let Some(old) = reference.try_id().map(gix::Id::detach) else {
@@ -2543,13 +2549,16 @@ fn update_refs(
         return Ok(UpdatedRefs::default());
     }
     let mut time = gix::date::parse::TimeBuf::default();
-    repo.edit_references_as(edits, Some(committer.to_ref(&mut time)))
+    let applied = repo
+        .edit_references_as(edits, Some(committer.to_ref(&mut time)))
         .context("could not update references after rebasing")?;
+    let changes = super::undo::changes_from_edits(applied)?;
     ref_rewrites.sort_by(|a, b| a.name.cmp(&b.name));
     ref_rewrites.dedup();
     Ok(UpdatedRefs {
         rollback,
         rewritten: ref_rewrites,
+        changes,
     })
 }
 
@@ -2557,6 +2566,7 @@ fn update_refs(
 struct UpdatedRefs {
     rollback: Vec<RefEdit>,
     rewritten: Vec<RefRewrite>,
+    changes: Vec<super::undo::RefChange>,
 }
 
 fn pin_name(
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 8abcab80ceb..ecfc683287d 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -27,6 +27,7 @@ pub(crate) struct Outcome {
     pub commit: Option<gix::ObjectId>,
     pub enrichment: Option<crate::enrich::Enrichment>,
     pub ref_rewrites: Vec<rebase::RefRewrite>,
+    pub ref_changes: Vec<super::undo::RefChange>,
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -127,11 +128,26 @@ pub(crate) fn apply(
         .as_ref()
         .and_then(|outcome| outcome.selected)
         .filter(|new_id| *new_id != old_id);
+    let enrich_ref: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let enrich_before = super::undo::state(&repo, enrich_ref.as_ref())?;
     let enrichment = crate::enrich::apply_headers(&repo, commit.unwrap_or(old_id), &edit.enrichment)?;
+    let enrich_after = super::undo::state(&repo, enrich_ref.as_ref())?;
+    let (ref_rewrites, mut ref_changes) = rebased.map_or_else(
+        || (Vec::new(), Vec::new()),
+        |outcome| (outcome.ref_rewrites, outcome.ref_changes),
+    );
+    if enrich_before != enrich_after {
+        ref_changes.push(super::undo::RefChange {
+            name: enrich_ref,
+            before: enrich_before,
+            after: enrich_after,
+        });
+    }
     Ok(Outcome {
         commit,
         enrichment,
-        ref_rewrites: rebased.map_or_else(Vec::new, |outcome| outcome.ref_rewrites),
+        ref_rewrites,
+        ref_changes,
     })
 }
 
@@ -162,6 +178,7 @@ pub(crate) fn apply_message_reporting(
             commit: None,
             enrichment: None,
             ref_rewrites: Vec::new(),
+            ref_changes: Vec::new(),
         });
     }
     if let Some(author) = changed_author {
@@ -173,6 +190,7 @@ pub(crate) fn apply_message_reporting(
         commit: outcome.selected.filter(|new_id| *new_id != old_id),
         enrichment: None,
         ref_rewrites: outcome.ref_rewrites,
+        ref_changes: outcome.ref_changes,
     })
 }
 
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index d884766ea21..81701ac22e3 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -66,6 +66,7 @@ pub(crate) fn prepare(mut repo: gix::Repository, todo: bool) -> Result<Prepared>
     })
 }
 
+#[cfg(test)]
 #[tracing::instrument(skip_all, fields(target = %prepared.target))]
 pub(crate) fn apply(
     repo: gix::Repository,
@@ -90,7 +91,7 @@ pub(crate) fn apply_reporting(
         .set_object_memory(std::mem::take(&mut prepared.create.objects));
     let (mut upper, enrichment) = create::commit_from_edit(&prepared.create, edited)?;
     upper.tree = prepared.tree;
-    let outcome = rebase::perform(
+    let mut outcome = rebase::perform(
         &repo,
         graph,
         rebase::Edit::Split {
@@ -104,8 +105,15 @@ pub(crate) fn apply_reporting(
     .complete()?;
     let id = outcome.selected.context("splitting HEAD did not produce a selection")?;
     drop(repo);
-    crate::enrich::apply_headers(&crate::open_repository(&repository_path, bare, false)?, id, &enrichment)
+    let repo = crate::open_repository(&repository_path, bare, false)?;
+    let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let before = super::undo::state(&repo, name.as_ref())?;
+    crate::enrich::apply_headers(&repo, id, &enrichment)
         .context("the commit was split, but its enrichment could not be saved")?;
+    let after = super::undo::state(&repo, name.as_ref())?;
+    if before != after {
+        outcome.ref_changes.push(super::undo::RefChange { name, before, after });
+    }
     Ok(outcome)
 }
 
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 0336d318388..b17d71084ed 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -26,6 +26,7 @@ pub(crate) enum Perform {
         notice: Option<String>,
         selected: ObjectId,
         ref_rewrites: Vec<super::rebase::RefRewrite>,
+        ref_changes: Vec<super::undo::RefChange>,
     },
     Conflict(Conflict),
 }
@@ -53,6 +54,7 @@ pub(crate) struct Conflict {
     revisions: Vec<OsString>,
     include_worktrees: bool,
     ref_rewrites: Vec<super::rebase::RefRewrite>,
+    ref_changes: Vec<super::undo::RefChange>,
 }
 
 impl Conflict {
@@ -60,12 +62,30 @@ impl Conflict {
         self.rebase.original()
     }
 
+    pub(crate) fn prepend_ref_changes(&mut self, mut changes: Vec<super::undo::RefChange>) {
+        changes.append(&mut self.ref_changes);
+        self.ref_changes = changes;
+    }
+
+    pub(crate) fn into_ref_changes(self) -> Vec<super::undo::RefChange> {
+        self.ref_changes
+    }
+
     #[tracing::instrument(skip_all, fields(commit_id = %self.rebase.original()))]
-    pub(crate) fn accept(self) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
+    pub(crate) fn accept(
+        self,
+    ) -> Result<(
+        String,
+        ObjectId,
+        Vec<super::rebase::RefRewrite>,
+        Vec<super::undo::RefChange>,
+    )> {
         let mut conflict = self.rebase.persist()?;
         let mut ref_rewrites = self.ref_rewrites;
+        let mut ref_changes = self.ref_changes;
         ref_rewrites.append(&mut conflict.ref_rewrites);
-        let notice = move_head_to(
+        ref_changes.append(&mut conflict.ref_changes);
+        let (notice, mut checkout_changes) = move_head_to_reporting(
             &self.repository_path,
             self.bare,
             conflict.commit,
@@ -73,29 +93,41 @@ impl Conflict {
             &self.revisions,
             self.include_worktrees,
             |id| conflict.map(id),
-        )?
-        .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
-        delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
+        )?;
+        ref_changes.append(&mut checkout_changes);
+        let mut deletion_changes =
+            delete_deferred_refs(&self.repository_path, self.bare, &conflict.deferred_ref_deletions)?;
+        ref_changes.append(&mut deletion_changes);
         conflict.materialize()?;
         Ok((
-            format!("{notice}; ready to resolve conflicts"),
+            format!(
+                "{}; ready to resolve conflicts",
+                notice.unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)))
+            ),
             conflict.commit,
             ref_rewrites,
+            ref_changes,
         ))
     }
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %conflict.original()))]
-pub(crate) fn materialize_plan_conflict(
+pub(crate) fn materialize_plan_conflict_reporting(
     conflict: super::rebase::PlanConflict,
     repository_path: &Path,
     bare: bool,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<(String, ObjectId, Vec<super::rebase::RefRewrite>)> {
+) -> Result<(
+    String,
+    ObjectId,
+    Vec<super::rebase::RefRewrite>,
+    Vec<super::undo::RefChange>,
+)> {
     let original = conflict.original();
     let mut conflict = conflict.into_conflict().persist()?;
-    let notice = move_head_to(
+    let mut ref_changes = std::mem::take(&mut conflict.ref_changes);
+    let (notice, mut checkout_changes) = move_head_to_reporting(
         repository_path,
         bare,
         conflict.commit,
@@ -103,18 +135,24 @@ pub(crate) fn materialize_plan_conflict(
         revisions,
         include_worktrees,
         |id| conflict.map(id),
-    )?
-    .unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)));
-    delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
+    )?;
+    ref_changes.append(&mut checkout_changes);
+    let mut deletion_changes = delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
+    ref_changes.append(&mut deletion_changes);
     conflict.materialize()?;
     tracing::warn!(commit_id = %original, rewritten_id = %conflict.commit, "materialized rebase-todo conflict");
     Ok((
-        format!("{notice}; ready to resolve conflicts"),
+        format!(
+            "{}; ready to resolve conflicts",
+            notice.unwrap_or_else(|| format!("checked out {}", conflict.commit.to_hex_with_len(7)))
+        ),
         conflict.commit,
         conflict.ref_rewrites,
+        ref_changes,
     ))
 }
 
+#[cfg(test)]
 pub(crate) fn checkout_without_replay(
     repository_path: &Path,
     bare: bool,
@@ -122,9 +160,20 @@ pub(crate) fn checkout_without_replay(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
+    Ok(checkout_without_replay_reporting(repository_path, bare, selected, revisions, include_worktrees)?.0)
+}
+
+pub(crate) fn checkout_without_replay_reporting(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
     move_head(repository_path, bare, selected, revisions, include_worktrees)
 }
 
+#[cfg(test)]
 pub(crate) fn checkout_review_return(
     repository_path: &Path,
     bare: bool,
@@ -132,6 +181,18 @@ pub(crate) fn checkout_review_return(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<(ObjectId, Option<String>)> {
+    let (selected, notice, _) =
+        checkout_review_return_reporting(repository_path, bare, name, revisions, include_worktrees)?;
+    Ok((selected, notice))
+}
+
+pub(crate) fn checkout_review_return_reporting(
+    repository_path: &Path,
+    bare: bool,
+    name: &gix::refs::FullName,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(ObjectId, Option<String>, Vec<super::undo::RefChange>)> {
     let repository = open_repository(repository_path, bare, false).context("could not open review return checkout")?;
     let workdir = repository
         .workdir()
@@ -152,7 +213,7 @@ pub(crate) fn checkout_review_return(
     drop(repository);
     checkout(&workdir, [OsString::from("--force"), OsString::from("HEAD")])
         .context("could not discard the cancelled review checkout")?;
-    let notice = move_head_to(
+    let (notice, ref_changes) = move_head_to_reporting(
         repository_path,
         bare,
         selected,
@@ -161,9 +222,10 @@ pub(crate) fn checkout_review_return(
         include_worktrees,
         |_| None,
     )?;
-    Ok((selected, notice))
+    Ok((selected, notice, ref_changes))
 }
 
+#[cfg(test)]
 pub(crate) fn checkout_plan(
     repository_path: &Path,
     bare: bool,
@@ -171,8 +233,19 @@ pub(crate) fn checkout_plan(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
+    Ok(checkout_plan_reporting(repository_path, bare, outcome, revisions, include_worktrees)?.0)
+}
+
+pub(crate) fn checkout_plan_reporting(
+    repository_path: &Path,
+    bare: bool,
+    outcome: &super::rebase::Outcome,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
     let selected = outcome.selected.context("the rebase plan does not select a checkout")?;
-    let notice = move_head_to(
+    let mut ref_changes = outcome.ref_changes.clone();
+    let (notice, mut checkout_changes) = move_head_to_reporting(
         repository_path,
         bare,
         selected,
@@ -181,8 +254,10 @@ pub(crate) fn checkout_plan(
         include_worktrees,
         |id| outcome.map(id),
     )?;
-    delete_deferred_refs(repository_path, bare, &outcome.deferred_ref_deletions)?;
-    Ok(notice)
+    ref_changes.append(&mut checkout_changes);
+    let mut deletion_changes = delete_deferred_refs(repository_path, bare, &outcome.deferred_ref_deletions)?;
+    ref_changes.append(&mut deletion_changes);
+    Ok((notice, ref_changes))
 }
 
 fn move_head(
@@ -191,8 +266,8 @@ fn move_head(
     selected: ObjectId,
     revisions: &[OsString],
     include_worktrees: bool,
-) -> Result<Option<String>> {
-    move_head_to(
+) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
+    move_head_to_reporting(
         repository_path,
         bare,
         selected,
@@ -203,6 +278,7 @@ fn move_head(
     )
 }
 
+#[cfg(test)]
 fn move_head_to<F>(
     repository_path: &Path,
     bare: bool,
@@ -212,10 +288,36 @@ fn move_head_to<F>(
     include_worktrees: bool,
     map_departure: F,
 ) -> Result<Option<String>>
+where
+    F: FnOnce(ObjectId) -> Option<ObjectId>,
+{
+    Ok(move_head_to_reporting(
+        repository_path,
+        bare,
+        selected,
+        reference,
+        revisions,
+        include_worktrees,
+        map_departure,
+    )?
+    .0)
+}
+
+fn move_head_to_reporting<F>(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+    reference: Option<&gix::refs::FullName>,
+    revisions: &[OsString],
+    include_worktrees: bool,
+    map_departure: F,
+) -> Result<(Option<String>, Vec<super::undo::RefChange>)>
 where
     F: FnOnce(ObjectId) -> Option<ObjectId>,
 {
     let repository = open_repository(repository_path, bare, false).context("could not open repository for checkout")?;
+    let head_name: gix::refs::FullName = "HEAD".try_into().expect("valid reference name");
+    let head_before = super::undo::state(&repository, head_name.as_ref())?;
     let workdir = repository
         .workdir()
         .context("time-travel requires a worktree")?
@@ -229,52 +331,74 @@ where
     let departure = map_departure(head_id);
     drop(head);
     if selected == head_id && head_ref.as_ref() == reference {
-        return Ok(None);
+        return Ok((None, Vec::new()));
     }
+    let mut ref_changes = Vec::new();
     let destination_pin = selected_pin(&repository, selected)?;
     let checkout_detaches = reference.is_none()
         && destination_pin
             .as_ref()
             .is_none_or(|pin| pin.target.try_name().is_none());
-    let head_pin = head_ref
+    let head_pin = match head_ref
         .as_ref()
         .filter(|name| checkout_detaches && name.as_bstr().starts_with(b"refs/heads/"))
-        .map(|name| create_or_update_head_pin(&repository, name, head_id))
-        .transpose()?;
-    let provisional = head_pin
+    {
+        Some(name) => {
+            let (pin, mut changes) = create_or_update_head_pin_reporting(&repository, name, head_id)?;
+            ref_changes.append(&mut changes);
+            Some(pin)
+        }
+        None => None,
+    };
+    let provisional = match head_pin
         .is_none()
         .then_some(departure)
         .flatten()
         .filter(|departure| *departure != selected)
         .filter(|departure| !contains(&repository, *departure, selected))
-        .map(|departure| {
+    {
+        Some(departure) => {
             let target = head_ref.clone().map_or(Target::Object(departure), Target::Symbolic);
-            create_or_reuse_pin(&repository, target, departure, "tix time-travel")
-        })
-        .transpose()?;
+            let (pin, created, mut changes) =
+                create_or_reuse_pin_reporting(&repository, target, departure, "tix time-travel")?;
+            ref_changes.append(&mut changes);
+            Some((pin, created))
+        }
+        None => None,
+    };
+    let head_after_checkout = reference.map_or_else(
+        || match destination_pin.as_ref().map(|pin| &pin.target) {
+            Some(Target::Symbolic(name)) => super::undo::State::Symbolic(name.clone()),
+            Some(Target::Object(id)) => super::undo::State::Object(*id),
+            None => super::undo::State::Object(selected),
+        },
+        |name| super::undo::State::Symbolic(name.clone()),
+    );
     drop(repository);
     let checkout = match (reference, &destination_pin) {
+        (Some(reference), _) if reference.as_bstr().starts_with(b"refs/heads/") => {
+            checkout_branch(&workdir, reference.as_ref())
+        }
         (Some(reference), _) => checkout_reference(repository_path, bare, &workdir, selected, reference),
         (None, Some(pin)) => checkout_pin(&workdir, pin),
         (None, None) => checkout_detached(&workdir, selected),
     };
     if let Err(checkout) = checkout {
-        let cleanup_pin = head_pin
-            .as_ref()
-            .or_else(|| provisional.as_ref().and_then(|(pin, created)| created.then_some(pin)));
-        if let Some(pin) = cleanup_pin {
-            let cleanup = open_repository(repository_path, bare, false)
-                .context("could not reopen repository to remove a provisional pin")
-                .and_then(|repository| delete_pin(&repository, pin));
-            if let Err(cleanup) = cleanup {
-                return Err(checkout.context(format!(
-                    "checkout failed and {} could not be removed: {cleanup:#}",
-                    pin_label(pin)
-                )));
-            }
+        let cleanup = open_repository(repository_path, bare, false)
+            .context("could not reopen repository to restore provisional references")
+            .and_then(|repository| super::undo::apply_reversed_changes(&repository, &ref_changes));
+        if let Err(cleanup) = cleanup {
+            return Err(checkout.context(format!("checkout failed and provisional refs remain: {cleanup:#}")));
         }
         return Err(checkout);
     }
+    if head_before != head_after_checkout {
+        ref_changes.push(super::undo::RefChange {
+            name: head_name,
+            before: head_before,
+            after: head_after_checkout,
+        });
+    }
     let mut notice = reference.map_or_else(
         || {
             destination_pin.as_ref().map_or_else(
@@ -284,15 +408,27 @@ where
         },
         |reference| format!("checked out {}", reference.shorten()),
     );
-    let repository =
-        open_repository(repository_path, bare, false).context("could not reopen repository after time-travel")?;
-    if let Some(pin) = destination_pin
-        && let Err(err) = delete_pin(&repository, &pin)
-    {
-        notice = format!("{notice}; destination pin remains: {err:#}");
+    let repository = match open_repository(repository_path, bare, false) {
+        Ok(repository) => repository,
+        Err(err) => {
+            notice = format!("{notice}; post-checkout cleanup skipped: {err:#}");
+            return Ok((Some(notice), ref_changes));
+        }
+    };
+    if let Some(pin) = destination_pin {
+        match delete_pin_reporting(&repository, &pin) {
+            Ok(mut changes) => ref_changes.append(&mut changes),
+            Err(err) => notice = format!("{notice}; destination pin remains: {err:#}"),
+        }
     }
-    if let Some(addition) = reconcile_head_pin(&repository, &workdir)? {
-        notice = format!("{notice}; {addition}");
+    match reconcile_head_pin_reporting(&repository, &workdir) {
+        Ok((addition, mut changes)) => {
+            ref_changes.append(&mut changes);
+            if let Some(addition) = addition {
+                notice = format!("{notice}; {addition}");
+            }
+        }
+        Err(err) => notice = format!("{notice}; HEAD-pin reconciliation failed: {err:#}"),
     }
     if let Some((provisional, _)) = provisional {
         let snapshot = history::snapshot_ignoring_pin(
@@ -301,21 +437,29 @@ where
             &[],
             include_worktrees,
             Some(provisional.name.as_bstr()),
-        )?;
+        );
+        let snapshot = match snapshot {
+            Ok(snapshot) => snapshot,
+            Err(err) => {
+                notice = format!("{notice}; kept {}: {err:#}", pin_label(&provisional));
+                return Ok((Some(notice), ref_changes));
+            }
+        };
         if snapshot
             .view_tips
             .iter()
             .copied()
             .any(|tip| contains(&repository, provisional.id, tip))
         {
-            if let Err(err) = delete_pin(&repository, &provisional) {
-                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&provisional));
+            match delete_pin_reporting(&repository, &provisional) {
+                Ok(mut changes) => ref_changes.append(&mut changes),
+                Err(err) => notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&provisional)),
             }
         } else {
             notice = format!("{notice}; saved {}", pin_label(&provisional));
         }
     }
-    Ok(Some(notice))
+    Ok((Some(notice), ref_changes))
 }
 
 fn remembered_branch(repository: &gix::Repository) -> Result<RememberedBranch> {
@@ -362,12 +506,22 @@ fn validate_attach(repository: &gix::Repository, head_id: ObjectId, remembered:
     ensure_branch_is_available(repository, remembered.branch.as_ref())
 }
 
+#[cfg(test)]
 pub(crate) fn attach(
     repository_path: &Path,
     bare: bool,
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<String> {
+    Ok(attach_reporting(repository_path, bare, revisions, include_worktrees)?.0)
+}
+
+pub(crate) fn attach_reporting(
+    repository_path: &Path,
+    bare: bool,
+    revisions: &[OsString],
+    include_worktrees: bool,
+) -> Result<(String, Vec<super::undo::RefChange>)> {
     let repository = open_repository(repository_path, bare, false)
         .context("could not open repository to attach the remembered branch")?;
     repository.workdir().context("attaching requires a worktree")?;
@@ -384,16 +538,19 @@ pub(crate) fn attach(
     validate_attach(&repository, head_id, &remembered)?;
 
     let destination_pin = selected_pin(&repository, head_id)?;
-    let provisional = (remembered.branch_tip != head_id && !contains(&repository, remembered.branch_tip, head_id))
-        .then(|| {
-            create_or_reuse_pin(
-                &repository,
-                Target::Object(remembered.branch_tip),
-                remembered.branch_tip,
-                "tix attach departure",
-            )
-        })
-        .transpose()?;
+    let mut ref_changes = Vec::new();
+    let provisional = if remembered.branch_tip != head_id && !contains(&repository, remembered.branch_tip, head_id) {
+        let (pin, created, mut changes) = create_or_reuse_pin_reporting(
+            &repository,
+            Target::Object(remembered.branch_tip),
+            remembered.branch_tip,
+            "tix attach departure",
+        )?;
+        ref_changes.append(&mut changes);
+        Some((pin, created))
+    } else {
+        None
+    };
     let mut edits = Vec::with_capacity(2);
     if remembered.branch_tip != head_id {
         edits.push(checked_ref_edit(
@@ -409,43 +566,57 @@ pub(crate) fn attach(
         Target::Symbolic(remembered.branch.clone()),
         "tix attach",
     ));
-    if let Err(err) = repository
+    let applied = match repository
         .edit_references(edits)
         .context("could not move and attach the remembered branch")
     {
-        return Err(match provisional.as_ref() {
-            Some(pin) => cleanup_new_pins(&repository, std::slice::from_ref(pin), err),
-            None => err,
-        });
-    }
+        Ok(applied) => applied,
+        Err(err) => {
+            return Err(match provisional.as_ref() {
+                Some(pin) => cleanup_new_pins(&repository, std::slice::from_ref(pin), err),
+                None => err,
+            });
+        }
+    };
+    let mut attach_changes = super::undo::changes_from_edits(applied)?;
+    ref_changes.append(&mut attach_changes);
 
     let mut notice = format!(
         "attached {} at {}",
         remembered.branch.shorten(),
         head_id.to_hex_with_len(7)
     );
-    if let Some(pin) = destination_pin
-        && let Err(err) = delete_pin(&repository, &pin)
-    {
-        notice = format!("{notice}; destination pin remains: {err:#}");
+    if let Some(pin) = destination_pin {
+        match delete_pin_reporting(&repository, &pin) {
+            Ok(mut changes) => ref_changes.append(&mut changes),
+            Err(err) => notice = format!("{notice}; destination pin remains: {err:#}"),
+        }
     }
     if let Some((pin, _)) = provisional {
         let snapshot =
-            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()))?;
+            history::snapshot_ignoring_pin(&repository, revisions, &[], include_worktrees, Some(pin.name.as_bstr()));
+        let snapshot = match snapshot {
+            Ok(snapshot) => snapshot,
+            Err(err) => {
+                notice = format!("{notice}; kept {}: {err:#}", pin_label(&pin));
+                return Ok((notice, ref_changes));
+            }
+        };
         if snapshot
             .view_tips
             .iter()
             .copied()
             .any(|tip| contains(&repository, pin.id, tip))
         {
-            if let Err(err) = delete_pin(&repository, &pin) {
-                notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin));
+            match delete_pin_reporting(&repository, &pin) {
+                Ok(mut changes) => ref_changes.append(&mut changes),
+                Err(err) => notice = format!("{notice}; redundant {} remains: {err:#}", pin_label(&pin)),
             }
         } else {
             notice = format!("{notice}; saved {}", pin_label(&pin));
         }
     }
-    Ok(notice)
+    Ok((notice, ref_changes))
 }
 
 fn checked_ref_edit(name: gix::refs::FullName, old: Target, new: Target, message: &str) -> RefEdit {
@@ -583,6 +754,7 @@ pub(crate) fn perform_reporting_rebased(
     let mut original_ids = HashMap::new();
     let mut review_roots = review_roots.to_vec();
     let mut ref_rewrites = Vec::new();
+    let mut ref_changes = Vec::new();
     while let Some(base) = pending_base(&repository, selected)? {
         let mut rebased = Vec::new();
         let outcome = super::rebase::perform_reporting_rebased(
@@ -610,10 +782,12 @@ pub(crate) fn perform_reporting_rebased(
                     revisions: revisions.to_vec(),
                     include_worktrees,
                     ref_rewrites,
+                    ref_changes,
                 }));
             }
         };
         ref_rewrites.extend(outcome.ref_rewrites.iter().cloned());
+        ref_changes.extend(outcome.ref_changes.iter().cloned());
         for (old, original) in rebased {
             if let Some(new) = outcome.map(old) {
                 original_ids.insert(new, original);
@@ -650,7 +824,7 @@ pub(crate) fn perform_reporting_rebased(
     } else {
         None
     };
-    let moved = move_head_to(
+    let moved = move_head_to_reporting(
         repository_path,
         bare,
         selected,
@@ -661,8 +835,8 @@ pub(crate) fn perform_reporting_rebased(
             if head_was_detached { Some(head_id) } else { Some(actual) }
         },
     );
-    let mut notice = match moved {
-        Ok(notice) => notice,
+    let (mut notice, mut checkout_changes) = match moved {
+        Ok(outcome) => outcome,
         Err(err) => {
             let err = match saved {
                 Some(stash) => match apply_review_stash(repository_path, bare, &workdir, stash) {
@@ -674,27 +848,35 @@ pub(crate) fn perform_reporting_rebased(
             return Err(err);
         }
     };
+    ref_changes.append(&mut checkout_changes);
     if let Some(saved) = saved
         && let Some(warning) = saved.warning
     {
         append_notice(&mut notice, warning);
     }
-    if crosses_review_boundary
-        && let Some(review) = destination_review
-        && let Some(stash) = find_review_stash(repository_path, bare, &review)?
-    {
-        append_notice(&mut notice, apply_review_stash(repository_path, bare, &workdir, stash)?);
+    if crosses_review_boundary && let Some(review) = destination_review {
+        match find_review_stash(repository_path, bare, &review) {
+            Ok(Some(stash)) => match apply_review_stash(repository_path, bare, &workdir, stash) {
+                Ok(message) => append_notice(&mut notice, message),
+                Err(err) => append_notice(&mut notice, format!("review stash remains: {err:#}")),
+            },
+            Ok(None) => {}
+            Err(err) => append_notice(&mut notice, format!("could not inspect the review stash: {err:#}")),
+        }
     }
-    if let Some(stash) = super::stash::find(repository_path, bare, super::stash::reference(selected)?)? {
-        append_notice(
-            &mut notice,
-            super::stash::apply(repository_path, bare, &workdir, stash)?,
-        );
+    match super::stash::reference(selected).and_then(|name| super::stash::find(repository_path, bare, name)) {
+        Ok(Some(stash)) => match super::stash::apply(repository_path, bare, &workdir, stash) {
+            Ok(message) => append_notice(&mut notice, message),
+            Err(err) => append_notice(&mut notice, format!("commit stash remains: {err:#}")),
+        },
+        Ok(None) => {}
+        Err(err) => append_notice(&mut notice, format!("could not inspect the commit stash: {err:#}")),
     }
     Ok(Perform::Complete {
         notice,
         selected,
         ref_rewrites,
+        ref_changes,
     })
 }
 
@@ -810,11 +992,20 @@ fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Opti
     Ok(pins.into_iter().next())
 }
 
+#[cfg(test)]
 fn create_or_update_head_pin(
     repository: &gix::Repository,
     branch: &gix::refs::FullName,
     id: ObjectId,
 ) -> Result<history::Pin> {
+    Ok(create_or_update_head_pin_reporting(repository, branch, id)?.0)
+}
+
+fn create_or_update_head_pin_reporting(
+    repository: &gix::Repository,
+    branch: &gix::refs::FullName,
+    id: ObjectId,
+) -> Result<(history::Pin, Vec<super::undo::RefChange>)> {
     let name: gix::refs::FullName = history::HEAD_PIN_NAME
         .as_bstr()
         .try_into()
@@ -826,51 +1017,74 @@ fn create_or_update_head_pin(
             PreviousValue::MustExistAndMatch(reference.target().into_owned())
         });
     let target = Target::Symbolic(branch.clone());
-    repository
-        .edit_references([RefEdit {
-            change: Change::Update {
-                log: LogChange {
-                    mode: RefLog::AndReference,
-                    force_create_reflog: false,
-                    message: "tix remember HEAD branch".into(),
-                },
-                expected,
-                new: target.clone(),
+    let edit = RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: "tix remember HEAD branch".into(),
             },
-            name: name.clone(),
-            deref: false,
-        }])
+            expected,
+            new: target.clone(),
+        },
+        name: name.clone(),
+        deref: false,
+    };
+    let applied = repository
+        .edit_references([edit])
         .context("could not remember the branch HEAD was attached to")?;
-    Ok(history::Pin { name, target, id })
+    let changes = super::undo::changes_from_edits(applied)?;
+    Ok((history::Pin { name, target, id }, changes))
 }
 
-fn reconcile_head_pin(repository: &gix::Repository, workdir: &Path) -> Result<Option<String>> {
+fn reconcile_head_pin_reporting(
+    repository: &gix::Repository,
+    workdir: &Path,
+) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
     let Some(pin) = history::all_pins(repository)?.into_iter().find(history::Pin::is_head) else {
-        return Ok(None);
+        return Ok((None, Vec::new()));
     };
     let head = repository.head().context("could not read HEAD after time-travel")?;
     let detached = head.is_detached();
     let head_id = head.id().map(gix::Id::detach);
     drop(head);
     if !detached {
-        return Ok(delete_pin(repository, &pin)
-            .err()
-            .map(|err| format!("HEAD pin remains: {err:#}")));
+        return Ok(match delete_pin_reporting(repository, &pin) {
+            Ok(changes) => (None, changes),
+            Err(err) => (Some(format!("HEAD pin remains: {err:#}")), Vec::new()),
+        });
     }
     if head_id != Some(pin.id) {
-        return Ok(None);
+        return Ok((None, Vec::new()));
     }
     let branch = pin.target.try_name().context("the HEAD pin is not symbolic")?;
     if let Err(err) = checkout_branch(workdir, branch) {
-        return Ok(Some(format!(
-            "could not reattach HEAD to {}: {err:#}; HEAD pin remains",
-            branch.shorten()
-        )));
-    }
-    Ok(Some(match delete_pin(repository, &pin) {
-        Ok(()) => format!("reattached HEAD to {}", branch.shorten()),
-        Err(err) => format!("reattached HEAD to {}; HEAD pin remains: {err:#}", branch.shorten()),
-    }))
+        return Ok((
+            Some(format!(
+                "could not reattach HEAD to {}: {err:#}; HEAD pin remains",
+                branch.shorten()
+            )),
+            Vec::new(),
+        ));
+    }
+    let mut head_change = vec![super::undo::RefChange {
+        name: "HEAD".try_into().expect("valid reference name"),
+        before: super::undo::State::Object(pin.id),
+        after: super::undo::State::Symbolic(branch.to_owned()),
+    }];
+    Ok(match delete_pin_reporting(repository, &pin) {
+        Ok(mut changes) => {
+            head_change.append(&mut changes);
+            (Some(format!("reattached HEAD to {}", branch.shorten())), head_change)
+        }
+        Err(err) => (
+            Some(format!(
+                "reattached HEAD to {}; HEAD pin remains: {err:#}",
+                branch.shorten()
+            )),
+            head_change,
+        ),
+    })
 }
 
 pub(crate) fn create_or_reuse_pin(
@@ -879,11 +1093,22 @@ pub(crate) fn create_or_reuse_pin(
     id: ObjectId,
     reflog_message: &str,
 ) -> Result<(history::Pin, bool)> {
+    let (pin, created, _) = create_or_reuse_pin_reporting(repository, target, id, reflog_message)?;
+    Ok((pin, created))
+}
+
+pub(crate) fn create_or_reuse_pin_reporting(
+    repository: &gix::Repository,
+    target: Target,
+    id: ObjectId,
+    reflog_message: &str,
+) -> Result<(history::Pin, bool, Vec<super::undo::RefChange>)> {
     let pins = history::all_pins(repository)?;
     if let Some(pin) = pins.iter().find(|pin| !pin.is_head() && pin.target == target) {
-        return Ok((pin.clone(), false));
+        return Ok((pin.clone(), false, Vec::new()));
     }
-    Ok((create_pin(repository, target, id, reflog_message)?, true))
+    let (pin, changes) = create_pin_reporting(repository, target, id, reflog_message)?;
+    Ok((pin, true, changes))
 }
 
 pub(crate) fn create_pin(
@@ -892,6 +1117,15 @@ pub(crate) fn create_pin(
     id: ObjectId,
     reflog_message: &str,
 ) -> Result<history::Pin> {
+    Ok(create_pin_reporting(repository, target, id, reflog_message)?.0)
+}
+
+pub(crate) fn create_pin_reporting(
+    repository: &gix::Repository,
+    target: Target,
+    id: ObjectId,
+    reflog_message: &str,
+) -> Result<(history::Pin, Vec<super::undo::RefChange>)> {
     let hex = id.to_hex().to_string();
     let mut suffix_len = 8.min(hex.len());
     let mut number = 2;
@@ -919,32 +1153,48 @@ pub(crate) fn create_pin(
             suffix_len = hex.len() + 1;
         }
     };
-    repository
-        .edit_references([RefEdit {
-            change: Change::Update {
-                log: LogChange {
-                    mode: RefLog::AndReference,
-                    force_create_reflog: false,
-                    message: reflog_message.into(),
-                },
-                expected: PreviousValue::MustNotExist,
-                new: target.clone(),
+    let edit = RefEdit {
+        change: Change::Update {
+            log: LogChange {
+                mode: RefLog::AndReference,
+                force_create_reflog: false,
+                message: reflog_message.into(),
             },
-            name: name.clone(),
-            deref: false,
-        }])
-        .context("could not create tix pin")?;
-    Ok(history::Pin { name, target, id })
+            expected: PreviousValue::MustNotExist,
+            new: target.clone(),
+        },
+        name: name.clone(),
+        deref: false,
+    };
+    let applied = repository.edit_references([edit]).context("could not create tix pin")?;
+    let changes = super::undo::changes_from_edits(applied)?;
+    Ok((history::Pin { name, target, id }, changes))
 }
 
 pub(super) fn delete_pin(repository: &gix::Repository, pin: &history::Pin) -> Result<()> {
-    repository
-        .edit_references([delete_pin_edit(pin)])
-        .context("could not remove tix pin")?;
-    Ok(())
+    delete_pin_reporting(repository, pin).map(drop)
 }
 
+pub(crate) fn delete_pin_reporting(
+    repository: &gix::Repository,
+    pin: &history::Pin,
+) -> Result<Vec<super::undo::RefChange>> {
+    let edit = delete_pin_edit(pin);
+    let applied = repository.edit_references([edit]).context("could not remove tix pin")?;
+    let changes = super::undo::changes_from_edits(applied)?;
+    Ok(changes)
+}
+
+#[cfg(test)]
 pub(crate) fn remove_pins(repository_path: &Path, bare: bool, selected: ObjectId) -> Result<usize> {
+    Ok(remove_pins_reporting(repository_path, bare, selected)?.0)
+}
+
+pub(crate) fn remove_pins_reporting(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+) -> Result<(usize, Vec<super::undo::RefChange>)> {
     let repository =
         open_repository(repository_path, bare, false).context("could not open repository to remove pins")?;
     let pins: Vec<_> = history::all_pins(&repository)?
@@ -952,12 +1202,12 @@ pub(crate) fn remove_pins(repository_path: &Path, bare: bool, selected: ObjectId
         .filter(|pin| !pin.is_head() && pin.id == selected)
         .collect();
     if pins.is_empty() {
-        return Ok(0);
+        return Ok((0, Vec::new()));
     }
-    repository
-        .edit_references(pins.iter().map(delete_pin_edit))
-        .context("could not remove tix pins")?;
-    Ok(pins.len())
+    let edits: Vec<_> = pins.iter().map(delete_pin_edit).collect();
+    let applied = repository.edit_references(edits).context("could not remove tix pins")?;
+    let changes = super::undo::changes_from_edits(applied)?;
+    Ok((pins.len(), changes))
 }
 
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
@@ -966,7 +1216,11 @@ pub(crate) enum PinToggle {
     Removed(usize),
 }
 
-pub(crate) fn toggle_pin(repository_path: &Path, bare: bool, selected: ObjectId) -> Result<PinToggle> {
+pub(crate) fn toggle_pin_reporting(
+    repository_path: &Path,
+    bare: bool,
+    selected: ObjectId,
+) -> Result<(PinToggle, Vec<super::undo::RefChange>)> {
     let repository =
         open_repository(repository_path, bare, false).context("could not open repository to toggle a pin")?;
     let pins: Vec<_> = history::all_pins(&repository)?
@@ -974,11 +1228,13 @@ pub(crate) fn toggle_pin(repository_path: &Path, bare: bool, selected: ObjectId)
         .filter(|pin| !pin.is_head() && pin.id == selected)
         .collect();
     if pins.is_empty() {
-        create_or_reuse_pin(&repository, Target::Object(selected), selected, "tix TUI pin")?;
-        return Ok(PinToggle::Created);
+        let (_, _, changes) =
+            create_or_reuse_pin_reporting(&repository, Target::Object(selected), selected, "tix TUI pin")?;
+        return Ok((PinToggle::Created, changes));
     }
     drop(repository);
-    remove_pins(repository_path, bare, selected).map(PinToggle::Removed)
+    let (removed, changes) = remove_pins_reporting(repository_path, bare, selected)?;
+    Ok((PinToggle::Removed(removed), changes))
 }
 
 fn delete_pin_edit(pin: &history::Pin) -> RefEdit {
@@ -992,23 +1248,32 @@ fn delete_pin_edit(pin: &history::Pin) -> RefEdit {
     }
 }
 
-fn delete_deferred_refs(repository_path: &Path, bare: bool, refs: &[(gix::refs::FullName, ObjectId)]) -> Result<()> {
+fn delete_deferred_refs(
+    repository_path: &Path,
+    bare: bool,
+    refs: &[(gix::refs::FullName, ObjectId)],
+) -> Result<Vec<super::undo::RefChange>> {
     if refs.is_empty() {
-        return Ok(());
+        return Ok(Vec::new());
     }
     let repository = open_repository(repository_path, bare, false)
         .context("could not reopen repository to finish reference deletions")?;
-    repository
-        .edit_references(refs.iter().map(|(name, old)| RefEdit {
+    let edits: Vec<_> = refs
+        .iter()
+        .map(|(name, old)| RefEdit {
             name: name.clone(),
             deref: false,
             change: Change::Delete {
                 expected: PreviousValue::MustExistAndMatch(Target::Object(*old)),
                 log: RefLog::AndReference,
             },
-        }))
+        })
+        .collect();
+    let applied = repository
+        .edit_references(edits)
         .context("could not delete the branch HEAD left during rebase")?;
-    Ok(())
+    let changes = super::undo::changes_from_edits(applied)?;
+    Ok(changes)
 }
 
 fn checkout_branch(workdir: &Path, name: &gix::refs::FullNameRef) -> Result<()> {
@@ -1484,7 +1749,10 @@ mod tests {
         assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
         drop(repository);
 
-        perform(&repository_path, false, topic, &graph, &[], &[], false)?.complete()?;
+        let returned = perform(&repository_path, false, topic, &graph, &[], &[], false)?;
+        let Perform::Complete { ref_changes, .. } = returned else {
+            return Err("returning through the HEAD pin must complete".into());
+        };
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -1492,6 +1760,25 @@ mod tests {
             "returning through a symbolic pin reattaches HEAD"
         );
         assert!(history::all_pins(&repository)?.is_empty(), "the used pin is removed");
+        super::super::undo::record(&repository, "return to branch", &ref_changes)?;
+        super::super::undo::plan_undo(&repository)?
+            .expect("the return can be undone")
+            .apply_with_worktrees(&repository)?;
+        assert!(repository.head()?.is_detached(), "undo restores the detached HEAD");
+        assert_eq!(repository.head_id()?.detach(), middle);
+        assert!(
+            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            "undo restores the symbolic HEAD pin"
+        );
+        super::super::undo::plan_redo(&repository)?
+            .expect("the return can be redone")
+            .apply_with_worktrees(&repository)?;
+        assert_eq!(
+            repository.head_name()?.map(|name| name.as_bstr().to_owned()),
+            Some(b"refs/heads/main".into()),
+            "redo reattaches HEAD"
+        );
+        assert!(history::all_pins(&repository)?.is_empty(), "redo consumes the HEAD pin");
 
         let detach = Command::new("git")
             .arg("-C")
@@ -1809,7 +2096,14 @@ mod tests {
         create_or_update_head_pin(&repository, &main, selected)?;
         drop(repository);
 
-        assert_eq!(toggle_pin(&repository_path, false, selected)?, PinToggle::Created);
+        let (toggle, created_changes) = toggle_pin_reporting(&repository_path, false, selected)?;
+        assert_eq!(toggle, PinToggle::Created);
+        let [created] = created_changes.as_slice() else {
+            return Err("creating one pin must report one reference change".into());
+        };
+        assert_eq!(created.before, super::super::undo::State::Missing);
+        assert_eq!(created.after, super::super::undo::State::Object(selected));
+        let pin_name = created.name.clone();
         let repository = crate::test_repository::open(fixture.path())?;
         let pins = history::all_pins(&repository)?;
         assert_eq!(
@@ -1819,7 +2113,14 @@ mod tests {
         );
         drop(repository);
 
-        assert_eq!(toggle_pin(&repository_path, false, selected)?, PinToggle::Removed(1));
+        let (toggle, removed_changes) = toggle_pin_reporting(&repository_path, false, selected)?;
+        assert_eq!(toggle, PinToggle::Removed(1));
+        let [removed] = removed_changes.as_slice() else {
+            return Err("removing one pin must report one reference change".into());
+        };
+        assert_eq!(removed.name, pin_name);
+        assert_eq!(removed.before, super::super::undo::State::Object(selected));
+        assert_eq!(removed.after, super::super::undo::State::Missing);
         let pins = history::all_pins(&crate::test_repository::open(fixture.path())?)?;
         assert!(pins.iter().any(history::Pin::is_head), "unpin preserves the HEAD pin");
         assert!(
@@ -1893,6 +2194,7 @@ mod tests {
         let repository_path = repository.git_dir().to_owned();
         let root = repository.rev_parse_single("main~2")?.detach();
         let main = repository.rev_parse_single("main")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
         let revisions = [OsString::from("main")];
         let graph = loaded_graph(&repository, &revisions)?;
         drop(repository);
@@ -1912,6 +2214,16 @@ mod tests {
             .args(["checkout", "--no-guess", "main"])
             .status()?;
         assert!(checkout.success());
+        git(
+            fixture.path(),
+            &["symbolic-ref", "refs/worktree/tix/pins/HEAD", "refs/heads/topic"],
+        )?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let head_pin_before = repository
+            .find_reference(history::HEAD_PIN_NAME.as_bstr())?
+            .target()
+            .into_owned();
+        drop(repository);
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -1927,9 +2239,24 @@ mod tests {
         assert!(format!("{err:#}").contains("git checkout failed"));
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(repository.head_id()?.detach(), main, "failed checkout retains HEAD");
+        assert_eq!(
+            repository
+                .find_reference(history::HEAD_PIN_NAME.as_bstr())?
+                .target()
+                .into_owned(),
+            head_pin_before,
+            "failed checkout restores the existing HEAD pin exactly"
+        );
         let pins = history::all_pins(&repository)?;
-        assert_eq!(pins.len(), 1, "the destination pin survives a failed checkout");
-        assert_eq!(pins[0].id, root);
+        assert_eq!(pins.len(), 2, "failed checkout neither loses nor creates pins");
+        assert!(
+            pins.iter().any(|pin| pin.is_head() && pin.id == topic),
+            "the reversed provisional update follows the original remembered branch"
+        );
+        assert!(
+            pins.iter().any(|pin| !pin.is_head() && pin.id == root),
+            "the destination pin survives a failed checkout"
+        );
         Ok(())
     }
 
@@ -1950,7 +2277,7 @@ mod tests {
             "preparing the exact merge result changes no repository state"
         );
 
-        let (_notice, conflict_id, _) = conflict.accept()?;
+        let (_notice, conflict_id, _, _) = conflict.accept()?;
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_id()?.detach(),
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index b9d8c5c8b2b..3479c22d99b 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1155,6 +1155,7 @@ fn resolve_ref_name(
     if name.as_bstr().starts_with(crate::history::PIN_PREFIX)
         || name.as_bstr().starts_with(crate::history::STASH_PREFIX)
         || name.as_bstr().starts_with(crate::history::REVIEW_PREFIX)
+        || super::undo::is_queue_ref(name.as_bstr())
         || matches!(
             name.category(),
             Some(gix::refs::Category::Tag | gix::refs::Category::RemoteBranch)
diff --git a/gix-tix/src/edit/undo.rs b/gix-tix/src/edit/undo.rs
new file mode 100644
index 00000000000..7d21e7fa89d
--- /dev/null
+++ b/gix-tix/src/edit/undo.rs
@@ -0,0 +1,1203 @@
+use std::{
+    collections::{BTreeMap, HashSet},
+    path::PathBuf,
+};
+
+use anyhow::{Context, Result, bail, ensure};
+use gix::{
+    ObjectId,
+    bstr::{BStr, BString, ByteSlice},
+    config::File,
+    refs::{
+        FullName, FullNameRef, Target,
+        transaction::{Change, LogChange, PreviousValue, RefEdit, RefLog},
+    },
+};
+
+pub(crate) const TIP_REF: &str = "refs/worktree/tix/undo";
+pub(crate) const CURSOR_REF: &str = "refs/worktree/tix/undo-cursor";
+
+const VERSION: &str = "1";
+const START_TITLE: &str = "start of undo history";
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) enum State {
+    Missing,
+    Object(ObjectId),
+    Symbolic(FullName),
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct RefChange {
+    pub name: FullName,
+    pub before: State,
+    pub after: State,
+}
+
+impl RefChange {
+    pub(crate) fn from_edit(edit: &RefEdit) -> Result<Self> {
+        let (before, after) = match &edit.change {
+            Change::Update { expected, new, .. } => (state_from_expected(expected)?, state_from_target(new)),
+            Change::Delete { expected, .. } => (state_from_expected(expected)?, State::Missing),
+        };
+        Ok(RefChange {
+            name: edit.name.clone(),
+            before,
+            after,
+        })
+    }
+
+    fn reversed(&self) -> Self {
+        RefChange {
+            name: self.name.clone(),
+            before: self.after.clone(),
+            after: self.before.clone(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub(crate) struct Position {
+    pub title: String,
+    pub undo: usize,
+    pub redo: usize,
+}
+
+#[derive(Clone, Debug)]
+pub(crate) struct Plan {
+    /// The operation crossed by this step. `position.title` is the title at the destination.
+    pub title: String,
+    /// Changes oriented from the current queue position to the destination.
+    pub changes: Vec<RefChange>,
+    /// Checked, non-dereferencing edits for `changes`, followed by the cursor edit.
+    pub edits: Vec<RefEdit>,
+    pub position: Position,
+}
+
+impl Plan {
+    pub(crate) fn apply(self, repo: &gix::Repository) -> Result<()> {
+        self.apply_with_worktrees(repo)
+    }
+
+    pub(crate) fn apply_with_worktrees(self, repo: &gix::Repository) -> Result<()> {
+        let transitions = worktree_transitions(repo, &self.changes)?;
+        for transition in &transitions {
+            super::forget::preflight_tree_transition(
+                &transition.repo,
+                &transition.workdir,
+                transition.old,
+                transition.new,
+            )
+            .context("local changes prevent undo/redo; stash them manually and retry")?;
+        }
+        for (applied, transition) in transitions.iter().enumerate() {
+            if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.old, transition.new)
+            {
+                return Err(rollback_transitions(
+                    &transitions[..=applied],
+                    err.context("could not align a worktree with the undo queue"),
+                ));
+            }
+        }
+        if let Err(err) = repo.edit_references(self.edits) {
+            return Err(rollback_transitions(
+                &transitions,
+                anyhow::Error::new(err).context("could not atomically move references and the undo cursor"),
+            ));
+        }
+        Ok(())
+    }
+}
+
+pub(crate) fn is_queue_ref(name: &BStr) -> bool {
+    name.as_bytes() == TIP_REF.as_bytes() || name.as_bytes() == CURSOR_REF.as_bytes()
+}
+
+pub(crate) fn ref_chain_reaches_queue(repo: &gix::Repository, name: &FullNameRef) -> Result<bool> {
+    let mut name = name.to_owned();
+    let mut seen = HashSet::new();
+    loop {
+        if is_queue_ref(name.as_bstr()) {
+            return Ok(true);
+        }
+        ensure!(seen.insert(name.clone()), "a symbolic reference chain contains a cycle");
+        let Some(reference) = repo.try_find_reference(name.as_ref())? else {
+            return Ok(false);
+        };
+        let target = reference.target();
+        let Some(next) = target.try_name() else {
+            return Ok(false);
+        };
+        name = next.to_owned();
+    }
+}
+
+pub(crate) fn is_queue_commit(repo: &gix::Repository, needle: ObjectId) -> Result<bool> {
+    let Some(mut id) = read_queue_ref(repo, TIP_REF)?.or(read_queue_ref(repo, CURSOR_REF)?) else {
+        return Ok(false);
+    };
+    let mut seen = HashSet::new();
+    loop {
+        ensure!(seen.insert(id), "the undo queue first-parent chain contains a cycle");
+        let Ok(stored) = parse_commit(repo, id) else {
+            return Ok(false);
+        };
+        if id == needle {
+            return Ok(true);
+        }
+        let Some(parent) = stored.parent else {
+            return Ok(false);
+        };
+        id = parent;
+    }
+}
+
+pub(crate) fn review_blocks_undo(repo: &gix::Repository) -> Result<bool> {
+    let references = repo.references().context("could not open review references")?;
+    for reference in references
+        .prefixed(crate::history::REVIEW_PREFIX.as_bstr())
+        .context("could not iterate review references")?
+    {
+        let reference = match reference {
+            Ok(reference) => reference,
+            Err(err) if crate::history::is_missing_ref(&*err) => continue,
+            Err(err) => return Err(anyhow::anyhow!("could not read review reference: {err}")),
+        };
+        if crate::history::review_number(reference.name().as_bstr()).is_some() {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}
+
+pub(crate) fn clear(repo: &gix::Repository) -> Result<()> {
+    let mut edits = Vec::new();
+    for name in [TIP_REF, CURSOR_REF] {
+        let Some(reference) = repo
+            .try_find_reference(name)
+            .with_context(|| format!("could not read {name}"))?
+        else {
+            continue;
+        };
+        edits.push(RefEdit {
+            name: reference.name().to_owned(),
+            deref: false,
+            change: Change::Delete {
+                expected: PreviousValue::MustExistAndMatch(reference.target().into_owned()),
+                log: RefLog::AndReference,
+            },
+        });
+    }
+    if edits.is_empty() {
+        return Ok(());
+    }
+    repo.edit_references(edits)
+        .context("could not clear undo history for review")
+        .map(|_| ())
+}
+
+pub(crate) fn apply_reversed_changes(repo: &gix::Repository, changes: &[RefChange]) -> Result<()> {
+    let changes = normalize_changes(changes.iter().cloned())?;
+    if changes.is_empty() {
+        return Ok(());
+    }
+    let edits = changes
+        .iter()
+        .map(RefChange::reversed)
+        .map(|change| checked_edit(&change))
+        .collect::<Result<Vec<_>>>()?;
+    repo.edit_references(edits)
+        .context("could not roll back provisional reference changes")
+        .map(|_| ())
+}
+
+pub(crate) fn state(repo: &gix::Repository, name: &FullNameRef) -> Result<State> {
+    Ok(match repo.try_find_reference(name)? {
+        Some(reference) => state_from_target_ref(reference.target()),
+        None => State::Missing,
+    })
+}
+
+/// Convert checked transaction edits into one change per reference.
+///
+/// Repeated edits must form a continuous sequence; the first before-state and final after-state
+/// are retained, and resulting no-ops are omitted.
+pub(crate) fn changes_from_edits(edits: impl IntoIterator<Item = RefEdit>) -> Result<Vec<RefChange>> {
+    normalize_changes(
+        edits
+            .into_iter()
+            .map(|edit| RefChange::from_edit(&edit))
+            .collect::<Result<Vec<_>>>()?,
+    )
+}
+
+/// Record an already-successful operation and publish the new tip and cursor atomically.
+///
+/// Returns `None` when all supplied changes cancel each other out.
+pub(crate) fn record(repo: &gix::Repository, title: &str, changes: &[RefChange]) -> Result<Option<ObjectId>> {
+    validate_title(title)?;
+    if review_blocks_undo(repo)? {
+        clear(repo)?;
+        return Ok(None);
+    }
+    let changes = normalize_changes(changes.iter().cloned())?;
+    if changes.is_empty() {
+        return Ok(None);
+    }
+
+    let queue = load(repo)?;
+    let (predecessor, old_tip, old_cursor) = match queue {
+        Some(queue) => (queue.cursor, Some(queue.tip), Some(queue.cursor)),
+        None => {
+            let config = serialize_config(&[])?;
+            let sentinel = write_commit(repo, START_TITLE, &config, &[])?;
+            (sentinel, None, None)
+        }
+    };
+    let config = serialize_config(&changes)?;
+    let parents = retention_parents(repo, predecessor, &changes)?;
+    let entry = write_commit(repo, title, &config, &parents)?;
+
+    repo.edit_references([
+        queue_update(TIP_REF, old_tip, entry)?,
+        queue_update(CURSOR_REF, old_cursor, entry)?,
+    ])
+    .context("could not publish the undo entry")?;
+    Ok(Some(entry))
+}
+
+pub(crate) fn position(repo: &gix::Repository) -> Result<Position> {
+    if review_blocks_undo(repo)? {
+        return Ok(empty_position());
+    }
+    Ok(load(repo)?.map_or_else(empty_position, |queue| queue.position(queue.cursor_index)))
+}
+
+pub(crate) fn plan_undo(repo: &gix::Repository) -> Result<Option<Plan>> {
+    if review_blocks_undo(repo)? {
+        return Ok(None);
+    }
+    let Some(queue) = load(repo)? else { return Ok(None) };
+    if queue.cursor_index == 0 {
+        return Ok(None);
+    }
+    let entry = &queue.entries[queue.cursor_index - 1];
+    let changes: Vec<_> = entry.changes.iter().map(RefChange::reversed).collect();
+    let cursor = if queue.cursor_index == 1 {
+        queue.sentinel
+    } else {
+        queue.entries[queue.cursor_index - 2].id
+    };
+    Ok(Some(make_plan(
+        &queue,
+        entry.title.clone(),
+        changes,
+        cursor,
+        queue.cursor_index - 1,
+    )?))
+}
+
+pub(crate) fn plan_redo(repo: &gix::Repository) -> Result<Option<Plan>> {
+    if review_blocks_undo(repo)? {
+        return Ok(None);
+    }
+    let Some(queue) = load(repo)? else { return Ok(None) };
+    let Some(entry) = queue.entries.get(queue.cursor_index) else {
+        return Ok(None);
+    };
+    Ok(Some(make_plan(
+        &queue,
+        entry.title.clone(),
+        entry.changes.clone(),
+        entry.id,
+        queue.cursor_index + 1,
+    )?))
+}
+
+fn make_plan(
+    queue: &Queue,
+    title: String,
+    changes: Vec<RefChange>,
+    cursor: ObjectId,
+    cursor_index: usize,
+) -> Result<Plan> {
+    let mut edits = changes.iter().map(checked_edit).collect::<Result<Vec<_>>>()?;
+    edits.push(queue_update(CURSOR_REF, Some(queue.cursor), cursor)?);
+    Ok(Plan {
+        title,
+        changes,
+        edits,
+        position: queue.position(cursor_index),
+    })
+}
+
+fn empty_position() -> Position {
+    Position {
+        title: START_TITLE.into(),
+        undo: 0,
+        redo: 0,
+    }
+}
+
+fn normalize_changes(changes: impl IntoIterator<Item = RefChange>) -> Result<Vec<RefChange>> {
+    let mut by_name = BTreeMap::<FullName, RefChange>::new();
+    for change in changes {
+        ensure!(
+            !is_queue_ref(change.name.as_bstr()),
+            "the undo queue cannot record itself"
+        );
+        match by_name.get_mut(&change.name) {
+            Some(existing) => {
+                ensure!(
+                    existing.after == change.before,
+                    "successive changes to {} are not continuous",
+                    change.name
+                );
+                existing.after = change.after;
+            }
+            None => {
+                by_name.insert(change.name.clone(), change);
+            }
+        }
+    }
+    Ok(by_name
+        .into_values()
+        .filter(|change| change.before != change.after)
+        .collect())
+}
+
+fn state_from_expected(expected: &PreviousValue) -> Result<State> {
+    match expected {
+        PreviousValue::MustNotExist => Ok(State::Missing),
+        PreviousValue::MustExistAndMatch(target) => Ok(state_from_target(target)),
+        PreviousValue::Any | PreviousValue::MustExist | PreviousValue::ExistingMustMatch(_) => {
+            bail!("an undo entry requires the exact previous reference value")
+        }
+    }
+}
+
+fn state_from_target(target: &Target) -> State {
+    match target {
+        Target::Object(id) => State::Object(*id),
+        Target::Symbolic(name) => State::Symbolic(name.clone()),
+    }
+}
+
+fn state_from_target_ref(target: gix::refs::TargetRef<'_>) -> State {
+    match target {
+        gix::refs::TargetRef::Object(id) => State::Object(id.to_owned()),
+        gix::refs::TargetRef::Symbolic(name) => State::Symbolic(name.to_owned()),
+    }
+}
+
+struct WorktreeTransition {
+    repo: gix::Repository,
+    workdir: PathBuf,
+    old: ObjectId,
+    new: ObjectId,
+}
+
+fn worktree_transitions(repo: &gix::Repository, changes: &[RefChange]) -> Result<Vec<WorktreeTransition>> {
+    let mut repos = vec![
+        repo.main_repo()
+            .context("could not open the main worktree repository")?,
+    ];
+    for proxy in repo.worktrees().context("could not enumerate linked worktrees")? {
+        repos.push(
+            proxy
+                .into_repo_with_possibly_inaccessible_worktree()
+                .context("could not inspect a linked worktree")?,
+        );
+    }
+
+    let mut out = Vec::new();
+    let mut seen = HashSet::new();
+    for worktree_repo in repos {
+        if !seen.insert(worktree_repo.git_dir().to_owned()) {
+            continue;
+        }
+        let head = worktree_repo.head().context("could not inspect a worktree HEAD")?;
+        let old_id = head.id().map(gix::Id::detach);
+        let raw_head = worktree_repo
+            .find_reference("HEAD")
+            .context("could not read a worktree HEAD reference")?;
+        let raw_head = state_from_target_ref(raw_head.target());
+        let current = worktree_repo.git_dir() == repo.git_dir();
+        let projected_head = projected_ref_state(&worktree_repo, b"HEAD".as_bstr(), &raw_head, changes, current)?;
+        ensure!(
+            projected_head != State::Missing,
+            "undo/redo cannot delete a worktree HEAD"
+        );
+        let new_id = resolve_state(&worktree_repo, &projected_head, changes, current, &mut HashSet::new())?;
+        let old = tree_id(&worktree_repo, old_id).context("could not inspect the current worktree tree")?;
+        let new = tree_id(&worktree_repo, new_id).context("could not inspect the destination worktree tree")?;
+        if old == new || (worktree_repo.workdir().is_none() && worktree_repo.is_bare()) {
+            continue;
+        }
+        let workdir = worktree_repo
+            .workdir()
+            .filter(|path| path.is_dir())
+            .context("an affected worktree is inaccessible")?
+            .to_owned();
+        out.push(WorktreeTransition {
+            repo: worktree_repo,
+            workdir,
+            old,
+            new,
+        });
+    }
+    Ok(out)
+}
+
+fn projected_ref_state(
+    repo: &gix::Repository,
+    name: &BStr,
+    fallback: &State,
+    changes: &[RefChange],
+    include_head: bool,
+) -> Result<State> {
+    if (include_head || name != b"HEAD")
+        && let Some(change) = changes.iter().find(|change| change.name.as_bstr() == name)
+    {
+        return Ok(change.after.clone());
+    }
+    if name == b"HEAD" {
+        return Ok(fallback.clone());
+    }
+    let name = FullName::try_from(name).context("a projected worktree reference name is invalid")?;
+    state(repo, name.as_ref())
+}
+
+fn resolve_state(
+    repo: &gix::Repository,
+    state: &State,
+    changes: &[RefChange],
+    include_head: bool,
+    seen: &mut HashSet<FullName>,
+) -> Result<Option<ObjectId>> {
+    match state {
+        State::Missing => Ok(None),
+        State::Object(id) => Ok(Some(*id)),
+        State::Symbolic(name) => {
+            ensure!(
+                seen.insert(name.clone()),
+                "a projected worktree reference contains a symbolic cycle"
+            );
+            let next = projected_ref_state(repo, name.as_bstr(), &State::Missing, changes, include_head)?;
+            resolve_state(repo, &next, changes, include_head, seen)
+        }
+    }
+}
+
+fn tree_id(repo: &gix::Repository, commit: Option<ObjectId>) -> Result<ObjectId> {
+    commit.map_or_else(
+        || Ok(ObjectId::empty_tree(repo.object_hash())),
+        |commit| {
+            repo.find_commit(commit)
+                .context("a worktree HEAD target is not a commit")?
+                .tree_id()
+                .context("could not decode a worktree HEAD commit")
+                .map(gix::Id::detach)
+        },
+    )
+}
+
+fn rollback_transitions(transitions: &[WorktreeTransition], mut cause: anyhow::Error) -> anyhow::Error {
+    for transition in transitions.iter().rev() {
+        if let Err(err) = super::forget::apply_tree_transition(&transition.workdir, transition.new, transition.old) {
+            cause = cause.context(format!("worktree rollback failed: {err:#}"));
+        }
+    }
+    cause
+}
+
+fn checked_edit(change: &RefChange) -> Result<RefEdit> {
+    let expected = match &change.before {
+        State::Missing => PreviousValue::MustNotExist,
+        State::Object(id) => PreviousValue::MustExistAndMatch(Target::Object(*id)),
+        State::Symbolic(name) => PreviousValue::MustExistAndMatch(Target::Symbolic(name.clone())),
+    };
+    let tx_change = match &change.after {
+        State::Missing => {
+            ensure!(
+                change.before != State::Missing,
+                "cannot delete an already-missing reference"
+            );
+            Change::Delete {
+                expected,
+                log: RefLog::AndReference,
+            }
+        }
+        State::Object(id) => Change::Update {
+            expected,
+            new: Target::Object(*id),
+            log: log_change(),
+        },
+        State::Symbolic(name) => Change::Update {
+            expected,
+            new: Target::Symbolic(name.clone()),
+            log: log_change(),
+        },
+    };
+    Ok(RefEdit {
+        name: change.name.clone(),
+        deref: false,
+        change: tx_change,
+    })
+}
+
+fn queue_update(name: &str, old: Option<ObjectId>, new: ObjectId) -> Result<RefEdit> {
+    Ok(RefEdit {
+        name: name.try_into().context("the undo queue reference name is invalid")?,
+        deref: false,
+        change: Change::Update {
+            expected: old.map_or(PreviousValue::MustNotExist, |id| {
+                PreviousValue::MustExistAndMatch(Target::Object(id))
+            }),
+            new: Target::Object(new),
+            log: log_change(),
+        },
+    })
+}
+
+fn log_change() -> LogChange {
+    LogChange {
+        mode: RefLog::AndReference,
+        force_create_reflog: false,
+        message: "tix undo queue".into(),
+    }
+}
+
+fn serialize_config(changes: &[RefChange]) -> Result<File> {
+    let mut config = File::default();
+    config
+        .new_section("undo", None)?
+        .set("version", VERSION)
+        .context("could not serialize the undo version")?;
+    for change in changes {
+        let mut section = config
+            .new_section("ref", change.name.as_bstr())
+            .context("could not serialize an undo reference")?;
+        section
+            .set("before", encode_state(&change.before))
+            .context("could not serialize an undo before-state")?;
+        section
+            .set("after", encode_state(&change.after))
+            .context("could not serialize an undo after-state")?;
+    }
+    Ok(config)
+}
+
+fn encode_state(state: &State) -> BString {
+    match state {
+        State::Missing => "missing".into(),
+        State::Object(id) => format!("object:{id}").into(),
+        State::Symbolic(name) => {
+            let mut value = BString::from("symbolic:");
+            value.extend_from_slice(name.as_bstr());
+            value
+        }
+    }
+}
+
+fn parse_config(repo: &gix::Repository, body: &BStr) -> Result<Vec<RefChange>> {
+    let config = File::try_from(body).context("could not parse undo metadata as Git config")?;
+    let mut sections = config.sections();
+    let undo = sections.next().context("undo metadata has no version section")?;
+    ensure!(
+        undo.header().name() == b"undo" && undo.header().subsection_name().is_none(),
+        "undo metadata must start with [undo]"
+    );
+    ensure_exact_keys(&undo, &["version"])?;
+    ensure!(
+        undo.value("version").as_ref().map(|value| value.as_slice()) == Some(VERSION.as_bytes()),
+        "unsupported undo metadata version"
+    );
+
+    let mut changes = Vec::new();
+    let mut previous_name: Option<FullName> = None;
+    for section in sections {
+        ensure!(
+            section.header().name() == b"ref",
+            "undo metadata contains an unknown section"
+        );
+        let subsection = section
+            .header()
+            .subsection_name()
+            .context("an undo ref section has no reference name")?;
+        let name = FullName::try_from(subsection).context("an undo entry contains an invalid reference name")?;
+        ensure!(!is_queue_ref(name.as_bstr()), "the undo queue records itself");
+        if let Some(previous) = &previous_name {
+            ensure!(
+                previous < &name,
+                "undo reference sections are duplicated or out of order"
+            );
+        }
+        previous_name = Some(name.clone());
+        ensure_exact_keys(&section, &["before", "after"])?;
+        let before = section.value("before").context("an undo ref has no before-state")?;
+        let before = parse_state(repo, before.as_bstr())?;
+        let after = section.value("after").context("an undo ref has no after-state")?;
+        let after = parse_state(repo, after.as_bstr())?;
+        ensure!(before != after, "an undo ref does not change");
+        changes.push(RefChange { name, before, after });
+    }
+    Ok(changes)
+}
+
+fn ensure_exact_keys(section: &gix::config::file::SectionRef<'_>, expected: &[&str]) -> Result<()> {
+    let actual: Vec<_> = section.value_names().collect();
+    ensure!(
+        actual == expected,
+        "undo metadata has missing, repeated, or unknown keys"
+    );
+    Ok(())
+}
+
+fn parse_state(repo: &gix::Repository, value: &BStr) -> Result<State> {
+    if value == b"missing" {
+        return Ok(State::Missing);
+    }
+    if let Some(hex) = value.strip_prefix(b"object:") {
+        let id = ObjectId::from_hex(hex).context("an undo object ID is invalid")?;
+        ensure!(
+            id.kind() == repo.object_hash(),
+            "an undo object ID uses the wrong hash kind"
+        );
+        return Ok(State::Object(id));
+    }
+    if let Some(name) = value.strip_prefix(b"symbolic:") {
+        return FullName::try_from(name.as_bstr())
+            .map(State::Symbolic)
+            .context("an undo symbolic target is invalid");
+    }
+    bail!("an undo reference state has an unknown encoding")
+}
+
+fn validate_title(title: &str) -> Result<()> {
+    ensure!(!title.is_empty(), "an undo operation title cannot be empty");
+    ensure!(
+        !title.as_bytes().iter().any(|byte| matches!(byte, b'\n' | b'\r')),
+        "an undo operation title must be one line"
+    );
+    Ok(())
+}
+
+fn retention_parents(repo: &gix::Repository, predecessor: ObjectId, changes: &[RefChange]) -> Result<Vec<ObjectId>> {
+    let mut parents = vec![predecessor];
+    let mut seen = HashSet::from([predecessor]);
+    for id in changes
+        .iter()
+        .flat_map(|change| [&change.before, &change.after])
+        .filter_map(|state| match state {
+            State::Object(id) => Some(*id),
+            State::Missing | State::Symbolic(_) => None,
+        })
+    {
+        if seen.contains(&id) {
+            continue;
+        }
+        if repo
+            .find_header(id)
+            .with_context(|| format!("could not inspect retained undo object {id}"))?
+            .kind()
+            == gix::object::Kind::Commit
+        {
+            seen.insert(id);
+            parents.push(id);
+        }
+    }
+    Ok(parents)
+}
+
+fn write_commit(repo: &gix::Repository, title: &str, config: &File, parents: &[ObjectId]) -> Result<ObjectId> {
+    validate_title(title)?;
+    let tree = repo
+        .write_object(gix::objs::Tree::empty())
+        .context("could not write the undo queue's empty tree")?
+        .detach();
+    let committer = repo
+        .committer()
+        .context("no Git committer is configured")?
+        .context("could not resolve the Git committer")?
+        .to_owned()?;
+    let mut message = BString::from(title);
+    message.extend_from_slice(b"\n\n");
+    message.extend_from_slice(&config.to_bstring());
+    let commit = gix::objs::Commit {
+        tree,
+        parents: parents.iter().copied().collect(),
+        author: committer.clone(),
+        committer,
+        encoding: None,
+        message,
+        extra_headers: Vec::new(),
+    };
+    repo.write_object(&commit)
+        .context("could not write an undo queue commit")
+        .map(gix::Id::detach)
+}
+
+#[derive(Debug)]
+struct StoredEntry {
+    id: ObjectId,
+    title: String,
+    changes: Vec<RefChange>,
+}
+
+#[derive(Debug)]
+struct Queue {
+    tip: ObjectId,
+    cursor: ObjectId,
+    sentinel: ObjectId,
+    entries: Vec<StoredEntry>,
+    cursor_index: usize,
+}
+
+impl Queue {
+    fn position(&self, cursor_index: usize) -> Position {
+        Position {
+            title: cursor_index
+                .checked_sub(1)
+                .and_then(|index| self.entries.get(index))
+                .map_or_else(|| START_TITLE.into(), |entry| entry.title.clone()),
+            undo: cursor_index,
+            redo: self.entries.len() - cursor_index,
+        }
+    }
+}
+
+fn load(repo: &gix::Repository) -> Result<Option<Queue>> {
+    let tip = read_queue_ref(repo, TIP_REF)?;
+    let cursor = read_queue_ref(repo, CURSOR_REF)?;
+    let (tip, cursor) = match (tip, cursor) {
+        (None, None) => return Ok(None),
+        (Some(tip), Some(cursor)) => (tip, cursor),
+        _ => bail!("the undo queue has only one of its tip and cursor references"),
+    };
+
+    let mut id = tip;
+    let mut seen = HashSet::new();
+    let mut entries = Vec::new();
+    let sentinel;
+    loop {
+        ensure!(seen.insert(id), "the undo queue first-parent chain contains a cycle");
+        let stored = parse_commit(repo, id)?;
+        match stored.parent {
+            Some(parent) => {
+                entries.push(StoredEntry {
+                    id,
+                    title: stored.title,
+                    changes: stored.changes,
+                });
+                id = parent;
+            }
+            None => {
+                sentinel = id;
+                break;
+            }
+        }
+    }
+    entries.reverse();
+    let cursor_index = if cursor == sentinel {
+        0
+    } else {
+        entries
+            .iter()
+            .position(|entry| entry.id == cursor)
+            .map(|index| index + 1)
+            .context("the undo cursor is not on the tip's first-parent chain")?
+    };
+    Ok(Some(Queue {
+        tip,
+        cursor,
+        sentinel,
+        entries,
+        cursor_index,
+    }))
+}
+
+fn read_queue_ref(repo: &gix::Repository, name: &str) -> Result<Option<ObjectId>> {
+    let Some(reference) = repo
+        .try_find_reference(name)
+        .with_context(|| format!("could not read {name}"))?
+    else {
+        return Ok(None);
+    };
+    match reference.target() {
+        gix::refs::TargetRef::Object(id) => Ok(Some(id.to_owned())),
+        gix::refs::TargetRef::Symbolic(_) => bail!("{name} must be a direct reference"),
+    }
+}
+
+struct ParsedCommit {
+    parent: Option<ObjectId>,
+    title: String,
+    changes: Vec<RefChange>,
+}
+
+fn parse_commit(repo: &gix::Repository, id: ObjectId) -> Result<ParsedCommit> {
+    let commit = repo
+        .find_commit(id)
+        .with_context(|| format!("could not find undo queue commit {id}"))?
+        .decode()
+        .context("could not decode an undo queue commit")?
+        .into_owned()
+        .context("could not own an undo queue commit")?;
+    ensure!(
+        commit.tree == ObjectId::empty_tree(repo.object_hash()),
+        "an undo queue commit does not use the empty tree"
+    );
+    let message = gix::objs::commit::MessageRef::from_bytes(&commit.message);
+    let title = message
+        .title
+        .to_str()
+        .context("an undo operation title is not UTF-8")?
+        .to_owned();
+    validate_title(&title)?;
+    let body = message.body.context("an undo queue commit has no metadata body")?;
+    let changes = parse_config(repo, body)?;
+    let parent = commit.parents.first().copied();
+    match parent {
+        None => {
+            ensure!(title == START_TITLE, "the undo sentinel has the wrong title");
+            ensure!(changes.is_empty(), "the undo sentinel contains reference changes");
+        }
+        Some(parent) => {
+            ensure!(!changes.is_empty(), "an undo operation contains no reference changes");
+            let expected = retention_parents(repo, parent, &changes)?;
+            ensure!(
+                commit.parents.as_slice() == expected,
+                "an undo commit has invalid retention parents"
+            );
+        }
+    }
+    Ok(ParsedCommit { parent, title, changes })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn repo() -> gix_testtools::Result<(gix_testtools::tempfile::TempDir, gix::Repository)> {
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        Ok((fixture, repository))
+    }
+
+    fn name(value: &str) -> gix_testtools::Result<FullName> {
+        Ok(value.try_into()?)
+    }
+
+    fn set(repo: &gix::Repository, name: FullName, before: State, after: State) -> Result<()> {
+        checked_edit(&RefChange { name, before, after }).and_then(|edit| {
+            repo.edit_references([edit])?;
+            Ok(())
+        })
+    }
+
+    fn child(repo: &gix::Repository, parent: ObjectId, title: &str) -> gix_testtools::Result<ObjectId> {
+        let mut commit = repo.find_commit(parent)?.decode()?.into_owned()?;
+        commit.parents = [parent].into_iter().collect();
+        commit.message = title.into();
+        Ok(repo.write_object(&commit)?.detach())
+    }
+
+    #[test]
+    fn config_round_trip_is_lossless_and_strict() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let id = repo.head_id()?.detach();
+        let changes = vec![
+            RefChange {
+                name: name("HEAD")?,
+                before: State::Symbolic(name("refs/heads/main")?),
+                after: State::Object(id),
+            },
+            RefChange {
+                name: name("refs/heads/new")?,
+                before: State::Missing,
+                after: State::Object(id),
+            },
+        ];
+        let config = serialize_config(&changes)?;
+        assert_eq!(
+            parse_config(&repo, config.to_bstring().as_bstr())?,
+            changes,
+            "all supported reference states round-trip"
+        );
+        assert!(
+            parse_config(&repo, b"[undo]\nversion = 1\nextra = nope\n".as_bstr()).is_err(),
+            "unknown metadata keys are rejected"
+        );
+        assert!(
+            parse_config(
+                &repo,
+                b"[undo]\nversion = 1\n[ref \"refs/heads/a\"]\nbefore = missing\nafter = missing\n".as_bstr()
+            )
+            .is_err(),
+            "no-op entries are rejected"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn undo_and_redo_apply_checked_ref_and_cursor_edits() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let branch = name("refs/heads/undo-test")?;
+        let head = repo.head_id()?.detach();
+        set(&repo, branch.clone(), State::Missing, State::Object(head))?;
+        let entry = record(
+            &repo,
+            "create branch",
+            &[RefChange {
+                name: branch.clone(),
+                before: State::Missing,
+                after: State::Object(head),
+            }],
+        )?
+        .expect("a change creates an entry");
+
+        let parents: Vec<_> = repo.find_commit(entry)?.parent_ids().map(gix::Id::detach).collect();
+        assert_eq!(
+            parents.len(),
+            2,
+            "the prior queue entry and changed commit are retained"
+        );
+        assert_eq!(parents[1], head, "the changed commit is a retention parent");
+        assert_eq!(position(&repo)?.undo, 1, "the operation is initially applied");
+
+        let undo = plan_undo(&repo)?.expect("one operation can be undone");
+        assert_eq!(undo.title, "create branch");
+        assert_eq!(undo.position.title, START_TITLE);
+        undo.apply(&repo)?;
+        assert!(
+            repo.try_find_reference(branch.as_ref())?.is_none(),
+            "undo deletes the created branch"
+        );
+        assert_eq!(position(&repo)?.redo, 1, "the operation can be redone");
+
+        let redo = plan_redo(&repo)?.expect("one operation can be redone");
+        assert_eq!(redo.position.title, "create branch");
+        redo.apply(&repo)?;
+        assert_eq!(repo.find_reference(branch.as_ref())?.id().detach(), head);
+        assert!(plan_redo(&repo)?.is_none(), "the tip has no redo operation");
+        Ok(())
+    }
+
+    #[test]
+    fn recording_behind_tip_truncates_redo_and_merges_changes() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let branch = name("refs/heads/undo-test")?;
+        let first = repo.head_id()?.detach();
+        let discarded = child(&repo, first, "discarded")?;
+        let replacement = child(&repo, first, "replacement")?;
+
+        set(&repo, branch.clone(), State::Missing, State::Object(first))?;
+        record(
+            &repo,
+            "first",
+            &[RefChange {
+                name: branch.clone(),
+                before: State::Missing,
+                after: State::Object(first),
+            }],
+        )?;
+        set(&repo, branch.clone(), State::Object(first), State::Object(discarded))?;
+        record(
+            &repo,
+            "discarded",
+            &[RefChange {
+                name: branch.clone(),
+                before: State::Object(first),
+                after: State::Object(discarded),
+            }],
+        )?;
+        plan_undo(&repo)?.expect("second entry exists").apply(&repo)?;
+
+        set(&repo, branch.clone(), State::Object(first), State::Object(replacement))?;
+        record(
+            &repo,
+            "replacement",
+            &[
+                RefChange {
+                    name: branch.clone(),
+                    before: State::Object(first),
+                    after: State::Object(discarded),
+                },
+                RefChange {
+                    name: branch,
+                    before: State::Object(discarded),
+                    after: State::Object(replacement),
+                },
+            ],
+        )?;
+        let at_tip = position(&repo)?;
+        assert_eq!((at_tip.title.as_str(), at_tip.undo, at_tip.redo), ("replacement", 2, 0));
+        assert!(plan_redo(&repo)?.is_none(), "the old redo tail is no longer reachable");
+        Ok(())
+    }
+
+    #[test]
+    fn divergent_refs_fail_without_moving_the_cursor() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let branch = name("refs/heads/undo-test")?;
+        let expected = repo.head_id()?.detach();
+        let external = child(&repo, expected, "external")?;
+        set(&repo, branch.clone(), State::Missing, State::Object(expected))?;
+        record(
+            &repo,
+            "create branch",
+            &[RefChange {
+                name: branch.clone(),
+                before: State::Missing,
+                after: State::Object(expected),
+            }],
+        )?;
+        let plan = plan_undo(&repo)?.expect("the operation can be planned");
+        set(&repo, branch, State::Object(expected), State::Object(external))?;
+        assert!(plan.apply(&repo).is_err(), "the stale reference CAS is rejected");
+        assert_eq!(position(&repo)?.undo, 1, "the cursor remains at the applied operation");
+        Ok(())
+    }
+
+    #[test]
+    fn recording_accepts_a_ref_that_the_operation_deleted() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let branch = name("refs/heads/undo-test")?;
+        let head = repo.head_id()?.detach();
+        set(&repo, branch.clone(), State::Missing, State::Object(head))?;
+        set(&repo, branch.clone(), State::Object(head), State::Missing)?;
+
+        record(
+            &repo,
+            "delete branch",
+            &[RefChange {
+                name: branch.clone(),
+                before: State::Object(head),
+                after: State::Missing,
+            }],
+        )?
+        .expect("the deletion creates an entry");
+        plan_undo(&repo)?.expect("the deletion can be undone").apply(&repo)?;
+        assert_eq!(
+            repo.find_reference(branch.as_ref())?.id().detach(),
+            head,
+            "undo recreates the deleted reference"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn an_active_review_blocks_and_discards_ref_only_undo_history() -> gix_testtools::Result {
+        let (_fixture, repo) = repo()?;
+        let head = repo.head_id()?.detach();
+        let before_review = name("refs/heads/before-review")?;
+        set(&repo, before_review.clone(), State::Missing, State::Object(head))?;
+        record(
+            &repo,
+            "before review",
+            &[RefChange {
+                name: before_review,
+                before: State::Missing,
+                after: State::Object(head),
+            }],
+        )?;
+
+        let review = name("refs/worktree/tix/review/1")?;
+        set(&repo, review, State::Missing, State::Object(head))?;
+        assert!(
+            review_blocks_undo(&repo)?,
+            "a valid review reference blocks the ref-only queue"
+        );
+        assert!(
+            plan_undo(&repo)?.is_none(),
+            "review checkout state cannot be undone as refs alone"
+        );
+        assert_eq!(
+            position(&repo)?,
+            empty_position(),
+            "the blocked queue is not presented as available"
+        );
+
+        let during_review = name("refs/heads/during-review")?;
+        set(&repo, during_review.clone(), State::Missing, State::Object(head))?;
+        assert!(
+            record(
+                &repo,
+                "during review",
+                &[RefChange {
+                    name: during_review,
+                    before: State::Missing,
+                    after: State::Object(head),
+                }],
+            )?
+            .is_none(),
+            "operations during a review are deliberately not journalled"
+        );
+        assert!(
+            repo.try_find_reference(TIP_REF)?.is_none(),
+            "the old queue tip is discarded"
+        );
+        assert!(
+            repo.try_find_reference(CURSOR_REF)?.is_none(),
+            "the old queue cursor is discarded atomically"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn attached_branch_checkout_follows_undo_and_redo() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("forget_commit.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let top = repo.head_id()?.detach();
+        let parent = repo
+            .find_commit(top)?
+            .parent_ids()
+            .next()
+            .expect("the fixture tip has a parent")
+            .detach();
+        let branch = repo
+            .head()?
+            .referent_name()
+            .expect("the fixture HEAD is attached")
+            .to_owned();
+        let top_state = gix_testtools::repository::snapshot(fixture.path())?;
+        record(
+            &repo,
+            "restore tip",
+            &[RefChange {
+                name: branch,
+                before: State::Object(parent),
+                after: State::Object(top),
+            }],
+        )?;
+
+        plan_undo(&repo)?
+            .expect("the tip operation can be undone")
+            .apply_with_worktrees(&repo)?;
+        let undone = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(
+            undone.head,
+            gix_testtools::repository::Head::Symbolic {
+                name: b"refs/heads/main".into(),
+                id: parent,
+            }
+        );
+        assert_eq!(
+            undone.index_tree,
+            Some(repo.find_commit(parent)?.tree_id()?.detach()),
+            "the index follows the undo destination"
+        );
+        assert_eq!(std::fs::read(fixture.path().join("tracked"))?, b"base\n");
+        assert!(!fixture.path().join("added").exists());
+
+        plan_redo(&repo)?
+            .expect("the tip operation can be redone")
+            .apply_with_worktrees(&repo)?;
+        let redone = gix_testtools::repository::snapshot(fixture.path())?;
+        assert_eq!(redone.head, top_state.head);
+        assert_eq!(redone.index_tree, top_state.index_tree);
+        assert_eq!(redone.worktree, top_state.worktree);
+        Ok(())
+    }
+}
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index a496b877a5c..c9ebf84de5e 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -1450,6 +1450,12 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
         }
         let name = reference.name().to_owned();
         let target = reference.target().into_owned();
+        if let Some(target_name) = target.try_name()
+            && crate::edit::undo::ref_chain_reaches_queue(repo, target_name)?
+        {
+            tracing::warn!(name = %name, %label, "ignoring tix reference into the undo queue");
+            continue;
+        }
         if name.as_bstr() == HEAD_PIN_NAME
             && !target
                 .try_name()
@@ -1465,6 +1471,10 @@ fn refs_with_commit_targets(repo: &gix::Repository, prefix: &[u8], label: &str)
                 continue;
             }
         };
+        if crate::edit::undo::is_queue_commit(repo, id)? {
+            tracing::warn!(name = %name, %label, "ignoring tix reference to an undo queue commit");
+            continue;
+        }
         match repo.find_header(id) {
             Ok(header) if header.kind() == gix::object::Kind::Commit => {}
             Ok(_) => {
@@ -1517,6 +1527,10 @@ pub(crate) fn referenced_refs(
             .rev_parse(revision)
             .with_context(|| format!("could not parse revision {revision}"))?;
         for reference in [spec.first_reference(), spec.second_reference()].into_iter().flatten() {
+            anyhow::ensure!(
+                !crate::edit::undo::ref_chain_reaches_queue(repo, reference.name.as_ref())?,
+                "the undo queue is not a selectable revision"
+            );
             insert_ref_chain(repo, reference.name.as_bstr(), &mut out)?;
         }
     }
@@ -1746,17 +1760,40 @@ fn resolve_revisions(repo: &gix::Repository, revisions: &[OsString], kind: &str)
         .map(|revision| {
             let revision = gix::path::os_str_into_bstr(revision)
                 .with_context(|| format!("{kind}revision {} is not valid UTF-8", revision.to_string_lossy()))?;
-            repo.rev_parse_single(revision)
-                .with_context(|| format!("could not resolve {kind}revision {revision}"))?
-                .object()
-                .with_context(|| format!("could not read {kind}revision"))?
-                .peel_to_kind(gix::object::Kind::Commit)
-                .with_context(|| format!("{kind}revision does not resolve to a commit"))
-                .map(|object| object.id)
+            resolve_revision(repo, revision)
+                .with_context(|| format!("could not resolve {kind}revision {revision}"))
+                .map(|(id, _reference)| id)
         })
         .collect()
 }
 
+pub(crate) fn resolve_revision(
+    repo: &gix::Repository,
+    revision: &BStr,
+) -> Result<(ObjectId, Option<gix::refs::FullName>)> {
+    let spec = repo.rev_parse(revision)?;
+    let first_reference = spec.first_reference().map(|reference| reference.name.clone());
+    for reference in [spec.first_reference(), spec.second_reference()].into_iter().flatten() {
+        anyhow::ensure!(
+            !crate::edit::undo::ref_chain_reaches_queue(repo, reference.name.as_ref())?,
+            "the undo queue is not a selectable revision"
+        );
+    }
+    let id = spec
+        .single()
+        .context("revision does not name a single object")?
+        .object()
+        .context("could not read revision")?
+        .peel_to_kind(gix::object::Kind::Commit)
+        .context("revision does not resolve to a commit")?
+        .id;
+    anyhow::ensure!(
+        !crate::edit::undo::is_queue_commit(repo, id)?,
+        "the undo queue is not a selectable revision"
+    );
+    Ok((id, first_reference))
+}
+
 impl Authors {
     fn intern_author(&mut self, name: &[u8], email: &[u8]) -> &'static Author {
         let name = self.intern_string(name);
@@ -1809,7 +1846,7 @@ pub(crate) fn decorations_excluding(
             Err(err) => return Err(anyhow::anyhow!("could not read reference: {err}")),
         };
         let full_name = reference.name().to_owned();
-        if excluded.contains(full_name.as_bstr()) {
+        if excluded.contains(full_name.as_bstr()) || crate::edit::undo::is_queue_ref(full_name.as_bstr()) {
             continue;
         }
         if full_name.as_bstr() == HEAD_PIN_NAME {
@@ -2287,6 +2324,66 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn undo_queue_revisions_are_private_but_retained_commits_remain_selectable() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let retained = repo.head_id()?.detach();
+        let retained_ref: gix::refs::FullName = "refs/heads/undo-retained".try_into()?;
+        repo.reference(
+            retained_ref.clone(),
+            retained,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "prepare retained undo commit",
+        )?;
+        let entry = crate::edit::undo::record(
+            &repo,
+            "retain commit",
+            &[crate::edit::undo::RefChange {
+                name: retained_ref,
+                before: crate::edit::undo::State::Missing,
+                after: crate::edit::undo::State::Object(retained),
+            }],
+        )?
+        .expect("the reference change creates an undo entry");
+        let sentinel = repo
+            .find_commit(entry)?
+            .parent_ids()
+            .next()
+            .context("the undo entry has its queue predecessor")?
+            .detach();
+
+        for revision in [
+            crate::edit::undo::TIP_REF.to_owned(),
+            crate::edit::undo::CURSOR_REF.to_owned(),
+            entry.to_string(),
+            sentinel.to_string(),
+        ] {
+            let revision = BString::from(revision);
+            assert!(
+                resolve_revision(&repo, revision.as_bstr()).is_err(),
+                "queue revision {revision} is not selectable"
+            );
+            assert!(
+                snapshot(&repo, &[revision.to_os_str()?.to_owned()], &[], false).is_err(),
+                "queue revision {revision} cannot enter a history view"
+            );
+        }
+
+        let retained_revision = BString::from(retained.to_string());
+        assert_eq!(
+            resolve_revision(&repo, retained_revision.as_bstr())?.0,
+            retained,
+            "a commit retained as a non-first queue parent stays selectable"
+        );
+        assert_eq!(
+            snapshot(&repo, &[retained_revision.to_os_str()?.to_owned()], &[], false)?.view_tips,
+            [retained],
+            "retention does not make an ordinary commit private"
+        );
+        Ok(())
+    }
+
     #[test]
     fn discovers_worktree_decorations_and_optionally_adds_their_tips() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -2895,6 +2992,14 @@ mod tests {
             gix::refs::transaction::PreviousValue::MustNotExist,
             "test tree revisions",
         )?;
+        for name in [crate::edit::undo::TIP_REF, crate::edit::undo::CURSOR_REF] {
+            repo.reference(
+                name,
+                repo.head_id()?,
+                gix::refs::transaction::PreviousValue::MustNotExist,
+                "test undo reference filtering",
+            )?;
+        }
         let names = |include_tags| {
             ref_tree_revisions(&repo, include_tags).map(|revisions| {
                 revisions
@@ -2924,6 +3029,12 @@ mod tests {
                 .all(|name| !name.starts_with("refs/worktree/tix/pins/")),
             "ordinary pins never become tree traversal tips"
         );
+        assert!(
+            with_tags
+                .iter()
+                .all(|name| !crate::edit::undo::is_queue_ref(name.as_bytes().into())),
+            "undo queue refs never become tree traversal tips"
+        );
         Ok(())
     }
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 9b142bddd26..42403bc1442 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -989,6 +989,8 @@ fn event_loop(
     let mut pending_rebase_conflict: Option<edit::time_travel::Conflict> = None;
     let mut pending_todo_rebase_conflict: Option<edit::rebase::PlanConflict> = None;
     let mut pending_todo_rebase_plan: Option<edit::rebase::Plan> = None;
+    let mut pending_todo_ref_changes = Vec::new();
+    let mut pending_conflict_ref_changes = Vec::new();
     let result: Result<Option<Duration>> = (|| loop {
         if let Some(mut recovered) =
             recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
@@ -1560,6 +1562,15 @@ fn event_loop(
             continue;
         };
         if ref_tree.is_active() {
+            if matches!(
+                &terminal_event,
+                TerminalEvent::Key(KeyEvent {
+                    kind: KeyEventKind::Press | KeyEventKind::Repeat,
+                    ..
+                }) | TerminalEvent::Mouse(_)
+            ) {
+                app.dismiss_undo_position();
+            }
             match &terminal_event {
                 TerminalEvent::Key(key) if key.kind != KeyEventKind::Release => match ref_tree.handle_key(*key) {
                     ref_tree::Input::Handled => {
@@ -1570,16 +1581,23 @@ fn event_loop(
                     ref_tree::Input::PinReferences { id, kinds } => {
                         let result = open_repository(&repository_path, repository_is_bare, false)
                             .context("could not open repository to pin ref-tree references")
-                            .and_then(|repository| ref_tree::pin_references(&repository, id, &kinds));
+                            .and_then(|repository| ref_tree::pin_references_reporting(&repository, id, &kinds));
                         match result {
-                            Ok(pins) if !pins.is_empty() => {
+                            Ok((pins, changes)) if !pins.is_empty() => {
                                 app.select_commit_after_refresh(pins[0].id);
                                 return_to_history_after_refresh = Some(pins[0].id);
-                                app.leave_success(if pins.len() == 1 {
-                                    "pinned selected reference".into()
-                                } else {
-                                    format!("pinned {} selected references", pins.len())
-                                });
+                                leave_recorded_success(
+                                    &mut app,
+                                    &repository_path,
+                                    repository_is_bare,
+                                    "pin references",
+                                    &changes,
+                                    if pins.len() == 1 {
+                                        "pinned selected reference".into()
+                                    } else {
+                                        format!("pinned {} selected references", pins.len())
+                                    },
+                                );
                                 refresh_pending = true;
                                 refresh_expand_hidden = true;
                             }
@@ -1617,24 +1635,56 @@ fn event_loop(
                         };
                         let mut deleted = false;
                         match open_repository(&repository_path, repository_is_bare, false) {
-                            Ok(mut repository) => match repository.delete_local_branches(names) {
-                                Ok(()) => {
-                                    ref_tree.leave_success(format!("deleted {label}"));
+                            Ok(mut repository) => {
+                                let before = names
+                                    .iter()
+                                    .map(|name| {
+                                        edit::undo::state(&repository, name.as_ref()).map(|state| (name.clone(), state))
+                                    })
+                                    .collect::<Result<Vec<_>>>();
+                                let result = repository.delete_local_branches(names);
+                                let changed = result.is_ok()
+                                    || result.as_ref().is_err_and(|err| {
+                                        matches!(err, gix::repository::branch::delete::Error::Cleanup { .. })
+                                    });
+                                if changed {
+                                    let recorded = before
+                                        .and_then(|before| {
+                                            before
+                                                .into_iter()
+                                                .map(|(name, before)| {
+                                                    edit::undo::state(&repository, name.as_ref())
+                                                        .map(|after| edit::undo::RefChange { name, before, after })
+                                                })
+                                                .collect::<Result<Vec<_>>>()
+                                        })
+                                        .map(|changes| {
+                                            changes
+                                                .into_iter()
+                                                .filter(|change| change.before != change.after)
+                                                .collect::<Vec<_>>()
+                                        })
+                                        .and_then(|changes| {
+                                            edit::undo::record(&repository, "delete local branches", &changes)
+                                                .map(|_| ())
+                                        });
+                                    let message = result.as_ref().map_or_else(
+                                        |err| format!("delete {label}: {err}"),
+                                        |()| format!("deleted {label}"),
+                                    );
+                                    match (result, recorded) {
+                                        (Ok(()), Ok(())) => ref_tree.leave_success(message),
+                                        (_, Ok(())) => ref_tree.leave_attention(message),
+                                        (_, Err(err)) => {
+                                            ref_tree.leave_attention(format!("{message}; undo history: {err:#}"));
+                                        }
+                                    }
                                     deleted = true;
                                     refresh_pending = true;
+                                } else if let Err(err) = result {
+                                    ref_tree.leave_error(format!("delete {label}: {err}"));
                                 }
-                                Err(err) => {
-                                    let changed =
-                                        matches!(&err, gix::repository::branch::delete::Error::Cleanup { .. });
-                                    if changed {
-                                        ref_tree.leave_attention(format!("delete {label}: {err}"));
-                                    } else {
-                                        ref_tree.leave_error(format!("delete {label}: {err}"));
-                                    }
-                                    deleted = changed;
-                                    refresh_pending |= changed;
-                                }
-                            },
+                            }
                             Err(err) => ref_tree.leave_error(format!("delete {label}: {err:#}")),
                         }
                         if deleted {
@@ -1684,7 +1734,7 @@ fn event_loop(
             }
         }
         let key_pressed = is_key_press(&terminal_event);
-        let (action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
+        let (mut action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
                 let action = action_with_shortcut_groups(
                     key,
@@ -1792,13 +1842,29 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        if key_pressed
+            && action == Some(Action::OpenDiff)
+            && app.changes_focus.is_none()
+            && !pending_conflict_ref_changes.is_empty()
+        {
+            action = Some(Action::Amend);
+        }
         if key_pressed
             && action == Some(Action::Cancel)
             && pending_rebase_conflict.is_none()
             && pending_todo_rebase_conflict.is_none()
             && app.has_rebase_conflict()
         {
+            let recorded = record_and_clear_pending_undo(
+                &repository_path,
+                repository_is_bare,
+                "materialize time-travel conflict",
+                &mut pending_conflict_ref_changes,
+            );
             app.clear_rebase_conflict();
+            if let Err(err) = recorded {
+                app.leave_attention(format!("cancelled conflict; undo history: {err:#}"));
+            }
             dirty = true;
             urgent = true;
             continue;
@@ -1810,13 +1876,15 @@ fn event_loop(
                     .expect("a pending conflict was checked before accepting it");
                 let original = conflict.original();
                 match conflict.accept() {
-                    Ok((notice, id, _)) => {
+                    Ok((notice, id, _, ref_changes)) => {
+                        pending_conflict_ref_changes = ref_changes;
                         tracing::info!(commit_id = %original, rewritten_id = %id, "accepted suspended rebase conflict");
                         app.begin_conflict_resolution();
                         app.leave_attention(notice);
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
+                        pending_conflict_ref_changes.clear();
                         tracing::warn!(commit_id = %original, error = %err, "suspended rebase conflict checkout failed");
                         app.clear_rebase_conflict();
                         app.leave_error(format!("conflict checkout: {err:#}"));
@@ -1850,7 +1918,17 @@ fn event_loop(
                     .take()
                     .expect("a pending conflict was checked before discarding it");
                 tracing::info!(commit_id = %conflict.original(), "discarded suspended rebase conflict");
+                let mut changes = conflict.into_ref_changes();
+                let recorded = record_and_clear_pending_undo(
+                    &repository_path,
+                    repository_is_bare,
+                    "time travel before conflict",
+                    &mut changes,
+                );
                 app.clear_rebase_conflict();
+                if let Err(err) = recorded {
+                    app.leave_attention(format!("cancelled conflict; undo history: {err:#}"));
+                }
                 dirty = true;
                 urgent = true;
                 continue;
@@ -1862,14 +1940,15 @@ fn event_loop(
                     .take()
                     .expect("a pending todo conflict was checked before accepting it");
                 let plan = conflict.continuation_plan();
-                match edit::time_travel::materialize_plan_conflict(
+                match edit::time_travel::materialize_plan_conflict_reporting(
                     conflict,
                     &repository_path,
                     repository_is_bare,
                     &revisions,
                     false,
                 ) {
-                    Ok((notice, id, _)) => {
+                    Ok((notice, id, _, mut ref_changes)) => {
+                        pending_todo_ref_changes.append(&mut ref_changes);
                         pending_todo_rebase_plan = Some(plan);
                         app.begin_conflict_resolution();
                         app.arm_rebase_continuation();
@@ -1877,6 +1956,7 @@ fn event_loop(
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
+                        pending_todo_ref_changes.clear();
                         app.clear_rebase_conflict();
                         app.leave_error(format!("conflict checkout: {err:#}"));
                     }
@@ -1892,7 +1972,16 @@ fn event_loop(
                     .take()
                     .expect("a pending todo conflict was checked before discarding it");
                 tracing::info!(commit_id = %conflict.original(), "discarded suspended todo rebase conflict");
+                let recorded = record_and_clear_pending_undo(
+                    &repository_path,
+                    repository_is_bare,
+                    "materialize rebase conflict",
+                    &mut pending_todo_ref_changes,
+                );
                 app.clear_rebase_conflict();
+                if let Err(err) = recorded {
+                    app.leave_attention(format!("cancelled rebase conflict; undo history: {err:#}"));
+                }
                 refresh_pending = true;
                 dirty = true;
                 urgent = true;
@@ -1912,8 +2001,18 @@ fn event_loop(
             && pending_todo_rebase_plan.is_some()
         {
             drop(pending_todo_rebase_plan.take());
+            let recorded = record_and_clear_pending_undo(
+                &repository_path,
+                repository_is_bare,
+                "materialize rebase conflict",
+                &mut pending_todo_ref_changes,
+            );
             app.clear_rebase_continuation();
-            app.leave_attention("stopped rebase continuation; the partially applied repository remains unchanged");
+            let message = "stopped rebase continuation; the partially applied repository remains unchanged";
+            app.leave_attention(match recorded {
+                Ok(()) => message.into(),
+                Err(err) => format!("{message}; undo history: {err:#}"),
+            });
             tracing::info!("stopped materialized rebase continuation without rolling back repository state");
             dirty = true;
             urgent = true;
@@ -1940,7 +2039,7 @@ fn event_loop(
                     let notice = outcome
                         .selected
                         .map(|selected| {
-                            edit::time_travel::checkout_without_replay(
+                            edit::time_travel::checkout_without_replay_reporting(
                                 &repository_path,
                                 repository_is_bare,
                                 selected,
@@ -1949,14 +2048,27 @@ fn event_loop(
                             )
                         })
                         .transpose()
-                        .map(Option::flatten);
+                        .map(|result| result.map_or((None, Vec::new()), |(notice, changes)| (notice, changes)));
                     app.clear_rebase_conflict();
                     app.clear_rebase_continuation();
                     app.set_worktree_conflicted(false);
-                    match notice {
-                        Ok(notice) => app.leave_success(notice.unwrap_or_else(|| "rebased history".into())),
-                        Err(err) => app.leave_attention(format!("rebase applied, checkout failed: {err:#}")),
-                    }
+                    let mut changes = std::mem::take(&mut pending_todo_ref_changes);
+                    changes.extend(outcome.ref_changes.iter().cloned());
+                    let message = match notice {
+                        Ok((notice, mut checkout_changes)) => {
+                            changes.append(&mut checkout_changes);
+                            notice.unwrap_or_else(|| "rebased history".into())
+                        }
+                        Err(err) => format!("rebase applied, checkout failed: {err:#}"),
+                    };
+                    leave_recorded_success(
+                        &mut app,
+                        &repository_path,
+                        repository_is_bare,
+                        "rebase history",
+                        &changes,
+                        message,
+                    );
                     refresh_pending = true;
                 }
                 Ok(edit::rebase::PlanPerform::Conflict(conflict)) => {
@@ -1989,10 +2101,20 @@ fn event_loop(
             urgent = true;
             continue;
         }
+        if !pending_conflict_ref_changes.is_empty()
+            && action != Some(Action::Amend)
+            && !action_allowed_during_rebase_continuation(action.as_ref(), app.changes_focus.is_some())
+        {
+            app.leave_attention("resolve the checked-out conflict, then press <enter> to amend");
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         let Some(action) = action else {
             continue;
         };
         if action == Action::ToggleRefTree {
+            app.dismiss_undo_position();
             if ref_tree.is_active() {
                 ref_tree.leave();
             } else {
@@ -2066,6 +2188,73 @@ fn event_loop(
         for effect in effects {
             match effect {
                 Effect::Cancel => cancelled.store(true, Ordering::Relaxed),
+                direction @ (Effect::Undo | Effect::Redo) => {
+                    let undoing = matches!(direction, Effect::Undo);
+                    fill_repository.retain = false;
+                    fill_repository.retained = None;
+                    let repository = open_repository(&repository_path, repository_is_bare, false)
+                        .context("could not open repository for undo")?;
+                    match edit::undo::review_blocks_undo(&repository) {
+                        Ok(true) => {
+                            app.dismiss_undo_position();
+                            app.leave_attention("undo and redo are unavailable during a review");
+                            continue;
+                        }
+                        Ok(false) => {}
+                        Err(err) => {
+                            app.dismiss_undo_position();
+                            app.leave_error(format!("undo: {err:#}"));
+                            continue;
+                        }
+                    }
+                    let current = edit::undo::position(&repository);
+                    let planned = if undoing {
+                        edit::undo::plan_undo(&repository)
+                    } else {
+                        edit::undo::plan_redo(&repository)
+                    };
+                    match planned {
+                        Ok(Some(plan)) => {
+                            let crossed = plan.title.clone();
+                            let position = plan.position.clone();
+                            match plan.apply(&repository) {
+                                Ok(()) => {
+                                    pending_conflict_ref_changes.clear();
+                                    app.show_undo_position(
+                                        position.undo,
+                                        position.undo + position.redo,
+                                        position.title,
+                                    );
+                                    if let Ok(id) = repository.head_id() {
+                                        app.select_commit_after_refresh(id.detach());
+                                    }
+                                    invalidate_worktree_changes(&mut worktree_changes);
+                                    refresh_pending = true;
+                                }
+                                Err(err) => {
+                                    if let Ok(position) = current {
+                                        app.show_undo_position(
+                                            position.undo,
+                                            position.undo + position.redo,
+                                            position.title,
+                                        );
+                                    }
+                                    app.leave_error(format!(
+                                        "{} {crossed}: {err:#}",
+                                        if undoing { "undo" } else { "redo" }
+                                    ));
+                                }
+                            }
+                        }
+                        Ok(None) => {
+                            if let Ok(position) = current {
+                                app.show_undo_position(position.undo, position.undo + position.redo, position.title);
+                            }
+                            app.leave_attention(if undoing { "nothing to undo" } else { "nothing to redo" });
+                        }
+                        Err(err) => app.leave_error(format!("{}: {err:#}", if undoing { "undo" } else { "redo" })),
+                    }
+                }
                 Effect::CopyId(id) => execute!(
                     terminal.backend_mut(),
                     CopyToClipboard::to_clipboard_from(id.to_hex().to_string())
@@ -2140,23 +2329,36 @@ fn event_loop(
                         });
                     match result {
                         Ok(Some(edit::reword::Outcome {
-                            commit: Some(new_id), ..
+                            commit: Some(new_id),
+                            ref_changes,
+                            ..
                         })) => {
-                            app.leave_success(format!(
-                                "reworded {} as {}",
-                                id.to_hex_with_len(7),
-                                new_id.to_hex_with_len(7)
-                            ));
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "reword commit",
+                                &ref_changes,
+                                format!("reworded {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7)),
+                            );
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(Some(edit::reword::Outcome {
                             enrichment: Some(enrichment),
+                            ref_changes,
                             ..
                         })) => {
                             app.clear_enrichments();
                             app.set_enrichment(id, enrichment);
-                            app.leave_success("updated enrichment");
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "edit commit enrichment",
+                                &ref_changes,
+                                "updated enrichment",
+                            );
                         }
                         Ok(None) => {}
                         Ok(Some(_)) => {}
@@ -2183,8 +2385,16 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(Some(new_id)) => {
-                            app.leave_success(format!("created {}", new_id.to_hex_with_len(7)));
+                        Ok(Some(outcome)) => {
+                            let new_id = outcome.selected.context("creating a commit did not select it")?;
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                if empty { "create empty commit" } else { "create commit" },
+                                &outcome.ref_changes,
+                                format!("created {}", new_id.to_hex_with_len(7)),
+                            );
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
@@ -2210,7 +2420,9 @@ fn event_loop(
                             )
                         });
                     match created {
-                        Ok(Some(new_id)) => {
+                        Ok(Some(outcome)) => {
+                            let new_id = outcome.selected.context("creating a fork did not select it")?;
+                            let ref_changes = outcome.ref_changes;
                             let review_roots: Vec<_> =
                                 app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
                             let travel = open_repository(&repository_path, repository_is_bare, false)
@@ -2228,26 +2440,48 @@ fn event_loop(
                                     )
                                 });
                             match travel {
-                                Ok(edit::time_travel::Perform::Complete { notice, selected, .. }) => {
-                                    app.leave_success(notice.map_or_else(
-                                        || format!("created fork {}", new_id.to_hex_with_len(7)),
-                                        |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
-                                    ));
+                                Ok(edit::time_travel::Perform::Complete {
+                                    notice,
+                                    selected,
+                                    ref_changes: mut travel_changes,
+                                    ..
+                                }) => {
+                                    let mut changes = ref_changes;
+                                    changes.append(&mut travel_changes);
+                                    leave_recorded_success(
+                                        &mut app,
+                                        &repository_path,
+                                        repository_is_bare,
+                                        "fork commit",
+                                        &changes,
+                                        notice.map_or_else(
+                                            || format!("created fork {}", new_id.to_hex_with_len(7)),
+                                            |notice| format!("created fork {}; {notice}", new_id.to_hex_with_len(7)),
+                                        ),
+                                    );
                                     app.select_commit_after_refresh(selected);
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
-                                Ok(edit::time_travel::Perform::Conflict(conflict)) => {
+                                Ok(edit::time_travel::Perform::Conflict(mut conflict)) => {
+                                    conflict.prepend_ref_changes(ref_changes);
                                     let original = conflict.original();
                                     app.arm_rebase_conflict(original);
                                     app.select_commit(original);
                                     pending_rebase_conflict = Some(conflict);
                                 }
                                 Err(err) => {
-                                    app.leave_attention(format!(
-                                        "created fork {}, but checkout failed: {err:#}",
-                                        new_id.to_hex_with_len(7)
-                                    ));
+                                    leave_recorded_success(
+                                        &mut app,
+                                        &repository_path,
+                                        repository_is_bare,
+                                        "fork commit",
+                                        &ref_changes,
+                                        format!(
+                                            "created fork {}, but checkout failed: {err:#}",
+                                            new_id.to_hex_with_len(7)
+                                        ),
+                                    );
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
@@ -2267,12 +2501,16 @@ fn event_loop(
                             split_commit(terminal, &repository_path, repository_is_bare, graph, enhanced_keyboard)
                         });
                     match result {
-                        Ok(Some(new_id)) => {
-                            app.leave_success(format!(
-                                "split {} as {}",
-                                id.to_hex_with_len(7),
-                                new_id.to_hex_with_len(7)
-                            ));
+                        Ok(Some(outcome)) => {
+                            let new_id = outcome.selected.context("splitting HEAD did not select its result")?;
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "split commit",
+                                &outcome.ref_changes,
+                                format!("split {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7)),
+                            );
                             invalidate_worktree_changes(&mut worktree_changes);
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
@@ -2324,9 +2562,13 @@ fn event_loop(
                         .context("editing HEAD requires a completed history graph")
                         .and_then(|graph| {
                             path.and_then(|path| {
-                                edit::head::perform(
-                                    open_repository(&repository_path, repository_is_bare, false)
-                                        .context("could not open repository for HEAD edit")?,
+                                let repository = open_repository(&repository_path, repository_is_bare, false)
+                                    .context("could not open repository for HEAD edit")?;
+                                if kind == edit::head::Kind::Amend && !pending_conflict_ref_changes.is_empty() {
+                                    stage_resolved_conflict_paths(&repository)?;
+                                }
+                                edit::head::perform_with_changes(
+                                    repository,
                                     graph,
                                     kind,
                                     path.as_ref().map(|(path, parent)| (path, *parent)),
@@ -2334,12 +2576,27 @@ fn event_loop(
                             })
                         });
                     match result {
-                        Ok(Some(new_id)) => {
-                            app.leave_success(format!(
-                                "{verb}ed {} as {}",
-                                id.to_hex_with_len(7),
-                                new_id.to_hex_with_len(7)
-                            ));
+                        Ok(Some(outcome)) => {
+                            let new_id = outcome.selected.context("editing HEAD did not select its result")?;
+                            let mut changes = if kind == edit::head::Kind::Amend {
+                                std::mem::take(&mut pending_conflict_ref_changes)
+                            } else {
+                                Vec::new()
+                            };
+                            let resolved_conflict = !changes.is_empty();
+                            changes.extend(outcome.ref_changes.iter().cloned());
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                if resolved_conflict {
+                                    "resolve rebase conflict"
+                                } else {
+                                    verb
+                                },
+                                &changes,
+                                format!("{verb}ed {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7)),
+                            );
                             invalidate_worktree_changes(&mut worktree_changes);
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
@@ -2377,14 +2634,25 @@ fn event_loop(
                 Effect::Forget(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
+                    let cancels_review = app.rows.iter().any(|row| row.id == id && row.is_review);
+                    if cancels_review {
+                        app.dismiss_undo_position();
+                    }
                     let result = history_graph
                         .as_ref()
                         .context("forget requires a completed history graph")
-                        .and_then(|graph| forget_commit(&repository_path, repository_is_bare, graph, id));
+                        .and_then(|graph| {
+                            if cancels_review {
+                                clear_undo_history(&repository_path, repository_is_bare)
+                                    .context("could not clear undo history before cancelling review")?;
+                            }
+                            forget_commit(&repository_path, repository_is_bare, graph, id)
+                        });
                     match result {
                         Ok(outcome) => {
+                            let ref_changes = outcome.ref_changes.clone();
                             let returned = outcome.review_return.as_ref().map(|name| {
-                                edit::time_travel::checkout_review_return(
+                                edit::time_travel::checkout_review_return_reporting(
                                     &repository_path,
                                     repository_is_bare,
                                     name,
@@ -2393,15 +2661,52 @@ fn event_loop(
                                 )
                             });
                             match returned.transpose() {
-                                Ok(Some((selected, _))) => {
-                                    app.leave_attention("cancelled review");
+                                Ok(Some((selected, _, mut checkout_changes))) => {
+                                    let mut changes = ref_changes;
+                                    changes.append(&mut checkout_changes);
+                                    if cancels_review {
+                                        app.leave_success("cancelled review");
+                                    } else {
+                                        leave_recorded_success(
+                                            &mut app,
+                                            &repository_path,
+                                            repository_is_bare,
+                                            "cancel review",
+                                            &changes,
+                                            "cancelled review",
+                                        );
+                                    }
                                     app.select_commit_after_refresh(selected);
                                 }
                                 Err(err) => {
-                                    app.leave_attention(format!("review cancelled, return checkout failed: {err:#}"));
+                                    let message = format!("review cancelled, return checkout failed: {err:#}");
+                                    if cancels_review {
+                                        app.leave_attention(message);
+                                    } else {
+                                        leave_recorded_success(
+                                            &mut app,
+                                            &repository_path,
+                                            repository_is_bare,
+                                            "forget commit",
+                                            &ref_changes,
+                                            message,
+                                        );
+                                    }
                                 }
                                 Ok(None) => {
-                                    app.leave_success(format!("forgot {}", id.to_hex_with_len(7)));
+                                    let message = format!("forgot {}", id.to_hex_with_len(7));
+                                    if cancels_review {
+                                        app.leave_success(message);
+                                    } else {
+                                        leave_recorded_success(
+                                            &mut app,
+                                            &repository_path,
+                                            repository_is_bare,
+                                            "forget commit",
+                                            &ref_changes,
+                                            message,
+                                        );
+                                    }
                                     if let Some(selected) = outcome.selected {
                                         app.select_commit(selected);
                                     }
@@ -2440,7 +2745,7 @@ fn event_loop(
                     match result {
                         Ok(Some(edit::rebase::PlanPerform::Complete(outcome))) => {
                             let notice = if outcome.selected.is_some() {
-                                edit::time_travel::checkout_plan(
+                                edit::time_travel::checkout_plan_reporting(
                                     &repository_path,
                                     repository_is_bare,
                                     &outcome,
@@ -2448,17 +2753,31 @@ fn event_loop(
                                     false,
                                 )
                             } else {
-                                Ok(None)
+                                Ok((None, outcome.ref_changes.clone()))
                             };
                             match notice {
-                                Ok(notice) => {
-                                    app.leave_success(notice.unwrap_or_else(|| "rebased history".to_owned()));
+                                Ok((notice, changes)) => {
+                                    leave_recorded_success(
+                                        &mut app,
+                                        &repository_path,
+                                        repository_is_bare,
+                                        "rebase history",
+                                        &changes,
+                                        notice.unwrap_or_else(|| "rebased history".to_owned()),
+                                    );
                                     app.select_commit_after_refresh(base);
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
                                 Err(err) => {
-                                    app.leave_attention(format!("rebase applied, checkout failed: {err:#}"));
+                                    leave_recorded_success(
+                                        &mut app,
+                                        &repository_path,
+                                        repository_is_bare,
+                                        "rebase history",
+                                        &outcome.ref_changes,
+                                        format!("rebase applied, checkout failed: {err:#}"),
+                                    );
                                     invalidate_worktree_changes(&mut worktree_changes);
                                     refresh_pending = true;
                                 }
@@ -2498,7 +2817,7 @@ fn event_loop(
                         Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
                             let combined = outcome.map(target).unwrap_or(target);
                             let notice = if outcome.selected.is_some() {
-                                edit::time_travel::checkout_plan(
+                                edit::time_travel::checkout_plan_reporting(
                                     &repository_path,
                                     repository_is_bare,
                                     &outcome,
@@ -2506,18 +2825,36 @@ fn event_loop(
                                     false,
                                 )
                             } else {
-                                Ok(None)
+                                Ok((None, outcome.ref_changes.clone()))
                             };
-                            match notice {
-                                Ok(notice) => app.leave_success(notice.unwrap_or_else(|| {
-                                    format!(
-                                        "squashed {} into {}",
-                                        source.to_hex_with_len(7),
-                                        combined.to_hex_with_len(7)
+                            let (message, changes) = notice.map_or_else(
+                                |err| {
+                                    (
+                                        format!("squash applied, checkout failed: {err:#}"),
+                                        outcome.ref_changes.clone(),
                                     )
-                                })),
-                                Err(err) => app.leave_attention(format!("squash applied, checkout failed: {err:#}")),
-                            }
+                                },
+                                |(notice, changes)| {
+                                    (
+                                        notice.unwrap_or_else(|| {
+                                            format!(
+                                                "squashed {} into {}",
+                                                source.to_hex_with_len(7),
+                                                combined.to_hex_with_len(7)
+                                            )
+                                        }),
+                                        changes,
+                                    )
+                                },
+                            );
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "squash commits",
+                                &changes,
+                                message,
+                            );
                             app.select_commit_after_refresh(combined);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
@@ -2569,32 +2906,56 @@ fn event_loop(
                             } else {
                                 outcome.map(source).unwrap_or(source)
                             };
-                            let notice = edit::time_travel::checkout_plan(
+                            let notice = edit::time_travel::checkout_plan_reporting(
                                 &repository_path,
                                 repository_is_bare,
                                 &outcome,
                                 &revisions,
                                 false,
                             );
-                            match notice {
-                                Ok(notice) => app.leave_success(notice.unwrap_or_else(|| {
-                                    if copy {
-                                        format!(
-                                            "copied {} as {} above {}",
-                                            source.to_hex_with_len(7),
-                                            inserted.to_hex_with_len(7),
-                                            target.to_hex_with_len(7)
-                                        )
-                                    } else {
-                                        format!(
-                                            "inserted {} above {}",
-                                            inserted.to_hex_with_len(7),
-                                            target.to_hex_with_len(7)
-                                        )
-                                    }
-                                })),
-                                Err(err) => app.leave_attention(format!("insert applied, checkout failed: {err:#}")),
-                            }
+                            let (message, changes) = notice.map_or_else(
+                                |err| {
+                                    (
+                                        format!("insert applied, checkout failed: {err:#}"),
+                                        outcome.ref_changes.clone(),
+                                    )
+                                },
+                                |(notice, changes)| {
+                                    (
+                                        notice.unwrap_or_else(|| {
+                                            if copy {
+                                                format!(
+                                                    "copied {} as {} above {}",
+                                                    source.to_hex_with_len(7),
+                                                    inserted.to_hex_with_len(7),
+                                                    target.to_hex_with_len(7)
+                                                )
+                                            } else {
+                                                format!(
+                                                    "inserted {} above {}",
+                                                    inserted.to_hex_with_len(7),
+                                                    target.to_hex_with_len(7)
+                                                )
+                                            }
+                                        }),
+                                        changes,
+                                    )
+                                },
+                            );
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                if copy {
+                                    "copy-insert commit"
+                                } else if base == source {
+                                    "move-insert commit"
+                                } else {
+                                    "stack-insert commits"
+                                },
+                                &changes,
+                                message,
+                            );
                             app.select_commit_after_refresh(inserted);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
@@ -2624,11 +2985,16 @@ fn event_loop(
                         .and_then(|graph| edit::review::start(&repository_path, repository_is_bare, graph, tip, base));
                     match result {
                         Ok(started) => {
-                            app.leave_success(format!(
+                            app.dismiss_undo_position();
+                            let message = format!(
                                 "started review {} at {}",
                                 started.reference.shorten(),
                                 started.commit.to_hex_with_len(7)
-                            ));
+                            );
+                            match clear_undo_history(&repository_path, repository_is_bare) {
+                                Ok(()) => app.leave_success(message),
+                                Err(err) => app.leave_attention(format!("{message}; undo history: {err:#}")),
+                            }
                             app.select_commit_after_refresh(started.commit);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
@@ -2645,27 +3011,25 @@ fn event_loop(
                         .and_then(|graph| {
                             let mut repo = open_repository(&repository_path, repository_is_bare, false)
                                 .context("could not open repository to finish review")?;
+                            edit::undo::clear(&repo).context("could not clear undo history before finishing review")?;
                             repo.object_cache_size(None);
                             edit::review::finish(repo, graph, id, return_to)
                         });
                     match result {
                         Ok(edit::review::Finish::Complete(finished)) => {
-                            let checkout = edit::time_travel::checkout_plan(
+                            let checkout = edit::time_travel::checkout_plan_reporting(
                                 &repository_path,
                                 repository_is_bare,
                                 &finished.outcome,
                                 &revisions,
                                 false,
                             );
-                            match checkout {
-                                Ok(_) => app.leave_success(format!(
-                                    "finished review as {}",
-                                    finished.commit.to_hex_with_len(7)
-                                )),
-                                Err(err) => {
-                                    app.leave_attention(format!("review applied, return checkout failed: {err:#}"));
-                                }
-                            }
+                            let message = checkout.map_or_else(
+                                |err| format!("review applied, return checkout failed: {err:#}"),
+                                |(_, _changes)| format!("finished review as {}", finished.commit.to_hex_with_len(7)),
+                            );
+                            app.dismiss_undo_position();
+                            app.leave_success(message);
                             app.select_commit_after_refresh(finished.outcome.selected.unwrap_or(finished.commit));
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
@@ -2683,9 +3047,16 @@ fn event_loop(
                 Effect::Attach => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    match edit::time_travel::attach(&repository_path, repository_is_bare, &revisions, false) {
-                        Ok(notice) => {
-                            app.leave_success(notice);
+                    match edit::time_travel::attach_reporting(&repository_path, repository_is_bare, &revisions, false) {
+                        Ok((notice, changes)) => {
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "attach HEAD",
+                                &changes,
+                                notice,
+                            );
                             refresh_pending = true;
                         }
                         Err(err) => app.leave_error(format!("attach: {err:#}")),
@@ -2739,10 +3110,19 @@ fn event_loop(
                         });
                     match result {
                         Ok(edit::time_travel::Perform::Complete {
-                            notice: Some(notice), ..
+                            notice: Some(notice),
+                            ref_changes,
+                            ..
                         }) => {
                             tracing::info!(selected = %id, %notice, "completed time-travel action");
-                            app.leave_success(notice);
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "time travel",
+                                &ref_changes,
+                                notice,
+                            );
                             if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
                                 .and_then(|repo| Ok(repo.head_id()?.detach()))
                             {
@@ -2751,7 +3131,22 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
-                        Ok(edit::time_travel::Perform::Complete { notice: None, .. }) => {}
+                        Ok(edit::time_travel::Perform::Complete {
+                            notice: None,
+                            ref_changes,
+                            ..
+                        }) => {
+                            if !ref_changes.is_empty() {
+                                leave_recorded_success(
+                                    &mut app,
+                                    &repository_path,
+                                    repository_is_bare,
+                                    "time travel",
+                                    &ref_changes,
+                                    "time-travelled",
+                                );
+                            }
+                        }
                         Ok(edit::time_travel::Perform::Conflict(conflict)) => {
                             let original = conflict.original();
                             app.arm_rebase_conflict(original);
@@ -2768,14 +3163,28 @@ fn event_loop(
                 Effect::TogglePin(id) => {
                     fill_repository.retain = false;
                     fill_repository.retained = None;
-                    match edit::time_travel::toggle_pin(&repository_path, repository_is_bare, id) {
-                        Ok(edit::time_travel::PinToggle::Removed(count)) => {
-                            app.leave_success(format!("removed {count} pin{}", if count == 1 { "" } else { "s" }));
+                    match edit::time_travel::toggle_pin_reporting(&repository_path, repository_is_bare, id) {
+                        Ok((edit::time_travel::PinToggle::Removed(count), changes)) => {
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "unpin commit",
+                                &changes,
+                                format!("removed {count} pin{}", if count == 1 { "" } else { "s" }),
+                            );
                             app.select_commit_after_refresh(id);
                             refresh_pending = true;
                         }
-                        Ok(edit::time_travel::PinToggle::Created) => {
-                            app.leave_success("pinned selected commit");
+                        Ok((edit::time_travel::PinToggle::Created, changes)) => {
+                            leave_recorded_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "pin commit",
+                                &changes,
+                                "pinned selected commit",
+                            );
                             app.select_commit_after_refresh(id);
                             refresh_pending = true;
                         }
@@ -2787,17 +3196,24 @@ fn event_loop(
                     fill_repository.retained = None;
                     let result = open_repository(&repository_path, repository_is_bare, false)
                         .context("could not open repository to update the enrichment")
-                        .and_then(|repo| enrich::toggle(&repo, id));
+                        .and_then(|repo| tracked_ref_update(&repo, enrich::REF_NAME, |repo| enrich::toggle(repo, id)));
                     match result {
-                        Ok(enrichment) => {
+                        Ok((enrichment, changes)) => {
                             let enabled = enrichment.todo;
                             app.clear_enrichments();
                             app.set_enrichment(id, enrichment);
-                            app.leave_success(if enabled {
-                                "marked commit todo"
-                            } else {
-                                "cleared commit todo"
-                            });
+                            leave_tracked_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "toggle todo",
+                                changes,
+                                if enabled {
+                                    "marked commit todo"
+                                } else {
+                                    "cleared commit todo"
+                                },
+                            );
                         }
                         Err(err) => app.leave_error(format!("todo: {err:#}")),
                     }
@@ -2807,17 +3223,28 @@ fn event_loop(
                     fill_repository.retained = None;
                     let result = open_repository(&repository_path, repository_is_bare, false)
                         .context("could not open repository to update the tree enrichment")
-                        .and_then(|repo| enrich::toggle_checks_pass(&repo, id));
+                        .and_then(|repo| {
+                            tracked_ref_update(&repo, enrich::TREE_REF_NAME, |repo| {
+                                enrich::toggle_checks_pass(repo, id)
+                            })
+                        });
                     match result {
-                        Ok(enrichment) => {
+                        Ok((enrichment, changes)) => {
                             let enabled = enrichment.checks_pass;
                             app.clear_enrichments();
                             app.set_tree_enrichment(id, enrichment);
-                            app.leave_success(if enabled {
-                                "marked tree checks-pass"
-                            } else {
-                                "cleared tree checks-pass"
-                            });
+                            leave_tracked_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "toggle checks-pass",
+                                changes,
+                                if enabled {
+                                    "marked tree checks-pass"
+                                } else {
+                                    "cleared tree checks-pass"
+                                },
+                            );
                         }
                         Err(err) => app.leave_error(format!("checks-pass: {err:#}")),
                     }
@@ -2826,11 +3253,18 @@ fn event_loop(
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     match edit_note(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
-                        Ok(Some(enrichment)) => {
+                        Ok(Some((enrichment, changes))) => {
                             let has_note = enrichment.note.is_some();
                             app.clear_enrichments();
                             app.set_enrichment(id, enrichment);
-                            app.leave_success(if has_note { "saved note" } else { "cleared note" });
+                            leave_tracked_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "edit commit note",
+                                changes,
+                                if has_note { "saved note" } else { "cleared note" },
+                            );
                         }
                         Ok(None) => {}
                         Err(err) => app.leave_error(format!("note: {err:#}")),
@@ -2840,9 +3274,16 @@ fn event_loop(
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     match edit_git_note(terminal, &repository_path, repository_is_bare, id, enhanced_keyboard) {
-                        Ok(Some(saved)) => {
+                        Ok(Some((saved, changes))) => {
                             app.clear_notes(id);
-                            app.leave_success(if saved { "saved Git note" } else { "cleared Git note" });
+                            leave_tracked_success(
+                                &mut app,
+                                &repository_path,
+                                repository_is_bare,
+                                "edit Git note",
+                                changes,
+                                if saved { "saved Git note" } else { "cleared Git note" },
+                            );
                         }
                         Ok(None) => {}
                         Err(err) => app.leave_error(format!("Git note: {err:#}")),
@@ -3115,6 +3556,78 @@ fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) -> bool {
     false
 }
 
+fn leave_recorded_success(
+    app: &mut App,
+    repository_path: &Path,
+    bare: bool,
+    title: &str,
+    changes: &[edit::undo::RefChange],
+    message: impl Into<String>,
+) {
+    let message = message.into();
+    match record_undo(repository_path, bare, title, changes) {
+        Ok(()) => app.leave_success(message),
+        Err(err) => app.leave_attention(format!("{message}; undo history: {err:#}")),
+    }
+}
+
+fn record_undo(repository_path: &Path, bare: bool, title: &str, changes: &[edit::undo::RefChange]) -> Result<()> {
+    open_repository(repository_path, bare, false)
+        .context("could not reopen repository for undo history")
+        .and_then(|repo| edit::undo::record(&repo, title, changes).map(|_| ()))
+}
+
+fn clear_undo_history(repository_path: &Path, bare: bool) -> Result<()> {
+    open_repository(repository_path, bare, false)
+        .context("could not reopen repository to clear undo history")
+        .and_then(|repo| edit::undo::clear(&repo))
+}
+
+fn record_and_clear_pending_undo(
+    repository_path: &Path,
+    bare: bool,
+    title: &str,
+    changes: &mut Vec<edit::undo::RefChange>,
+) -> Result<()> {
+    let result = record_undo(repository_path, bare, title, changes);
+    changes.clear();
+    result
+}
+
+fn tracked_ref_update<T>(
+    repo: &gix::Repository,
+    name: &str,
+    update: impl FnOnce(&gix::Repository) -> Result<T>,
+) -> Result<(T, Result<Vec<edit::undo::RefChange>>)> {
+    let name: gix::refs::FullName = name.try_into().context("tracked reference name is invalid")?;
+    let before = edit::undo::state(repo, name.as_ref());
+    let value = update(repo)?;
+    let changes = before.and_then(|before| {
+        edit::undo::state(repo, name.as_ref()).map(|after| {
+            (before != after)
+                .then_some(edit::undo::RefChange { name, before, after })
+                .into_iter()
+                .collect()
+        })
+    });
+    Ok((value, changes))
+}
+
+fn leave_tracked_success(
+    app: &mut App,
+    repository_path: &Path,
+    bare: bool,
+    title: &str,
+    changes: Result<Vec<edit::undo::RefChange>>,
+    message: impl Into<String>,
+) {
+    let message = message.into();
+    match changes {
+        Ok(changes) => leave_recorded_success(app, repository_path, bare, title, &changes, message),
+        Err(err) => app.leave_attention(format!("{message}; undo history: {err:#}")),
+    }
+}
+
 fn remembered_change_selection(view: &app::ChangesView, changes: Option<&Changes>) -> Option<(BString, usize)> {
     changes.and_then(|changes| {
         changes
@@ -3920,7 +4433,7 @@ fn edit_note(
     bare: bool,
     id: gix::ObjectId,
     enhanced_keyboard: bool,
-) -> Result<Option<enrich::Enrichment>> {
+) -> Result<Option<(enrich::Enrichment, Result<Vec<edit::undo::RefChange>>)>> {
     let (editor, enrichment, document) = {
         let repository =
             open_repository(repository_path, bare, false).context("could not open repository before editing note")?;
@@ -3945,7 +4458,18 @@ fn edit_note(
 
     let repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing note")?;
-    enrich::set_note(&repository, id, desired_note.map(AsRef::as_ref)).map(Some)
+    let name: gix::refs::FullName = enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let before = edit::undo::state(&repository, name.as_ref());
+    let enrichment = enrich::set_note(&repository, id, desired_note.map(AsRef::as_ref))?;
+    let changes = before.and_then(|before| {
+        edit::undo::state(&repository, name.as_ref()).map(|after| {
+            (before != after)
+                .then_some(edit::undo::RefChange { name, before, after })
+                .into_iter()
+                .collect()
+        })
+    });
+    Ok(Some((enrichment, changes)))
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -3955,7 +4479,7 @@ fn edit_git_note(
     bare: bool,
     id: gix::ObjectId,
     enhanced_keyboard: bool,
-) -> Result<Option<bool>> {
+) -> Result<Option<(bool, Result<Vec<edit::undo::RefChange>>)>> {
     let (editor, reference, document) = {
         let repository = open_repository(repository_path, bare, false)
             .context("could not open repository before editing Git note")?;
@@ -3988,21 +4512,23 @@ fn edit_git_note(
 
     let repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing Git note")?;
-    set_git_note(
+    let changes = set_git_note_reporting(
         &repository,
         reference.as_ref(),
         id,
         (!cleaned.is_empty()).then_some(cleaned.as_ref()),
     )?;
-    Ok(Some(!cleaned.is_empty()))
+    Ok(Some((!cleaned.is_empty(), changes)))
 }
 
-pub(crate) fn set_git_note(
+fn set_git_note_reporting(
     repository: &gix::Repository,
     reference: &gix::refs::FullNameRef,
     id: gix::ObjectId,
     data: Option<&[u8]>,
-) -> Result<()> {
+) -> Result<Result<Vec<edit::undo::RefChange>>> {
+    let name = reference.to_owned();
+    let before = edit::undo::state(repository, reference);
     let mut notes = repository.notes().map_err(gix::Exn::into_error)?;
     match data {
         Some(data) => {
@@ -4018,7 +4544,24 @@ pub(crate) fn set_git_note(
                 .context("could not remove Git note")?;
         }
     }
-    Ok(())
+    Ok(before.and_then(|before| {
+        edit::undo::state(repository, reference).map(|after| {
+            (before != after)
+                .then_some(edit::undo::RefChange { name, before, after })
+                .into_iter()
+                .collect()
+        })
+    }))
+}
+
+#[cfg(test)]
+pub(crate) fn set_git_note(
+    repository: &gix::Repository,
+    reference: &gix::refs::FullNameRef,
+    id: gix::ObjectId,
+    data: Option<&[u8]>,
+) -> Result<Vec<edit::undo::RefChange>> {
+    set_git_note_reporting(repository, reference, id, data)?
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -4438,7 +4981,7 @@ fn create_commit(
     parent: Option<gix::ObjectId>,
     mode: CreateMode,
     enhanced_keyboard: bool,
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<Option<edit::rebase::Outcome>> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before creating commit")?;
     repository.object_cache_size(None);
@@ -4463,11 +5006,13 @@ fn create_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    let id = match mode {
-        CreateMode::Insert | CreateMode::InsertEmpty => edit::create::apply(repository, graph, prepared, &edited),
-        CreateMode::Fork => edit::create::apply_fork(repository, graph, prepared, &edited),
+    let outcome = match mode {
+        CreateMode::Insert | CreateMode::InsertEmpty => {
+            edit::create::apply_reporting(repository, graph, prepared, &edited)
+        }
+        CreateMode::Fork => edit::create::apply_fork_reporting(repository, graph, prepared, &edited),
     }?;
-    Ok(Some(id))
+    Ok(Some(outcome))
 }
 
 #[tracing::instrument(skip_all)]
@@ -4477,7 +5022,7 @@ fn split_commit(
     bare: bool,
     graph: &HistoryGraph,
     enhanced_keyboard: bool,
-) -> Result<Option<gix::ObjectId>> {
+) -> Result<Option<edit::rebase::Outcome>> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before splitting HEAD")?;
     repository.object_cache_size(None);
@@ -4495,7 +5040,7 @@ fn split_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing split")?;
     repository.object_cache_size(None);
-    edit::split::apply(repository, graph, prepared, &edited).map(Some)
+    edit::split::apply_reporting(repository, graph, prepared, &edited).map(Some)
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -5305,9 +5850,14 @@ fn action_with_shortcut_groups(
         KeyCode::Char('b') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Rebase)
         }
-        KeyCode::Char('u') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
+        KeyCode::Char('U') => Some(Action::Redo),
+        KeyCode::Char('u') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Redo),
+        KeyCode::Char('u')
+            if actions_expanded && !key.modifiers.intersects(KeyModifiers::CONTROL | KeyModifiers::SHIFT) =>
+        {
             Some(Action::RebaseUpdate)
         }
+        KeyCode::Char('u') if !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Undo),
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
         KeyCode::Char('c') if actions_expanded => Some(Action::CopyInsert),
@@ -5456,6 +6006,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn pending_changes_are_recorded_before_they_are_cleared() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let id = repository.rev_parse_single("topic")?.detach();
+        let name: gix::refs::FullName = "refs/heads/cancelled-conflict".try_into()?;
+        let status = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["update-ref", name.as_bstr().to_str_lossy().as_ref(), &id.to_string()])
+            .status()?;
+        assert!(
+            status.success(),
+            "the cancelled operation has an applied reference change"
+        );
+        let mut changes = vec![edit::undo::RefChange {
+            name: name.clone(),
+            before: edit::undo::State::Missing,
+            after: edit::undo::State::Object(id),
+        }];
+
+        record_and_clear_pending_undo(fixture.path(), false, "materialize rebase conflict", &mut changes)?;
+        assert!(changes.is_empty(), "the cancellation releases its accumulator");
+
+        let repository = test_repository::open(fixture.path())?;
+        edit::undo::plan_undo(&repository)?
+            .expect("the cancelled operation was journalled")
+            .apply(&repository)?;
+        assert!(
+            repository.try_find_reference(name.as_ref())?.is_none(),
+            "the recorded cancellation remains undoable"
+        );
+        Ok(())
+    }
+
     #[test]
     fn retains_unseen_filesystem_redraws_until_focus_returns() {
         assert!(!unseen_filesystem_redraw(false, false, false));
@@ -6432,6 +7016,18 @@ mod tests {
             action(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL)),
             Some(Action::HalfPageUp)
         );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE)),
+            Some(Action::Undo)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::NONE)),
+            Some(Action::Redo)
+        );
+        assert_eq!(
+            action(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::SHIFT)),
+            Some(Action::Redo)
+        );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL)),
             Some(Action::HalfPageDown)
@@ -6850,11 +7446,14 @@ mod tests {
             assert!(action_allowed_during_rebase_continuation(Some(&action), false));
         }
         for action in [
+            Action::Undo,
+            Action::Redo,
             Action::Refresh,
             Action::ToggleHidden,
             Action::ToggleRefTree,
             Action::ToggleCommitGroup,
             Action::Amend,
+            Action::Spill,
             Action::Rebase,
             Action::TimeTravel,
             Action::VerifySignatures,
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 438d1b5932a..7b5accb68cf 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -805,11 +805,20 @@ fn pinnable_kind(kind: DecorationKind) -> Option<DecorationKind> {
     }
 }
 
+#[cfg(test)]
 pub(crate) fn pin_references(
     repository: &gix::Repository,
     id: ObjectId,
     kinds: &[DecorationKind],
 ) -> anyhow::Result<Vec<crate::history::Pin>> {
+    pin_references_reporting(repository, id, kinds).map(|(pins, _changes)| pins)
+}
+
+pub(crate) fn pin_references_reporting(
+    repository: &gix::Repository,
+    id: ObjectId,
+    kinds: &[DecorationKind],
+) -> anyhow::Result<(Vec<crate::history::Pin>, Vec<crate::edit::undo::RefChange>)> {
     let mut names = Vec::new();
     for reference in repository
         .references()
@@ -839,18 +848,27 @@ pub(crate) fn pin_references(
     }
     names.sort();
     names.dedup();
-    names
-        .into_iter()
-        .map(|name| {
-            crate::edit::time_travel::create_or_reuse_pin(
-                repository,
-                gix::refs::Target::Symbolic(name),
-                id,
-                "tix ref-tree",
-            )
-            .map(|(pin, _created)| pin)
-        })
-        .collect()
+    let mut pins = Vec::new();
+    let mut changes = Vec::new();
+    for name in names {
+        let (pin, created) = crate::edit::time_travel::create_or_reuse_pin(
+            repository,
+            gix::refs::Target::Symbolic(name),
+            id,
+            "tix ref-tree",
+        )?;
+        if created {
+            changes.push(crate::edit::undo::RefChange {
+                name: pin.name.clone(),
+                before: crate::edit::undo::State::Missing,
+                after: crate::edit::undo::State::Symbolic(
+                    pin.target.try_name().expect("a ref-tree pin is symbolic").to_owned(),
+                ),
+            });
+        }
+        pins.push(pin);
+    }
+    Ok((pins, changes))
 }
 
 impl Overview {
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 689e22ec925..8bbecd65ce8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1393,6 +1393,9 @@ pub(crate) fn draw_with_worktree(
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
     if let (Some(area), Some(notice)) = (notice_area, notice.as_ref()) {
         render_notice(frame, area, notice);
+        if let Some((applied, total, _)) = app.undo_position() {
+            render_undo_progress(frame, area, notice.kind, applied, total);
+        }
     }
     let prefix_popup_area = prefix_popup
         .filter(|_| prefix_popup_allowed)
@@ -1409,6 +1412,32 @@ pub(crate) fn draw_with_worktree(
     }
 }
 
+fn render_undo_progress(frame: &mut Frame<'_>, area: Rect, kind: NoticeKind, applied: usize, total: usize) {
+    let bright_width = if total == 0 {
+        0
+    } else {
+        (u128::from(area.width) * applied.min(total) as u128 / total as u128) as u16
+    };
+    let (bright, dim) = match kind {
+        NoticeKind::Success => (Color::LightGreen, Color::Green),
+        NoticeKind::Attention => (Color::LightYellow, Color::Yellow),
+        NoticeKind::Error => (Color::LightRed, Color::Red),
+    };
+    frame.buffer_mut().set_style(
+        Rect::new(area.x, area.y, bright_width, area.height),
+        Style::default().bg(bright),
+    );
+    frame.buffer_mut().set_style(
+        Rect::new(
+            area.x.saturating_add(bright_width),
+            area.y,
+            area.width.saturating_sub(bright_width),
+            area.height,
+        ),
+        Style::default().bg(dim),
+    );
+}
+
 fn history_position(app: &App) -> String {
     if let (State::Complete, Some(selected)) = (app.deferred_history_state.unwrap_or(app.state), app.selected)
         && let Some(count) = app.visual_count(selected)
@@ -2819,6 +2848,101 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn undo_progress_uses_the_message_line_without_shifting_the_body() -> Result<(), Box<dyn std::error::Error>> {
+        let mut app = App::new(4);
+        app.update(Action::ToggleInformation);
+        app.show_undo_position(1, 4, "reword commit");
+        let mut terminal = Terminal::new(TestBackend::new(80, 5))?;
+        let mut layout = None;
+
+        terminal.draw(|frame| {
+            layout = Some(super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                None,
+            ));
+        })?;
+
+        let layout = layout.as_ref().expect("drawing returns its layout");
+        assert_eq!(layout.history.x, 0, "undo progress does not shift history");
+        assert_eq!(layout.history.width, 80, "history retains the complete width");
+        let notice_y = (0..4)
+            .find(|y| rendered_line(&terminal, *y).contains("reword commit · 1 undo · 3 redo"))
+            .expect("the undo message is visible");
+        assert!(
+            rendered_line(&terminal, notice_y).contains("reword commit · 1 undo · 3 redo"),
+            "the message line names the current operation"
+        );
+        let buffer = terminal.backend().buffer();
+        assert_eq!(buffer[(2, notice_y)].bg, Color::LightGreen);
+        assert_eq!(buffer[(20, notice_y)].bg, Color::LightGreen);
+        assert_eq!(buffer[(21, notice_y)].bg, Color::Green);
+        assert_eq!(buffer[(77, notice_y)].bg, Color::Green);
+        assert_eq!(buffer[(78, notice_y)].bg, Color::Reset, "the notice margin stays clear");
+        assert!(
+            rendered_line(&terminal, 4).starts_with("0 commits"),
+            "the footer remains full-width"
+        );
+
+        app.update(Action::MoveDown);
+        terminal.draw(|frame| {
+            super::draw_with_worktree(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                None,
+                None,
+            );
+        })?;
+        assert_eq!(app.undo_position(), None, "ordinary movement dismisses undo progress");
+        Ok(())
+    }
+
+    #[test]
+    fn undo_progress_colors_all_notice_rows_and_handles_edges() -> Result<(), Box<dyn std::error::Error>> {
+        let mut terminal = Terminal::new(TestBackend::new(8, 2))?;
+        for (kind, applied, total, bright_width, bright, dim) in [
+            (NoticeKind::Success, 4, 4, 8, Color::LightGreen, Color::Green),
+            (NoticeKind::Success, 3, 4, 6, Color::LightGreen, Color::Green),
+            (NoticeKind::Success, 0, 4, 0, Color::LightGreen, Color::Green),
+            (NoticeKind::Success, 0, 0, 0, Color::LightGreen, Color::Green),
+            (NoticeKind::Attention, 3, 4, 6, Color::LightYellow, Color::Yellow),
+            (NoticeKind::Error, 3, 4, 6, Color::LightRed, Color::Red),
+        ] {
+            let notice = Notice {
+                kind,
+                text: "notice".into(),
+            };
+            terminal.draw(|frame| {
+                render_notice(frame, frame.area(), &notice);
+                render_undo_progress(frame, frame.area(), kind, applied, total);
+            })?;
+            let buffer = terminal.backend().buffer();
+            for y in 0..2 {
+                for x in 0..8 {
+                    assert_eq!(
+                        buffer[(x, y)].bg,
+                        if x < bright_width { bright } else { dim },
+                        "every row uses the same progress boundary"
+                    );
+                }
+            }
+            assert_eq!(buffer[(0, 0)].fg, Color::Black, "progress preserves notice text color");
+            assert!(
+                buffer[(0, 0)].modifier.contains(Modifier::BOLD),
+                "progress preserves notice emphasis"
+            );
+        }
+        Ok(())
+    }
+
     #[test]
     fn renders_todo_progress_with_operation_counts_and_times() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(80, 8))?;

From 8ccb47df3647997595c6cee419694d03097e0c0e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 20:03:36 +0200
Subject: [PATCH 246/282] fix: make Tix prefix menus switchable

Reserve top-level prefix keys across every submenu, move stash into actions, and underline stack-insert at its actual shortcut.
---
 gix-tix/spec.md    | 41 +++++++++++---------
 gix-tix/src/app.rs |  3 +-
 gix-tix/src/lib.rs | 94 ++++++++++++++++++++++++++++++++++------------
 gix-tix/src/ui.rs  | 39 ++++++++++---------
 4 files changed, 116 insertions(+), 61 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index cd8eb73df34..b0d2b0e924e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -52,7 +52,7 @@ without trading responsiveness for metadata that is not visible.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
-  worktree-safety rules as `c n`. By default a changed index wins and tracked
+  worktree-safety rules as `c w`. By default a changed index wins and tracked
   worktree changes are used only when the index is unchanged. `--index` uses
   only the index delta; `--worktree` applies only unstaged tracked-worktree
   changes to the `HEAD` tree and omits staged-only changes. `--worktree-untracked`
@@ -389,15 +389,16 @@ without trading responsiveness for metadata that is not visible.
 | `[` | Cycle viewport-local title alignment, full-column alignment, no alignment, and compressed history. |
 | `v` | Toggle the history-display key group. Pressing `v` again closes it. |
 | `v d` | Cycle author dates, committer dates, and no dates. |
-| `v e` | Toggle full actors/emails and titles. |
-| `v n` | Cycle all attribution, author only, and no names, skipping inert states. |
+| `v i` | Cycle commit IDs, change IDs, and no explicit IDs. |
+| `v s` | Toggle full actors/emails and titles. |
+| `v e` | Cycle all attribution, author only, and no names, skipping inert states. |
 | `v t` | Toggle attribution trailers. |
 | `v m` | Toggle mailmap resolution. |
 | `v r` | Cycle all, normal, and no reference labels. |
 | `v h` | Show or hide configured hidden ancestry. |
 | `r` | Hide reference labels or restore the mode visible when they were hidden. |
 | `m`/`]` | Toggle the commit-message view. |
-| `? c` | Cycle the tree/worktree changes display. |
+| `? e` | Cycle the tree/worktree changes display. |
 | `Shift-R` | Explicitly refresh the revision view and visible worktree status. |
 | `y` | Copy the selected commit ID, or the selected raw path when a changes block is focused. |
 | `Shift-y`/`Y` | Copy the selected author as `Name <email>`. |
@@ -521,7 +522,7 @@ The Enter key is written as `<enter>` throughout.
   attached history; returning through that pin consumes it. Nested trees use the
   nearest review-root ancestor.
 - When loaded worktree status shows staged, unstaged, or untracked changes without
-  conflicts, the edit menu offers `stas[h]` at the selected `@` entry. Missing or
+  conflicts, the actions menu offers `z stash` at the selected `@` entry. Missing or
   stale worktree status hides the action instead of performing another status
   query. Saving uses Git with `--include-untracked`, leaves ignored files alone,
   preserves the ordinary stash stack, and records the stash commit at
@@ -535,7 +536,7 @@ The Enter key is written as `<enter>` throughout.
   stashes retain their review-tree identity and namespace. An active automatic
   review stash likewise shows `🎁` on the review leaf whose worktree state it
   saved, without exposing its internal reference or stash commit to traversal.
-- At a selected `@` with a commit stash, the edit menu offers `unstas[h]` even
+- At a selected `@` with a commit stash, the actions menu offers `z unstash` even
   when other worktree changes are present. It applies and consumes the stash in
   place through the same path used when time travel returns to that commit.
 - Rewriting a commit atomically renames its commit-stash association alongside
@@ -671,7 +672,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### New commits
 
-- `c n` creates a child of the selected commit from tracked changes, or a root
+- `c w` creates a child of the selected commit from tracked changes, or a root
   commit for an unborn `HEAD`. A changed index wins; otherwise, tracked worktree
   changes are used. Untracked files never enter an implicit new commit and remain
   untracked. It is available only with a live worktree, after history completion,
@@ -707,7 +708,7 @@ space first; changes blocks adapt within the remaining history width.
 
 - `a f` creates an independent child of any selected commit, including a hidden
   boundary or merge commit. It requires completed history and a live,
-  conflict-free worktree, but unlike `c n` it is not restricted by descendants
+  conflict-free worktree, but unlike `c w` it is not restricted by descendants
   because it rewrites none of them. It is unavailable for unborn history.
 - Fork preparation reuses the new-commit editor, candidate-tree, identity,
   enrichment, and signing rules. Empty-delta children are allowed so historical
@@ -721,7 +722,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Amend, spill, and split
 
-- `c a` amends the current worktree's `@` commit with the changed index, or
+- `c e` amends the current worktree's `@` commit with the changed index, or
   worktree changes when the index already matches `HEAD`. `c s` spills that
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
@@ -743,7 +744,7 @@ space first; changes blocks adapt within the remaining history width.
   offers `spill` and `c s` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
 - With a path selected in the focused worktree-changes block, the main `c`
-  prefix offers `amend` and `c a` amends only that path. A staged row uses its
+  prefix offers `amend` and `c e` amends only that path. A staged row uses its
   index version; an unstaged row uses its filtered worktree version. If both
   rows exist for one path, the selected row determines the version. Review
   commits accept only staged rows, and unresolved indexes cannot be amended.
@@ -1043,13 +1044,14 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Commit and action shortcuts
 
-- `c` toggles the commit shortcut group. `c o` rewords, `c n` creates a rebased
-  child, `c a` amends `@`, `c h` stashes
-  changes at `@`, `c s` spills `@`, `c p` splits staged from unstaged changes,
-  and `c d d` confirms forgetting a top commit when each action is available.
+- `c` toggles the commit shortcut group. `c o` rewords, `c w` creates a rebased
+  child, `c m` creates an empty child, `c e` amends `@`, `c s` spills `@`, `c p`
+  splits staged from unstaged changes, and `c d d` confirms forgetting a top
+  commit when each action is available.
 - `a` toggles the actions shortcut group. `a b` rebases an eligible hidden base,
   `a u` rebases it onto the newer hidden branch tip when available, `a r` starts
-  or finishes a review, `a s` squashes the selected commit, `a c` copy-inserts
+  or finishes a review, `a s` squashes the selected commit, `a z` stashes or
+  restores changes at `@`, `a y` copy-inserts
   current `HEAD` above the selected commit, `a m` move-inserts it, `a t` starts
   stack-insert for the linear ancestry from the selected commit through `HEAD`,
   `a f` creates and travels to a standalone child of the selected commit, and
@@ -1089,12 +1091,15 @@ space first; changes blocks adapt within the remaining history width.
 - The footer underlines `c` in `commit` and `a` in `actions`; an expanded group
   contains only the operations available for the current selection. An empty
   group says `no actions`.
-- While the `v` group is open, `d`, `e`, `r`, and `t` retain their display
-  meanings for dates, emails, references, and trailers.
+- The top-level `v`, `c`, `a`, `n`, and `?` keys are reserved for their groups.
+  Pressing one while another group is open switches directly to that group;
+  `? e` cycles the changes panes.
+- While the `v` group is open, `d`, `i`, `s`, `e`, `m`, `t`, `r`, and `h` control
+  dates, IDs, emails, names, mailmap, trailers, references, and hidden commits.
 - The `n` in `enrich` toggles its shortcut group. On any commit eligible for rewording,
   `n t` toggles `[commit] todo`, preserving a saved note, and `n o` opens
   `[commit] note` in Git's editor as Markdown. Saving or removing a note preserves
-  the todo flag, and toggling todo preserves the note. `n c` toggles
+  the todo flag, and toggling todo preserves the note. `n e` toggles
   `[tree] checks-pass` for any selected commit, including immutable boundaries.
   `n g` edits the real Git note and remains available when the commit-specific
   Tix actions are not. The group is mutually
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index d5b0e6e8804..3c05d3c6efe 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -1371,7 +1371,6 @@ impl App {
                 | Action::NewCommit
                 | Action::NewEmptyCommit
                 | Action::Amend
-                | Action::Stash
                 | Action::Spill
                 | Action::Split
                 | Action::Forget
@@ -1389,6 +1388,7 @@ impl App {
                 | Action::CopyInsert
                 | Action::MoveInsert
                 | Action::StackInsert
+                | Action::Stash
                 | Action::Review
                 | Action::ForkCommit
                 | Action::Attach
@@ -5820,6 +5820,7 @@ mod tests {
         app.update(Action::CopyInsert);
         app.update(Action::MoveInsert);
         app.update(Action::StackInsert);
+        app.update(Action::Stash);
         app.update(Action::ForkCommit);
         app.update(Action::Attach);
         assert!(app.actions_expanded, "grouped actions keep the group open");
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 42403bc1442..a2e66d5c225 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1742,7 +1742,7 @@ fn event_loop(
                     app.commit_expanded,
                     app.actions_expanded,
                     app.enrich_expanded,
-                    app.information_expanded,
+                    app.information_expanded || app.changes_focus.is_some(),
                 );
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
@@ -5845,7 +5845,12 @@ fn action_with_shortcut_groups(
         KeyCode::Tab => Some(Action::ToggleChangesFocus),
         KeyCode::Enter => Some(Action::OpenDiff),
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
-        KeyCode::Char('c') if information_expanded => Some(Action::ToggleChanges),
+        KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
+        KeyCode::Char('c') => Some(Action::ToggleCommitGroup),
+        KeyCode::Char('a') => Some(Action::ToggleActions),
+        KeyCode::Char('n') => Some(Action::ToggleEnrich),
+        KeyCode::Char('?') => Some(Action::ToggleInformation),
+        KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
         KeyCode::Char('p') if commit_expanded => Some(Action::Split),
         KeyCode::Char('b') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Rebase)
@@ -5860,20 +5865,20 @@ fn action_with_shortcut_groups(
         KeyCode::Char('u') if !key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::Undo),
         KeyCode::Char('r') if actions_expanded => Some(Action::Review),
         KeyCode::Char('s') if actions_expanded => Some(Action::Squash),
-        KeyCode::Char('c') if actions_expanded => Some(Action::CopyInsert),
+        KeyCode::Char('y') if actions_expanded => Some(Action::CopyInsert),
         KeyCode::Char('m') if actions_expanded => Some(Action::MoveInsert),
         KeyCode::Char('t') if actions_expanded => Some(Action::StackInsert),
         KeyCode::Char('f') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::ForkCommit)
         }
         KeyCode::Char('h') if actions_expanded => Some(Action::Attach),
+        KeyCode::Char('z') if actions_expanded => Some(Action::Stash),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
         KeyCode::Up | KeyCode::Char('k') => Some(Action::MoveUp),
         KeyCode::Down | KeyCode::Char('j') => Some(Action::MoveDown),
         KeyCode::Char('x') => Some(Action::CycleDuplicate),
-        KeyCode::Char('h') if commit_expanded => Some(Action::Stash),
         KeyCode::Char('h') if history_display_expanded => Some(Action::ToggleHidden),
         KeyCode::Char('h') => Some(Action::ScrollLeft),
         KeyCode::Char('l') => Some(Action::ScrollRight),
@@ -5889,35 +5894,30 @@ fn action_with_shortcut_groups(
         KeyCode::End | KeyCode::Char('G') => Some(Action::Last),
         KeyCode::Char('d') if history_display_expanded => Some(Action::ToggleDate),
         KeyCode::Char('i') if history_display_expanded => Some(Action::CycleIds),
-        KeyCode::Char('e') if history_display_expanded => Some(Action::ToggleEmail),
-        KeyCode::Char('n') if history_display_expanded => Some(Action::ToggleName),
+        KeyCode::Char('s') if history_display_expanded => Some(Action::ToggleEmail),
+        KeyCode::Char('e') if history_display_expanded => Some(Action::ToggleName),
         KeyCode::Char('t') if history_display_expanded => Some(Action::ToggleTrailers),
         KeyCode::Char('m') if history_display_expanded => Some(Action::ToggleMailmap),
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
         KeyCode::Char('o') if commit_expanded => Some(Action::Reword),
-        KeyCode::Char('n') if commit_expanded => Some(Action::NewCommit),
+        KeyCode::Char('w') if commit_expanded => Some(Action::NewCommit),
         KeyCode::Char('m') if commit_expanded => Some(Action::NewEmptyCommit),
-        KeyCode::Char('a') if commit_expanded => Some(Action::Amend),
+        KeyCode::Char('e') if commit_expanded => Some(Action::Amend),
         KeyCode::Char('s') if commit_expanded => Some(Action::Spill),
         KeyCode::Char('d') if commit_expanded => Some(Action::Forget),
         KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),
-        KeyCode::Char('c') if enrich_expanded => Some(Action::ToggleChecksPass),
+        KeyCode::Char('e') if enrich_expanded => Some(Action::ToggleChecksPass),
         KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
+        KeyCode::Char('e') if information_expanded => Some(Action::ToggleChanges),
         KeyCode::Char('@') => Some(Action::TimeTravel),
         KeyCode::Char('2') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::TimeTravel),
         KeyCode::Char('m') => Some(Action::ToggleCommit),
         KeyCode::Char('r') => Some(Action::ToggleRefs),
         KeyCode::Char('s') => Some(Action::VerifySignatures),
         KeyCode::Char('t') => Some(Action::ToggleRefTree),
-        KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
-        KeyCode::Char('c') => Some(Action::ToggleCommitGroup),
-        KeyCode::Char('a') => Some(Action::ToggleActions),
-        KeyCode::Char('n') => Some(Action::ToggleEnrich),
-        KeyCode::Char('?') => Some(Action::ToggleInformation),
-        KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
         KeyCode::Char('[') => Some(Action::ToggleAlign),
         KeyCode::Char(']') => Some(Action::ToggleCommit),
         KeyCode::Char('Y') => Some(Action::CopyAuthor),
@@ -7061,7 +7061,7 @@ mod tests {
         );
         assert_eq!(
             action_with_shortcut_groups(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+                KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
                 false,
                 false,
                 false,
@@ -7175,8 +7175,8 @@ mod tests {
         for (key, expected) in [
             ('d', Action::ToggleDate),
             ('i', Action::CycleIds),
-            ('e', Action::ToggleEmail),
-            ('n', Action::ToggleName),
+            ('s', Action::ToggleEmail),
+            ('e', Action::ToggleName),
             ('t', Action::ToggleTrailers),
             ('m', Action::ToggleMailmap),
             ('r', Action::CycleRefs),
@@ -7195,6 +7195,34 @@ mod tests {
                 "{key} is available after the view prefix"
             );
         }
+        for (history, commit, actions, enrich, information) in [
+            (true, false, false, false, false),
+            (false, true, false, false, false),
+            (false, false, true, false, false),
+            (false, false, false, true, false),
+            (false, false, false, false, true),
+        ] {
+            for (key, expected) in [
+                ('v', Action::ToggleHistoryDisplay),
+                ('c', Action::ToggleCommitGroup),
+                ('a', Action::ToggleActions),
+                ('n', Action::ToggleEnrich),
+                ('?', Action::ToggleInformation),
+            ] {
+                assert_eq!(
+                    action_with_shortcut_groups(
+                        KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
+                        history,
+                        commit,
+                        actions,
+                        enrich,
+                        information,
+                    ),
+                    Some(expected),
+                    "{key} switches prefix menus regardless of the active menu"
+                );
+            }
+        }
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('v'), KeyModifiers::NONE),
@@ -7209,10 +7237,9 @@ mod tests {
         );
         for (key, expected) in [
             ('o', Action::Reword),
-            ('n', Action::NewCommit),
+            ('w', Action::NewCommit),
             ('m', Action::NewEmptyCommit),
-            ('a', Action::Amend),
-            ('h', Action::Stash),
+            ('e', Action::Amend),
             ('s', Action::Spill),
             ('p', Action::Split),
             ('d', Action::Forget),
@@ -7236,11 +7263,12 @@ mod tests {
             ('u', Action::RebaseUpdate),
             ('r', Action::Review),
             ('s', Action::Squash),
-            ('c', Action::CopyInsert),
+            ('y', Action::CopyInsert),
             ('m', Action::MoveInsert),
             ('t', Action::StackInsert),
             ('f', Action::ForkCommit),
             ('h', Action::Attach),
+            ('z', Action::Stash),
         ] {
             assert_eq!(
                 action_with_shortcut_groups(
@@ -7255,6 +7283,24 @@ mod tests {
                 "{key} is available after the actions prefix"
             );
         }
+        for (history, commit, enrich, expected) in [
+            (true, false, false, Action::ToggleName),
+            (false, true, false, Action::Amend),
+            (false, false, true, Action::ToggleChecksPass),
+        ] {
+            assert_eq!(
+                action_with_shortcut_groups(
+                    KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
+                    history,
+                    commit,
+                    false,
+                    enrich,
+                    true,
+                ),
+                Some(expected),
+                "an open submenu takes priority over the focused changes shortcut"
+            );
+        }
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
@@ -7339,7 +7385,7 @@ mod tests {
         );
         assert_eq!(
             action_with_shortcut_groups(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
+                KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
                 false,
                 false,
                 false,
@@ -7347,7 +7393,7 @@ mod tests {
                 true
             ),
             Some(Action::ToggleChanges),
-            "changes is scoped to the information prefix"
+            "e changes is scoped to the information prefix"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('Y'), KeyModifiers::SHIFT)),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 8bbecd65ce8..7a643f2e3d7 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1025,7 +1025,7 @@ pub(crate) fn draw_with_worktree(
                 None => None,
             } {
                 spans.push(Span::raw(" · "));
-                spans.extend(shortcut(label, 'c', true));
+                spans.extend(shortcut(label, 'e', true));
             }
             frame.render_widget(
                 Paragraph::new(Line::from(spans)).style(Style::default().bg(PANE_STATUS_BACKGROUND)),
@@ -1096,18 +1096,13 @@ pub(crate) fn draw_with_worktree(
                 options.push(("reword", 'o'));
             }
             if app.changes_focus.is_none() && app.can_create_commit() {
-                options.push(("new", 'n'));
+                options.push(("new", 'w'));
             }
             if app.changes_focus.is_none() && app.can_create_empty_commit() {
                 options.push(("new-empty", 'm'));
             }
             if app.can_amend() {
-                options.push(("amend", 'a'));
-            }
-            if app.can_stash() {
-                options.push(("stash", 'h'));
-            } else if app.can_unstash() {
-                options.push(("unstash", 'h'));
+                options.push(("amend", 'e'));
             }
             if app.can_spill() {
                 options.push(("spill", 's'));
@@ -1154,6 +1149,11 @@ pub(crate) fn draw_with_worktree(
         actions_prefix_spans.push(Span::raw("ctions"));
         if app.actions_expanded {
             let mut options = Vec::new();
+            if app.can_stash() {
+                options.push(("z stash", 'z'));
+            } else if app.can_unstash() {
+                options.push(("z unstash", 'z'));
+            }
             if app.can_rebase() {
                 options.push(("rebase", 'b'));
             }
@@ -1169,7 +1169,7 @@ pub(crate) fn draw_with_worktree(
                 options.push(("squash", 's'));
             }
             if app.can_copy_insert() {
-                options.push(("copy-insert", 'c'));
+                options.push(("copy-insert", 'y'));
             }
             if app.can_move_insert() {
                 options.push(("move-insert", 'm'));
@@ -1185,8 +1185,8 @@ pub(crate) fn draw_with_worktree(
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
+                items.push(Span::raw("stack-inser"));
                 items.push(Span::styled("t", Style::default().add_modifier(Modifier::UNDERLINED)));
-                items.push(Span::raw(" stack-insert"));
             }
             if app.can_fork_commit() {
                 if !items.is_empty() {
@@ -1233,14 +1233,14 @@ pub(crate) fn draw_with_worktree(
         };
         items.extend(shortcut(id_label, 'i', ids_visible));
         items.push(Span::raw(" · "));
-        items.extend(shortcut("emails", 'e', app.show_emails));
+        items.extend(shortcut("emails", 's', app.show_emails));
         let (name_label, names_visible) = match app.name_mode {
             NameMode::All => ("names", true),
             NameMode::Author => ("name", true),
             NameMode::None => ("name", false),
         };
         items.push(Span::raw(" · "));
-        items.extend(shortcut(name_label, 'n', names_visible));
+        items.extend(shortcut(name_label, 'e', names_visible));
         for (label, key, enabled) in [("mailmap", 'm', app.use_mailmap), ("trailers", 't', app.show_trailers)] {
             items.push(Span::raw(" · "));
             items.extend(shortcut(label, key, enabled));
@@ -1297,7 +1297,7 @@ pub(crate) fn draw_with_worktree(
                     items.extend(shortcut("note", 'o', app.note(row.id).is_some()));
                     items.push(Span::raw(" · "));
                 }
-                items.extend(shortcut("checks-pass", 'c', app.checks_pass(row.id)));
+                items.extend(shortcut("checks-pass", 'e', app.checks_pass(row.id)));
                 items.push(Span::raw(" · "));
                 items.extend(shortcut("git note", 'g', !app.notes(row.id).is_empty()));
             } else {
@@ -1355,7 +1355,7 @@ pub(crate) fn draw_with_worktree(
             items.push(Span::raw(" · "));
             items.extend(shortcut("message", 'm', app.show_commit));
             items.push(Span::raw(" · "));
-            items.extend(shortcut("changes", 'c', app.changes_mode.is_some()));
+            items.extend(shortcut("changes", 'e', app.changes_mode.is_some()));
             if app.tree_changes_visible || app.worktree_changes_visible {
                 items.push(Span::raw(" · "));
                 items.push(match focus_feedback {
@@ -4265,20 +4265,21 @@ mod tests {
         assert!(popup.contains("fork"));
         assert!(popup.contains("attach"));
         assert!(!popup.contains("cherry-"));
-        let label = "t stack-insert";
+        let label = "stack-insert";
         let start = popup[..popup.find(label).expect("the stack-insert action is visible")]
             .chars()
             .count() as u16;
+        let shortcut = start + label.len() as u16 - 1;
         assert!(
-            terminal.backend().buffer()[(start, 3)]
+            terminal.backend().buffer()[(shortcut, 3)]
                 .modifier
                 .contains(Modifier::UNDERLINED)
         );
         assert!(
-            (start + 1..start + label.len() as u16).all(|x| !terminal.backend().buffer()[(x, 3)]
+            (start..shortcut).all(|x| !terminal.backend().buffer()[(x, 3)]
                 .modifier
                 .contains(Modifier::UNDERLINED)),
-            "only the prefixed t is underlined"
+            "only the t in insert is underlined"
         );
         Ok(())
     }
@@ -4374,6 +4375,7 @@ mod tests {
         assert!(!popup.contains("spill"), "worktree paths cannot be spilled");
 
         app.changes_focus = None;
+        app.update(Action::ToggleActions);
         terminal.draw(|frame| {
             super::draw_with_worktree(
                 frame,
@@ -4416,6 +4418,7 @@ mod tests {
             .expect("HEAD has decorations")
             .retain(|decoration| decoration.kind != DecorationKind::Stash);
         app.changes_focus = Some(ChangePane::Worktree);
+        app.update(Action::ToggleCommitGroup);
 
         std::sync::Arc::make_mut(&mut app.rows[0]).is_review = true;
         terminal.draw(|frame| {

From a0357d914bef746353d30e6845e49855a3f9101e Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 20:44:41 +0200
Subject: [PATCH 247/282] fix: preserve reword edits across concurrent amends

Reload the active view after an editor returns and relocate the target by its full change ID. This preserves concurrent tree amendments while failing safely if the identity disappeared or became ambiguous.
---
 gix-tix/src/command/reword.rs |  33 ++++--
 gix-tix/src/edit/mod.rs       |  22 +++-
 gix-tix/src/edit/reword.rs    | 190 ++++++++++++++++++++++++++++++++++
 gix-tix/src/lib.rs            |  56 ++++++----
 4 files changed, 265 insertions(+), 36 deletions(-)

diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index 2efacd17535..bb11e8b10e4 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -45,10 +45,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
         Some(graph) => graph,
         None => crate::edit::loaded_view_graph_with(&repository, &revisions)?,
     };
-    let covering_pin = pins.iter().any(|pin| graph.is_ancestor(target, pin.id));
-    if !attached_head && !covering_pin {
-        anyhow::bail!("the reword target or one of its descendants must be pinned");
-    }
+    ensure_retained_target(&graph, target, &pins, attached_head)?;
 
     let author = args
         .edit
@@ -74,6 +71,7 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
 
     let repository_path = repository.git_dir().to_owned();
     let bare = repository.is_bare();
+    let change_id = crate::change_id::for_commit(&repository, target)?;
     let (editor, document) = crate::edit::reword::document_with_author(&repository, target, author.map(AsRef::as_ref))?;
     drop(repository);
     let edited = crate::edit::edit_document_without_terminal(
@@ -93,14 +91,31 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
+    let (graph, target) = crate::edit::reword::relocate_after_editor(&repository, &[], &[], change_id)?;
+    let pins = crate::history::all_pins(&repository)?;
+    let head = repository.head().context("could not read HEAD after editing commit")?;
+    let attached_head = !head.is_detached() && head.id().map(gix::Id::detach) == Some(target);
+    drop(head);
+    ensure_retained_target(&graph, target, &pins, attached_head)?;
     let output_repository = repository.clone();
     finish_editor(
         &output_repository,
         crate::edit::reword::apply(repository, &graph, target, &edited)?,
-        target,
     )
 }
 
+fn ensure_retained_target(
+    graph: &crate::history::HistoryGraph,
+    target: gix::ObjectId,
+    pins: &[crate::history::Pin],
+    attached_head: bool,
+) -> Result<()> {
+    if !attached_head && !pins.iter().any(|pin| graph.is_ancestor(target, pin.id)) {
+        anyhow::bail!("the reword target or one of its descendants must be pinned");
+    }
+    Ok(())
+}
+
 pub(super) fn explicit_message(args: &MessageArgs, mut stdin: impl Read) -> Result<Option<Vec<u8>>> {
     if !args.message.is_empty() {
         let mut out = Vec::new();
@@ -141,11 +156,7 @@ fn finish(repository: &gix::Repository, outcome: crate::edit::reword::Outcome) -
     Ok(())
 }
 
-fn finish_editor(
-    repository: &gix::Repository,
-    outcome: crate::edit::reword::Outcome,
-    original: gix::ObjectId,
-) -> Result<()> {
+fn finish_editor(repository: &gix::Repository, outcome: crate::edit::reword::Outcome) -> Result<()> {
     let title = if outcome.commit.is_some() {
         "reword commit"
     } else {
@@ -153,7 +164,7 @@ fn finish_editor(
     };
     match (outcome.commit, outcome.enrichment) {
         (Some(id), _) => println!("{}", crate::change_id::display(repository, id, 7)?),
-        (None, Some(_)) => println!("{}", crate::change_id::display(repository, original, 7)?),
+        (None, Some(_)) => println!("{}", crate::change_id::display(repository, outcome.target, 7)?),
         (None, None) => println!("no reword performed: the edited commit was unchanged"),
     }
     super::print_ref_rewrites(repository, &outcome.ref_rewrites)?;
diff --git a/gix-tix/src/edit/mod.rs b/gix-tix/src/edit/mod.rs
index 14e8b814030..1bcebe2a102 100644
--- a/gix-tix/src/edit/mod.rs
+++ b/gix-tix/src/edit/mod.rs
@@ -37,21 +37,33 @@ pub(super) fn loaded_graph(repo: &gix::Repository) -> Result<crate::history::His
     if repo.head().is_ok_and(|head| head.referent_name().is_none()) {
         revisions.push("HEAD".into());
     }
-    load_graph(repo, &revisions)
+    load_graph(repo, &revisions, &[])
 }
 
 pub(super) fn loaded_view_graph(repo: &gix::Repository) -> Result<crate::history::HistoryGraph> {
-    load_graph(repo, &[])
+    load_graph(repo, &[], &[])
 }
 
 pub(super) fn loaded_view_graph_with(
     repo: &gix::Repository,
     revisions: &[std::ffi::OsString],
 ) -> Result<crate::history::HistoryGraph> {
-    load_graph(repo, revisions)
+    load_graph(repo, revisions, &[])
 }
 
-fn load_graph(repo: &gix::Repository, revisions: &[std::ffi::OsString]) -> Result<crate::history::HistoryGraph> {
+pub(super) fn loaded_view_graph_with_hidden(
+    repo: &gix::Repository,
+    revisions: &[std::ffi::OsString],
+    hidden_revisions: &[std::ffi::OsString],
+) -> Result<crate::history::HistoryGraph> {
+    load_graph(repo, revisions, hidden_revisions)
+}
+
+fn load_graph(
+    repo: &gix::Repository,
+    revisions: &[std::ffi::OsString],
+    hidden_revisions: &[std::ffi::OsString],
+) -> Result<crate::history::HistoryGraph> {
     use std::sync::atomic::AtomicBool;
 
     let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
@@ -61,7 +73,7 @@ fn load_graph(repo: &gix::Repository, revisions: &[std::ffi::OsString]) -> Resul
     crate::history::load(
         repo,
         revisions,
-        &[],
+        hidden_revisions,
         false,
         &authors,
         &AtomicBool::new(false),
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index ecfc683287d..6af8c71be1a 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -24,12 +24,40 @@ pub(super) struct Edit<'a> {
 }
 
 pub(crate) struct Outcome {
+    pub target: gix::ObjectId,
     pub commit: Option<gix::ObjectId>,
     pub enrichment: Option<crate::enrich::Enrichment>,
     pub ref_rewrites: Vec<rebase::RefRewrite>,
     pub ref_changes: Vec<super::undo::RefChange>,
 }
 
+pub(crate) fn relocate_after_editor(
+    repo: &gix::Repository,
+    revisions: &[std::ffi::OsString],
+    hidden_revisions: &[std::ffi::OsString],
+    change_id: gix::hash::ChangeId,
+) -> Result<(crate::history::HistoryGraph, gix::ObjectId)> {
+    let graph = super::loaded_view_graph_with_hidden(repo, revisions, hidden_revisions)?;
+    let mut matches = Vec::new();
+    for id in graph.stored_commit_ids() {
+        if crate::change_id::for_commit(repo, id)? == change_id {
+            matches.push(id);
+        }
+    }
+    match matches.as_slice() {
+        [target] => Ok((graph, *target)),
+        [] => anyhow::bail!("change ID {change_id} is no longer present in the Tix view"),
+        candidates => {
+            let candidates = candidates
+                .iter()
+                .map(|id| crate::change_id::display_short(repo, *id))
+                .collect::<Result<Vec<_>>>()?
+                .join("\n  ");
+            anyhow::bail!("change ID {change_id} is ambiguous in the Tix view; candidates:\n  {candidates}")
+        }
+    }
+}
+
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn document(repo: &gix::Repository, id: gix::ObjectId) -> Result<(std::ffi::OsString, Vec<u8>)> {
     document_with_author(repo, id, None)
@@ -144,6 +172,7 @@ pub(crate) fn apply(
         });
     }
     Ok(Outcome {
+        target: old_id,
         commit,
         enrichment,
         ref_rewrites,
@@ -175,6 +204,7 @@ pub(crate) fn apply_message_reporting(
         .transpose()?;
     if commit.message == message && changed_author.as_ref().is_none_or(|author| *author == commit.author) {
         return Ok(Outcome {
+            target: old_id,
             commit: None,
             enrichment: None,
             ref_rewrites: Vec::new(),
@@ -187,6 +217,7 @@ pub(crate) fn apply_message_reporting(
     commit.message = message;
     let outcome = apply_commit(&repo, graph, old_id, commit)?;
     Ok(Outcome {
+        target: old_id,
         commit: outcome.selected.filter(|new_id| *new_id != old_id),
         enrichment: None,
         ref_rewrites: outcome.ref_rewrites,
@@ -514,6 +545,7 @@ mod tests {
         let edited = document.replacen(b"Message: Existing title", b"Message: New title", 1);
         let graph = super::super::loaded_graph(&repository)?;
         let outcome = apply(repository.clone(), &graph, id, &edited)?;
+        assert_eq!(outcome.target, id, "the outcome identifies the edited commit");
         assert!(
             outcome.commit.is_none(),
             "enrichment changes leave the commit object untouched"
@@ -528,6 +560,164 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn relocates_an_editor_reword_onto_a_concurrent_amend() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open_with(
+            path,
+            [
+                "committer.name=Current Committer",
+                "committer.email=current@example.com",
+            ],
+        )?;
+        let original = repository.head_id()?.detach();
+        let change_id = crate::change_id::for_commit(&repository, original)?;
+        let (_, document) = document(&repository, original)?;
+        let edited = document.replacen(b"\ntip\n", b"\nreworded tip\n", 1);
+
+        let mut outside = repository.find_commit(original)?.decode()?.into_owned()?;
+        outside.parents = [original].into_iter().collect();
+        outside.message = "outside the view".into();
+        crate::change_id::inherit(&repository, &mut outside, original)?;
+        let outside = repository.write_object(&outside)?.detach();
+        repository.reference(
+            "refs/heads/outside",
+            outside,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test outside-view successor",
+        )?;
+
+        std::fs::write(path.join("concurrent"), b"amended while editing\n")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(path)
+                .args(["add", "concurrent"])
+                .status()?
+                .success(),
+            "the concurrent tree change is staged"
+        );
+        let graph = super::super::loaded_view_graph(&repository)?;
+        let amended =
+            crate::edit::head::amend_index(repository.clone(), &graph)?.expect("the staged tree changes amend HEAD");
+        let amended_commit = repository.find_commit(amended)?.decode()?.into_owned()?;
+        assert_eq!(
+            crate::change_id::for_commit(&repository, amended)?,
+            change_id,
+            "the concurrent amend preserves the stable identity"
+        );
+
+        let (graph, target) = relocate_after_editor(&repository, &[], &[], change_id)?;
+        assert_eq!(target, amended, "the fresh view resolves the amended successor");
+        let outcome = apply(repository.clone(), &graph, target, &edited)?;
+        assert_eq!(outcome.target, amended, "the outcome reports the relocated target");
+        let rewritten = outcome.commit.expect("the edited message rewrites the amended commit");
+        let rewritten_commit = repository.find_commit(rewritten)?.decode()?.into_owned()?;
+        assert_eq!(repository.head_id()?.detach(), rewritten, "HEAD follows the reword");
+        assert_eq!(
+            rewritten_commit.tree, amended_commit.tree,
+            "the reword retains the concurrently amended tree"
+        );
+        assert_eq!(
+            rewritten_commit.parents, amended_commit.parents,
+            "the reword retains the current topology"
+        );
+        assert_eq!(rewritten_commit.message, b"reworded tip\n".as_bstr());
+        assert_eq!(
+            repository.find_reference("refs/heads/outside")?.id().detach(),
+            outside,
+            "a duplicate identity outside the active view is neither selected nor rewritten"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn editor_relocation_requires_one_visible_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open(path)?;
+        let head = repository.head_id()?.detach();
+        let index_before = std::fs::read(repository.index_path())?;
+        let worktree_before = std::fs::read(path.join("tip"))?;
+
+        let missing = gix::hash::ChangeId::from(gix::ObjectId::Sha1([42; 20]));
+        let err = relocate_after_editor(&repository, &[], &[], missing)
+            .expect_err("an identity outside the current view cannot be edited");
+        assert!(
+            format!("{err:#}").contains("no longer present"),
+            "the missing identity is explained: {err:#}"
+        );
+
+        let change_id = crate::change_id::for_commit(&repository, head)?;
+        let mut colliding_change_id = change_id.to_reverse_hex().to_string().into_bytes();
+        let last = colliding_change_id.last_mut().expect("a change ID is not empty");
+        *last = if *last == b'k' { b'l' } else { b'k' };
+        let colliding_change_id = gix::hash::ChangeId::from_reverse_hex(&colliding_change_id)?;
+        let mut prefix_collision = repository.find_commit(head)?.decode()?.into_owned()?;
+        prefix_collision.message = "prefix collision".into();
+        prefix_collision
+            .extra_headers
+            .retain(|(name, _)| name.as_slice() != crate::change_id::HEADER.as_bytes());
+        prefix_collision
+            .extra_headers
+            .push((crate::change_id::HEADER.into(), colliding_change_id.to_string().into()));
+        let prefix_collision = repository.write_object(&prefix_collision)?.detach();
+        let prefix_pin = "refs/worktree/tix/pins/prefix-collision";
+        repository.reference(
+            prefix_pin,
+            prefix_collision,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test change ID prefix collision",
+        )?;
+        let (_, resolved) = relocate_after_editor(&repository, &[], &[], change_id)?;
+        assert_eq!(
+            resolved, head,
+            "a later prefix collision cannot make the captured full identity ambiguous"
+        );
+
+        let mut duplicate = repository.find_commit(head)?.decode()?.into_owned()?;
+        duplicate.message = "duplicate identity".into();
+        crate::change_id::inherit(&repository, &mut duplicate, head)?;
+        let duplicate = repository.write_object(&duplicate)?.detach();
+        let pin = "refs/worktree/tix/pins/duplicate";
+        repository.reference(
+            pin,
+            duplicate,
+            gix::refs::transaction::PreviousValue::MustNotExist,
+            "test duplicate identity",
+        )?;
+
+        let err = relocate_after_editor(&repository, &[], &[], change_id)
+            .expect_err("two visible commits with the same identity are ambiguous");
+        let message = format!("{err:#}");
+        assert!(message.contains("ambiguous"), "ambiguity is explicit: {message}");
+        for candidate in [head, duplicate] {
+            assert!(
+                message.contains(&candidate.to_hex_with_len(7).to_string()),
+                "the error lists candidate {candidate}: {message}"
+            );
+        }
+        assert_eq!(
+            repository.head_id()?.detach(),
+            head,
+            "failed relocation leaves HEAD alone"
+        );
+        assert_eq!(
+            repository.find_reference(pin)?.id().detach(),
+            duplicate,
+            "failed relocation leaves pins alone"
+        );
+        assert_eq!(
+            repository.find_reference(prefix_pin)?.id().detach(),
+            prefix_collision,
+            "failed relocation leaves prefix-collision pins alone"
+        );
+        assert_eq!(std::fs::read(repository.index_path())?, index_before);
+        assert_eq!(std::fs::read(path.join("tip"))?, worktree_before);
+        Ok(())
+    }
+
     #[test]
     fn offers_only_missing_agent_trailer_keys() {
         assert_eq!(
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a2e66d5c225..11de5718410 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2314,21 +2314,19 @@ fn event_loop(
                     }
                 }
                 Effect::Reword(id) => {
-                    let result = history_graph
-                        .as_ref()
-                        .context("reword requires a completed history graph")
-                        .and_then(|graph| {
-                            reword_commit(
-                                terminal,
-                                &repository_path,
-                                repository_is_bare,
-                                graph,
-                                id,
-                                enhanced_keyboard,
-                            )
-                        });
+                    let hidden = if app.show_hidden { &[][..] } else { hide.as_slice() };
+                    let result = reword_commit(
+                        terminal,
+                        &repository_path,
+                        repository_is_bare,
+                        &revisions,
+                        hidden,
+                        id,
+                        enhanced_keyboard,
+                    );
                     match result {
                         Ok(Some(edit::reword::Outcome {
+                            target,
                             commit: Some(new_id),
                             ref_changes,
                             ..
@@ -2339,18 +2337,23 @@ fn event_loop(
                                 repository_is_bare,
                                 "reword commit",
                                 &ref_changes,
-                                format!("reworded {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7)),
+                                format!(
+                                    "reworded {} as {}",
+                                    target.to_hex_with_len(7),
+                                    new_id.to_hex_with_len(7)
+                                ),
                             );
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
                         Ok(Some(edit::reword::Outcome {
+                            target,
                             enrichment: Some(enrichment),
                             ref_changes,
                             ..
                         })) => {
                             app.clear_enrichments();
-                            app.set_enrichment(id, enrichment);
+                            app.set_enrichment(target, enrichment);
                             leave_recorded_success(
                                 &mut app,
                                 &repository_path,
@@ -2359,9 +2362,18 @@ fn event_loop(
                                 &ref_changes,
                                 "updated enrichment",
                             );
+                            if target != id {
+                                app.select_commit_after_refresh(target);
+                                refresh_pending = true;
+                            }
                         }
                         Ok(None) => {}
-                        Ok(Some(_)) => {}
+                        Ok(Some(outcome)) => {
+                            if outcome.target != id {
+                                app.select_commit_after_refresh(outcome.target);
+                                refresh_pending = true;
+                            }
+                        }
                         Err(err) => app.leave_error(format!("reword: {err:#}")),
                     }
                 }
@@ -4569,15 +4581,18 @@ fn reword_commit(
     terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
     bare: bool,
-    graph: &HistoryGraph,
+    revisions: &[OsString],
+    hidden_revisions: &[OsString],
     id: gix::ObjectId,
     enhanced_keyboard: bool,
 ) -> Result<Option<edit::reword::Outcome>> {
-    let (editor, document) = {
+    let (editor, document, change_id) = {
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before editing commit")?;
         repository.object_cache_size(None);
-        edit::reword::document(&repository, id)?
+        let change_id = change_id::for_commit(&repository, id)?;
+        let (editor, document) = edit::reword::document(&repository, id)?;
+        (editor, document, change_id)
     };
     let Some(edited) = edit::edit_document(
         terminal,
@@ -4593,7 +4608,8 @@ fn reword_commit(
     let mut repository =
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
-    edit::reword::apply(repository, graph, id, &edited).map(Some)
+    let (graph, id) = edit::reword::relocate_after_editor(&repository, revisions, hidden_revisions, change_id)?;
+    edit::reword::apply(repository, &graph, id, &edited).map(Some)
 }
 
 pub(crate) fn load_rebase_todo_commits(

From 215c5c8e8033e595f631388a9041e86e4f644a1d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 21:21:10 +0200
Subject: [PATCH 248/282] fix: stabilize Tix history gutter layout

---
 gix-tix/src/app.rs |   8 ++
 gix-tix/src/ui.rs  | 223 +++++++++++++++++++++++++--------------------
 2 files changed, 134 insertions(+), 97 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 3c05d3c6efe..ff7495d7257 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -730,6 +730,10 @@ impl App {
         self.duplicate_change_ids.contains(&id)
     }
 
+    pub(crate) fn has_duplicate_change_ids(&self) -> bool {
+        !self.duplicate_change_ids.is_empty()
+    }
+
     pub(crate) fn can_cycle_duplicate(&self) -> bool {
         self.changes_focus.is_none() && self.reachable_rows.is_none() && self.next_duplicate().is_some()
     }
@@ -877,6 +881,10 @@ impl App {
         self.pending_rebase_conflict.is_some()
     }
 
+    pub(crate) fn has_conflict_marker(&self) -> bool {
+        self.pending_rebase_conflict.is_some() || self.worktree_conflicted
+    }
+
     pub(crate) fn clear_rebase_conflict(&mut self) {
         self.pending_rebase_conflict = None;
         self.notice = None;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7a643f2e3d7..ab2e6debf8e 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -526,48 +526,14 @@ pub(crate) fn draw_with_worktree(
             )
     });
     let lanes = app.render_lanes(start..render_end);
-    let enrichment_gutter = visible_entries
-        .iter()
-        .filter_map(|entry| match entry {
-            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
-            HistoryEntry::Segment { .. } => None,
-        })
-        .map(|row| {
-            Line::raw(crate::enrich::marker(
-                app.todo(row.id),
-                app.note(row.id).is_some(),
-                app.checks_pass(row.id),
-            ))
-            .width()
-        })
-        .max()
-        .unwrap_or_default() as u16;
-    let has_duplicate_change_id = visible_entries
-        .iter()
-        .filter_map(|entry| match entry {
-            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
-            HistoryEntry::Segment { .. } => None,
-        })
-        .any(|row| app.has_duplicate_change_id(row.id));
+    let enrichment_gutter = Line::raw(crate::enrich::marker(true, true, true)).width() as u16;
+    let has_duplicate_change_id = app.has_duplicate_change_ids();
     let change_id_gutter = if has_duplicate_change_id {
         Line::raw("👯‍♂️").width() as u16
     } else {
         0
     };
-    let has_conflict = visible_entries
-        .iter()
-        .filter_map(|entry| match entry {
-            HistoryEntry::Commit(index) => Some(&app.rows[*index]),
-            HistoryEntry::Segment { .. } => None,
-        })
-        .any(|row| {
-            let head = decorations.get(&row.id).is_some_and(|decorations| {
-                decorations
-                    .iter()
-                    .any(|decoration| decoration.kind == DecorationKind::Head)
-            });
-            app.conflict_marker(row.id, head)
-        });
+    let has_conflict = app.has_conflict_marker();
     let conflict_gutter = if has_conflict {
         Line::raw("💥").width() as u16
     } else {
@@ -843,14 +809,14 @@ pub(crate) fn draw_with_worktree(
             color(highlight).add_modifier(Modifier::REVERSED)
         });
         let conflict = app.conflict_marker(row.id, head);
-        let enrichment_marker =
-            crate::enrich::marker(app.todo(row.id), app.note(row.id).is_some(), app.checks_pass(row.id));
-        if !enrichment_marker.is_empty() {
-            frame.render_widget(
-                Paragraph::new(enrichment_marker),
-                Rect::new(body.x, y, enrichment_gutter, 1),
-            );
-        }
+        frame.render_widget(
+            Paragraph::new(Line::from(vec![
+                Span::raw(if app.todo(row.id) { "🚧" } else { "  " }),
+                Span::raw(if app.note(row.id).is_some() { "📝" } else { "  " }),
+                Span::raw(if app.checks_pass(row.id) { "✔️" } else { "  " }),
+            ])),
+            Rect::new(body.x, y, enrichment_gutter, 1),
+        );
         if app.has_duplicate_change_id(row.id) {
             frame.render_widget(
                 Paragraph::new("👯‍♂️"),
@@ -3131,10 +3097,70 @@ mod tests {
             rendered_line(&terminal, 0).contains("follow-up title"),
             "a note replaces the selected title independently of todo"
         );
-        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), "📝");
-        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "✔️");
-        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), ">");
-        assert_eq!(terminal.backend().buffer()[(6, 0)].symbol(), "●");
+        assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), " ");
+        assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "📝");
+        assert_eq!(terminal.backend().buffer()[(4, 0)].symbol(), "✔️");
+        assert_eq!(terminal.backend().buffer()[(6, 0)].symbol(), ">");
+        assert_eq!(terminal.backend().buffer()[(8, 0)].symbol(), "●");
+        Ok(())
+    }
+
+    #[test]
+    fn gutter_columns_and_history_offset_stay_fixed_while_scrolling() -> Result<(), Box<dyn std::error::Error>> {
+        let ids = [5, 4, 3, 2, 1].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let mut app = App::new(1);
+        app.extend_commits(
+            ids.into_iter()
+                .enumerate()
+                .map(|(index, id)| Commit {
+                    id,
+                    parent_ids: ids.get(index + 1).copied().into_iter().collect(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: "subject".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        let ids: Vec<_> = app.rows.iter().map(|row| row.id).collect();
+        app.set_enrichment(ids[0], crate::enrich::Enrichment { todo: true, note: None });
+        app.set_enrichment(
+            ids[1],
+            crate::enrich::Enrichment {
+                todo: false,
+                note: Some("note".into()),
+            },
+        );
+        app.set_tree_enrichment(ids[2], crate::enrich::TreeEnrichment { checks_pass: true });
+        app.set_change_ids(
+            std::collections::HashMap::new(),
+            std::collections::HashSet::from([ids[3]]),
+        );
+        app.arm_rebase_conflict(ids[4]);
+
+        let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
+        for (index, marker_x, marker) in [(4, 8, "💥"), (3, 6, "👯‍♂️"), (2, 4, "✔️"), (1, 2, "📝"), (0, 0, "🚧")]
+        {
+            terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+            let row = terminal.backend().buffer();
+            assert_eq!(row[(marker_x, 0)].symbol(), marker, "row {index} keeps its marker slot");
+            assert_eq!(row[(10, 0)].symbol(), ">", "row {index} keeps the status column");
+            assert_eq!(row[(12, 0)].symbol(), "●", "row {index} keeps the graph column");
+            for empty_x in [0, 2, 4, 6, 8].into_iter().filter(|x| *x != marker_x) {
+                assert_eq!(
+                    row[(empty_x, 0)].symbol(),
+                    " ",
+                    "row {index} clears the unused gutter slot at {empty_x}"
+                );
+            }
+            app.update(Action::MoveUp);
+        }
         Ok(())
     }
 
@@ -3786,25 +3812,25 @@ mod tests {
         );
 
         let footer_text = "#0 · view · commit · actions · enrich · copy · refs · ? · quit";
-        let selected_line = "> @ 0101010 1970-01-01 mapped author subject";
+        let selected_line = "      > @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
-        for x in 0..11 {
+        for x in 6..17 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
         }
-        for x in 0..4 {
+        for x in 6..10 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         }
-        for x in 4..11 {
+        for x in 10..17 {
             expected[(x, 0)].set_style(
                 Style::default()
                     .fg(Color::Magenta)
                     .add_modifier(Modifier::REVERSED | Modifier::BOLD),
             );
         }
-        for x in 12..23 {
+        for x in 18..29 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Blue));
         }
-        for x in 23..37 {
+        for x in 29..43 {
             expected[(x, 0)].set_style(Style::default().fg(Color::Green));
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
@@ -3836,11 +3862,11 @@ mod tests {
 
         let row = terminal.backend().buffer();
         assert!(
-            row[(10, 0)].modifier.contains(Modifier::REVERSED),
+            row[(16, 0)].modifier.contains(Modifier::REVERSED),
             "selection includes the final hash character"
         );
         assert!(
-            !row[(11, 0)].modifier.contains(Modifier::REVERSED),
+            !row[(17, 0)].modifier.contains(Modifier::REVERSED),
             "selection ends immediately after the hash"
         );
         assert!(
@@ -3950,7 +3976,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         assert!(!rendered_row(&terminal).contains("HEAD"), "no refs hides regular refs");
         assert!(
-            rendered_row(&terminal).starts_with("> @"),
+            rendered_row(&terminal).trim_start().starts_with("> @"),
             "HEAD keeps its graph marker"
         );
         assert!(
@@ -4716,7 +4742,7 @@ mod tests {
             ],
         )]);
         terminal.draw(|frame| draw(frame, &mut app, &attached))?;
-        let marker = &terminal.backend().buffer()[(2, 0)];
+        let marker = &terminal.backend().buffer()[(8, 0)];
         assert_eq!(marker.symbol(), "@");
         assert!(marker.modifier.contains(Modifier::ITALIC), "attached HEAD is italic");
 
@@ -4731,7 +4757,7 @@ mod tests {
             ],
         )]);
         terminal.draw(|frame| draw(frame, &mut app, &detached))?;
-        let marker = &terminal.backend().buffer()[(2, 0)];
+        let marker = &terminal.backend().buffer()[(8, 0)];
         assert_eq!(marker.symbol(), "@");
         assert!(!marker.modifier.contains(Modifier::ITALIC), "detached HEAD is upright");
         Ok(())
@@ -4781,7 +4807,7 @@ mod tests {
                 "the unselected HEAD title is reversed"
             );
         }
-        for x in [0, 2, 5, 12, 79] {
+        for x in [0, 6, 8, 11, 18, 79] {
             assert!(
                 !terminal.backend().buffer()[(x, head_row)]
                     .modifier
@@ -4796,7 +4822,7 @@ mod tests {
             "the old HEAD underline is gone"
         );
         assert!(
-            terminal.backend().buffer()[(2, head_row)]
+            terminal.backend().buffer()[(8, head_row)]
                 .modifier
                 .contains(Modifier::BOLD),
             "the non-tip @ is bold"
@@ -4811,7 +4837,7 @@ mod tests {
             "selection removes the HEAD title emphasis"
         );
         assert!(
-            terminal.backend().buffer()[(2, head_row)]
+            terminal.backend().buffer()[(8, head_row)]
                 .modifier
                 .contains(Modifier::BOLD),
             "the selected non-tip @ remains bold"
@@ -4837,7 +4863,7 @@ mod tests {
             "an unselected tip HEAD title is reversed too"
         );
         assert!(
-            !terminal.backend().buffer()[(2, 0)].modifier.contains(Modifier::BOLD),
+            !terminal.backend().buffer()[(8, 0)].modifier.contains(Modifier::BOLD),
             "a tip @ keeps its normal weight"
         );
         Ok(())
@@ -5019,11 +5045,11 @@ mod tests {
                 Some(&dirty),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("🫟 @"));
-        assert!(rendered_line(&terminal, 1).starts_with("> ●"));
-        assert_eq!(terminal.backend().buffer()[(0, 0)].modifier, Modifier::empty());
+        assert!(rendered_line(&terminal, 0).trim_start().starts_with("🫟 @"));
+        assert!(rendered_line(&terminal, 1).trim_start().starts_with("> ●"));
+        assert_eq!(terminal.backend().buffer()[(6, 0)].modifier, Modifier::empty());
         assert!(
-            terminal.backend().buffer()[(0, 1)]
+            terminal.backend().buffer()[(6, 1)]
                 .modifier
                 .contains(Modifier::REVERSED)
         );
@@ -5040,9 +5066,9 @@ mod tests {
                 Some(&dirty),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("🫟 @"));
+        assert!(rendered_line(&terminal, 0).trim_start().starts_with("🫟 @"));
         assert!(
-            terminal.backend().buffer()[(0, 0)]
+            terminal.backend().buffer()[(6, 0)]
                 .modifier
                 .contains(Modifier::REVERSED)
         );
@@ -5069,13 +5095,13 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("💥 🫟 @"),
+            rendered_line(&terminal, 0).trim_start().starts_with("💥 🫟 @"),
             "the conflict gutter precedes the ordinary status: {:?}",
             rendered_line(&terminal, 0)
         );
-        assert_eq!(terminal.backend().buffer()[(0, 0)].fg, Color::LightRed);
+        assert_eq!(terminal.backend().buffer()[(6, 0)].fg, Color::LightRed);
         assert!(
-            terminal.backend().buffer()[(0, 0)]
+            terminal.backend().buffer()[(6, 0)]
                 .modifier
                 .contains(Modifier::SLOW_BLINK),
             "the conflict marker remains visually urgent"
@@ -5093,7 +5119,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("🫟 @"),
+            rendered_line(&terminal, 0).trim_start().starts_with("🫟 @"),
             "resolving the index restores the ordinary dirty marker"
         );
 
@@ -5111,7 +5137,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 1).starts_with("💥 > ●"),
+            rendered_line(&terminal, 1).trim_start().starts_with("💥 > ●"),
             "the conflict gutter does not replace selection: {:?}",
             rendered_line(&terminal, 1)
         );
@@ -5130,7 +5156,7 @@ mod tests {
                 Some(&dirty),
             );
         })?;
-        assert!(rendered_line(&terminal, 0).starts_with("> @"));
+        assert!(rendered_line(&terminal, 0).trim_start().starts_with("> @"));
         Ok(())
     }
 
@@ -6034,7 +6060,7 @@ mod tests {
             app.viewport_rows, 7,
             "history remains bounded above the highest overlay"
         );
-        assert!(rendered_line(&terminal, 0).starts_with('>'));
+        assert!(rendered_line(&terminal, 0).trim_start().starts_with('>'));
 
         let mut wide_terminal = Terminal::new(TestBackend::new(240, 16))?;
         wide_terminal.draw(|frame| {
@@ -6649,17 +6675,17 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
 
         let buffer = terminal.backend().buffer();
-        assert_eq!(buffer[(5, 0)].symbol(), "2", "the viewport starts at the second row");
-        assert_eq!(buffer[(5, 1)].symbol(), "3", "the selected third row remains visible");
+        assert_eq!(buffer[(11, 0)].symbol(), "2", "the viewport starts at the second row");
+        assert_eq!(buffer[(11, 1)].symbol(), "3", "the selected third row remains visible");
         assert!(
-            buffer[(0, 1)].modifier.contains(Modifier::REVERSED),
+            buffer[(6, 1)].modifier.contains(Modifier::REVERSED),
             "the slice-local selection highlights the global selection"
         );
         assert!(
             buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
             "a clipped selection marker uses the right border"
         );
-        let hash_color = buffer[(5, 1)].fg;
+        let hash_color = buffer[(11, 1)].fg;
         assert_eq!(app.selected, Some(2), "drawing preserves the global selection");
         assert_eq!(app.offset, 1, "drawing preserves the global offset");
 
@@ -6667,22 +6693,22 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let buffer = terminal.backend().buffer();
         assert!(
-            !buffer[(0, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
+            !buffer[(6, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
             "the inactive marker has no selection modifiers"
         );
         assert!(
-            !buffer[(5, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
+            !buffer[(11, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
             "the inactive hash has no selection modifiers"
         );
-        assert_eq!(buffer[(0, 1)].symbol(), ">", "the inactive row keeps its marker");
-        assert_eq!(buffer[(0, 1)].fg, Color::Reset, "the marker uses normal text color");
+        assert_eq!(buffer[(6, 1)].symbol(), ">", "the inactive row keeps its marker");
+        assert_eq!(buffer[(6, 1)].fg, Color::Reset, "the marker uses normal text color");
         assert_eq!(
-            buffer[(0, 1)].bg,
+            buffer[(6, 1)].bg,
             Color::Reset,
             "the marker has no selection background"
         );
-        assert_eq!(buffer[(5, 1)].fg, hash_color, "the hash returns to its normal color");
-        assert_eq!(buffer[(5, 1)].bg, Color::Reset, "the hash has no selection background");
+        assert_eq!(buffer[(11, 1)].fg, hash_color, "the hash returns to its normal color");
+        assert_eq!(buffer[(11, 1)].bg, Color::Reset, "the hash has no selection background");
         assert!(
             !buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
             "the final frame hides the trailing selection marker"
@@ -6797,7 +6823,7 @@ mod tests {
             assert!(cell.modifier.contains(Modifier::DIM), "the hidden row is dimmed");
         }
         assert_eq!(
-            terminal.backend().buffer()[(0, 1)].symbol(),
+            terminal.backend().buffer()[(6, 1)].symbol(),
             ">",
             "the hidden base is selectable"
         );
@@ -6922,15 +6948,15 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let buffer = terminal.backend().buffer();
-        assert_eq!(buffer[(2, 0)].fg, Color::Blue, "commit dots use graph-commit");
-        assert_eq!(buffer[(4, 0)].fg, Color::Yellow, "lanes cycle through tig's palette");
+        assert_eq!(buffer[(8, 0)].fg, Color::Blue, "commit dots use graph-commit");
+        assert_eq!(buffer[(10, 0)].fg, Color::Yellow, "lanes cycle through tig's palette");
         assert_eq!(
-            buffer[(16, 0)].fg,
+            buffer[(22, 0)].fg,
             Color::Magenta,
             "the palette repeats after seven lanes"
         );
         assert!(
-            buffer[(16, 0)].modifier.contains(Modifier::BOLD),
+            buffer[(22, 0)].modifier.contains(Modifier::BOLD),
             "the second palette cycle is bold"
         );
         Ok(())
@@ -7019,7 +7045,7 @@ mod tests {
         let mut terminal = Terminal::new(TestBackend::new(80, 2))?;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
-            rendered_line(&terminal, 0).starts_with("👯‍♂️ > "),
+            rendered_line(&terminal, 0).trim_start().starts_with("👯‍♂️ > "),
             "the ambiguity gutter does not replace selection: {:?}",
             rendered_line(&terminal, 0)
         );
@@ -7148,7 +7174,7 @@ mod tests {
             "attribution and markers share one column"
         );
 
-        let mut narrow = Terminal::new(TestBackend::new(40, 3))?;
+        let mut narrow = Terminal::new(TestBackend::new(46, 3))?;
         narrow.draw(|frame| draw(frame, &mut app, &decorations))?;
         app.update(Action::ScrollRight);
         assert!(app.horizontal_offset > 0, "wide aligned columns create a scroll range");
@@ -7222,9 +7248,12 @@ mod tests {
             rendered_line(&terminal, 0).contains("tip"),
             "the retained tip keeps its metadata"
         );
-        assert_eq!(rendered_line(&terminal, 1).trim(), "> ○ [2]");
+        let line = rendered_line(&terminal, 1);
+        let summary = "> ○ [2]";
+        let summary_x = line.find(summary).expect("the compressed summary is visible") as u16;
+        assert_eq!(line.trim(), summary);
         assert!(
-            (0..7).all(|x| terminal.backend().buffer()[(x, 1)]
+            (summary_x..summary_x + summary.chars().count() as u16).all(|x| terminal.backend().buffer()[(x, 1)]
                 .modifier
                 .contains(Modifier::REVERSED)),
             "the selected summary, including its status and count, is reversed"

From 9bf307c9f3bb15edfb48aa00454b54fb07663669 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 21:47:20 +0200
Subject: [PATCH 249/282] fix: keep Tix edits within the current history view

Exclude obsolete commits retained by the append-only history cache from descendant and merge queries used by edits. Preserve the ordinary history scope across ref-tree refreshes that temporarily load foreign worktree tips.
---
 gix-tix/src/history.rs | 98 ++++++++++++++++++++++++++++++++++++++++--
 gix-tix/src/lib.rs     |  7 ++-
 2 files changed, 99 insertions(+), 6 deletions(-)

diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index c9ebf84de5e..97888af23ab 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -183,6 +183,7 @@ impl HistoryGraph {
                 state: NODE_LOADED,
             };
         }
+        graph.set_current_view(&commits.iter().map(|(id, _)| *id).collect::<Vec<_>>());
         graph
     }
 
@@ -201,6 +202,7 @@ impl HistoryGraph {
         for id in ids {
             graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, *id, &mut buf)?;
         }
+        graph.set_current_view(ids);
         Ok(graph)
     }
 
@@ -260,7 +262,16 @@ impl HistoryGraph {
     }
 
     pub(crate) fn commits_with_descendants(&self) -> HashSet<ObjectId> {
-        self.parents.iter().map(|parent| self.id(*parent)).collect()
+        self.commits
+            .iter()
+            .filter(|commit| commit.state & NODE_IN_VIEW != 0)
+            .flat_map(|commit| {
+                self.parents[commit.parents.start as usize..commit.parents.end as usize]
+                    .iter()
+                    .copied()
+            })
+            .map(|parent| self.id(parent))
+            .collect()
     }
 
     pub(crate) fn parents_of(&self, id: ObjectId) -> Option<Vec<ObjectId>> {
@@ -272,7 +283,7 @@ impl HistoryGraph {
         let mut pending: Vec<_> = self
             .commits
             .iter()
-            .filter(|commit| commit.parents.len() > 1)
+            .filter(|commit| commit.state & NODE_IN_VIEW != 0 && commit.parents.len() > 1)
             .flat_map(|commit| {
                 let range = commit.parents.clone();
                 self.parents[range.start as usize..range.end as usize].iter().copied()
@@ -281,7 +292,12 @@ impl HistoryGraph {
         let mut ancestors = HashSet::new();
         while let Some(index) = pending.pop() {
             if ancestors.insert(index) {
-                pending.extend_from_slice(self.parents(index));
+                pending.extend(
+                    self.parents(index)
+                        .iter()
+                        .copied()
+                        .filter(|parent| self.commits[parent.as_usize()].state & NODE_IN_VIEW != 0),
+                );
             }
         }
         ancestors.into_iter().map(|index| self.id(index)).collect()
@@ -289,12 +305,18 @@ impl HistoryGraph {
 
     pub(crate) fn descendants_in_parent_order(&self, root: ObjectId) -> Option<Vec<ObjectId>> {
         let root = self.index(root)?;
+        if self.commits[root.as_usize()].state & NODE_IN_VIEW == 0 {
+            return None;
+        }
         let mut included = HashSet::from([root]);
         loop {
             let mut changed = false;
             for index in 0..self.commits.len() {
                 let index = CommitIndex::new(index).expect("an existing graph index fits into u32");
-                if included.contains(&index) || !self.parents(index).iter().any(|parent| included.contains(parent)) {
+                if self.commits[index.as_usize()].state & NODE_IN_VIEW == 0
+                    || included.contains(&index)
+                    || !self.parents(index).iter().any(|parent| included.contains(parent))
+                {
                     continue;
                 }
                 included.insert(index);
@@ -325,6 +347,20 @@ impl HistoryGraph {
         Some(out.into_iter().map(|index| self.id(index)).collect())
     }
 
+    pub(crate) fn set_current_view(&mut self, tips: &[ObjectId]) {
+        for commit in &mut self.commits {
+            commit.state &= !NODE_IN_VIEW;
+        }
+        let mut pending: Vec<_> = tips.iter().filter_map(|id| self.index(*id)).collect();
+        while let Some(index) = pending.pop() {
+            if self.commits[index.as_usize()].state & NODE_IN_VIEW != 0 {
+                continue;
+            }
+            self.commits[index.as_usize()].state |= NODE_IN_VIEW;
+            pending.extend_from_slice(self.parents(index));
+        }
+    }
+
     fn parent_ids(&self, index: CommitIndex) -> gix::traverse::commit::ParentIds {
         self.parents(index).iter().map(|parent| self.id(*parent)).collect()
     }
@@ -782,6 +818,7 @@ impl HistoryGraph {
             }
         }
         self.tracking = tracking;
+        self.set_current_view(&refs.view_tips);
         let decorations = decorations(repo, &refs.pins, &refs.worktrees)?;
         Ok(Refresh {
             refs,
@@ -821,6 +858,7 @@ const EXPAND: u8 = 1 << 4;
 const NODE_LOADED: u8 = 1 << 0;
 const NODE_COMPLETE: u8 = 1 << 1;
 const NODE_STORED: u8 = 1 << 2;
+const NODE_IN_VIEW: u8 = 1 << 3;
 
 #[derive(Clone, Copy, Default)]
 struct WalkState {
@@ -1201,6 +1239,7 @@ pub(crate) fn load(
     }
     emit(Event::VisibleComplete);
     graph.tracking = tracking;
+    graph.set_current_view(&tips);
     emit(Event::Complete(graph));
     Ok(())
 }
@@ -2670,6 +2709,57 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn refresh_excludes_replaced_commits_from_descendant_queries() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let events = loaded(fixture.path(), &["main"], &[])?;
+        let mut graph = events
+            .into_iter()
+            .find_map(|event| match event {
+                Event::Complete(graph) => Some(graph),
+                _ => None,
+            })
+            .expect("history loading returns the persistent graph");
+        let repo = crate::test_repository::open(fixture.path())?;
+        let old_tip = repo.rev_parse_single("main")?.detach();
+        let parent = repo
+            .find_commit(old_tip)?
+            .parent_ids()
+            .next()
+            .expect("the main tip has a parent")
+            .detach();
+        drop(repo);
+
+        let amend = Command::new("git")
+            .current_dir(fixture.path())
+            .args([
+                "-c",
+                "commit.gpgSign=false",
+                "commit",
+                "--amend",
+                "-q",
+                "-m",
+                "replacement",
+            ])
+            .status()?;
+        assert!(amend.success(), "git replaces the visible tip");
+
+        let repo = crate::test_repository::open(fixture.path())?;
+        let replacement = repo.rev_parse_single("main")?.detach();
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        graph.refresh(&repo, &["main".into()], &[], false, &HashSet::new(), &authors)?;
+        let descendants = graph
+            .descendants_in_parent_order(parent)
+            .expect("the shared parent remains in the current view");
+        assert!(descendants.contains(&replacement), "the replacement tip is editable");
+        assert!(
+            !descendants.contains(&old_tip),
+            "the obsolete tip is excluded from edits"
+        );
+        Ok(())
+    }
+
     #[test]
     fn refresh_stops_at_cached_tracking_ancestry() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 11de5718410..d9f35481d9c 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1269,10 +1269,13 @@ fn event_loop(
         }
         if let Some(result) = refresh_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
-                Ok((kind, graph, result)) => {
+                Ok((kind, mut graph, result)) => {
+                    let result = result?;
+                    if matches!(kind, RefreshKind::RefTree { .. }) {
+                        graph.set_current_view(&ref_snapshot.view_tips);
+                    }
                     app.set_known_descendants(graph.commits_with_descendants());
                     app.set_known_merge_descendants(graph.commits_with_merge_descendants());
-                    let result = result?;
                     app.set_worktree_branch(
                         (!repository_is_bare)
                             .then(|| current_worktree_branch(&result.refs))

From 731b4c41d8ba8364979451e4e5dde296deb7fa03 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Wed, 19 Aug 2026 22:11:43 +0200
Subject: [PATCH 250/282] fix: avoid duplicate checkout when returning from Tix
 travel

Reuse an available symbolic HEAD pin as the checkout target when returning to its branch, avoiding an intermediate detached checkout and its extra worktree traversal.

Complete pending rebases using only the affected rewritten path so unrelated history cannot delay or block time travel.
---
 gix-tix/spec.md                 |  11 +-
 gix-tix/src/edit/time_travel.rs | 183 +++++++++++++++++++++++++-------
 2 files changed, 149 insertions(+), 45 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index b0d2b0e924e..6c1ca1ab769 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -461,9 +461,10 @@ The Enter key is written as `<enter>` throughout.
 - When tix detaches an attached local branch, it records that branch symbolically
   in the singleton `refs/worktree/tix/pins/HEAD` ref. Git stores this HEAD pin
   privately for the current worktree, and later branch advances move its tip.
-  Further detached travel preserves the singleton. After each successful tix
-  checkout, landing on the remembered branch tip reattaches `HEAD` to that branch
-  and removes the HEAD pin; explicitly attaching another branch also removes it.
+  Further detached travel preserves the singleton. Landing on an available
+  remembered branch tip uses that branch as the checkout target directly,
+  reattaches `HEAD` in one checkout, and removes the HEAD pin; explicitly
+  attaching another branch also removes it.
   Attach is the exception: it deliberately retains the symbolic HEAD pin
   after attaching its remembered branch.
   A failed automatic reattachment leaves both detached `HEAD` and the HEAD pin
@@ -779,7 +780,9 @@ space first; changes blocks adapt within the remaining history width.
   ancestry through that destination. Every later descendant is reparented and
   becomes or remains lazy and unsigned, including ordinary commits created above
   pending history; traveling toward a non-pending ancestor leaves the entire
-  pending region untouched. A conflict retains the ours tree, exact merge-result
+  pending region untouched. A completed final replay does not reload history;
+  another pass loads only the rewritten path and never unrelated references.
+  A conflict retains the ours tree, exact merge-result
   tree, conflict stages, prepared commits, and in-memory objects without changing
   the repository. The actual conflicting row is selected and centered with normal
   history-boundary clamping and shows a blinking red `C`; `<enter>` persists
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index b17d71084ed..3552c50528b 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -334,11 +334,22 @@ where
         return Ok((None, Vec::new()));
     }
     let mut ref_changes = Vec::new();
-    let destination_pin = selected_pin(&repository, selected)?;
-    let checkout_detaches = reference.is_none()
-        && destination_pin
-            .as_ref()
-            .is_none_or(|pin| pin.target.try_name().is_none());
+    let pins = history::all_pins(&repository)?;
+    let destination_pin = selected_pin(&pins, selected);
+    let direct_head_pin = if reference.is_none() {
+        pins.into_iter().find(|pin| {
+            pin.is_head()
+                && pin.id == selected
+                && pin.target.try_name().is_some_and(|branch| {
+                    branch.as_bstr().starts_with(b"refs/heads/")
+                        && ensure_branch_is_available(&repository, branch).is_ok()
+                })
+        })
+    } else {
+        None
+    };
+    let pin_for_checkout = direct_head_pin.as_ref().or(destination_pin.as_ref());
+    let checkout_detaches = reference.is_none() && pin_for_checkout.is_none_or(|pin| pin.target.try_name().is_none());
     let head_pin = match head_ref
         .as_ref()
         .filter(|name| checkout_detaches && name.as_bstr().starts_with(b"refs/heads/"))
@@ -367,7 +378,7 @@ where
         None => None,
     };
     let head_after_checkout = reference.map_or_else(
-        || match destination_pin.as_ref().map(|pin| &pin.target) {
+        || match pin_for_checkout.map(|pin| &pin.target) {
             Some(Target::Symbolic(name)) => super::undo::State::Symbolic(name.clone()),
             Some(Target::Object(id)) => super::undo::State::Object(*id),
             None => super::undo::State::Object(selected),
@@ -375,7 +386,7 @@ where
         |name| super::undo::State::Symbolic(name.clone()),
     );
     drop(repository);
-    let checkout = match (reference, &destination_pin) {
+    let checkout = match (reference, pin_for_checkout) {
         (Some(reference), _) if reference.as_bstr().starts_with(b"refs/heads/") => {
             checkout_branch(&workdir, reference.as_ref())
         }
@@ -399,15 +410,18 @@ where
             after: head_after_checkout,
         });
     }
-    let mut notice = reference.map_or_else(
-        || {
-            destination_pin.as_ref().map_or_else(
-                || format!("time-travelled to {}", selected.to_hex_with_len(7)),
-                |pin| format!("returned from {}", pin_label(pin)),
-            )
-        },
-        |reference| format!("checked out {}", reference.shorten()),
-    );
+    let mut notice = match (reference, direct_head_pin.as_ref(), destination_pin.as_ref()) {
+        (Some(reference), _, _) => format!("checked out {}", reference.shorten()),
+        (None, Some(pin), _) => format!(
+            "returned to {}",
+            pin.target
+                .try_name()
+                .expect("a direct HEAD return is symbolic")
+                .shorten()
+        ),
+        (None, None, Some(pin)) => format!("returned from {}", pin_label(pin)),
+        (None, None, None) => format!("time-travelled to {}", selected.to_hex_with_len(7)),
+    };
     let repository = match open_repository(repository_path, bare, false) {
         Ok(repository) => repository,
         Err(err) => {
@@ -537,7 +551,8 @@ pub(crate) fn attach_reporting(
     let remembered = remembered_branch(&repository)?;
     validate_attach(&repository, head_id, &remembered)?;
 
-    let destination_pin = selected_pin(&repository, head_id)?;
+    let pins = history::all_pins(&repository)?;
+    let destination_pin = selected_pin(&pins, head_id);
     let mut ref_changes = Vec::new();
     let provisional = if remembered.branch_tip != head_id && !contains(&repository, remembered.branch_tip, head_id) {
         let (pin, created, mut changes) = create_or_reuse_pin_reporting(
@@ -750,16 +765,21 @@ pub(crate) fn perform_reporting_rebased(
     {
         anyhow::bail!("cannot time-travel with unresolved index conflicts");
     }
+    let source_review = review_tree(&repository, graph, review_roots, head_id)?;
+    let destination_review = review_tree(&repository, graph, review_roots, selected)?;
+    let crosses_review_boundary =
+        source_review.as_ref().map(|review| review.root) != destination_review.as_ref().map(|review| review.root);
     let mut completed_graph = None;
     let mut original_ids = HashMap::new();
-    let mut review_roots = review_roots.to_vec();
     let mut ref_rewrites = Vec::new();
     let mut ref_changes = Vec::new();
-    while let Some(base) = pending_base(&repository, selected)? {
+    let mut pending = pending_base(&repository, selected)?;
+    while let Some(base) = pending {
+        let graph = completed_graph.as_ref().unwrap_or(graph);
         let mut rebased = Vec::new();
         let outcome = super::rebase::perform_reporting_rebased(
             &repository,
-            completed_graph.as_ref().unwrap_or(graph),
+            graph,
             super::rebase::Edit::Repeat {
                 base,
                 checkout: selected,
@@ -788,7 +808,7 @@ pub(crate) fn perform_reporting_rebased(
         };
         ref_rewrites.extend(outcome.ref_rewrites.iter().cloned());
         ref_changes.extend(outcome.ref_changes.iter().cloned());
-        for (old, original) in rebased {
+        for &(old, original) in &rebased {
             if let Some(new) = outcome.map(old) {
                 original_ids.insert(new, original);
             }
@@ -799,16 +819,21 @@ pub(crate) fn perform_reporting_rebased(
         head_id = outcome
             .map(head_id)
             .context("HEAD disappeared while completing its rebase")?;
-        review_roots = review_roots.into_iter().filter_map(|id| outcome.map(id)).collect();
         repository = open_repository(repository_path, bare, false)
             .context("could not reopen repository after completing a pending rebase")?;
-        completed_graph = Some(super::loaded_graph(&repository)?);
+        pending = pending_base(&repository, selected)?;
+        if pending.is_some() {
+            let affected = rebased
+                .into_iter()
+                .map(|(id, _original)| {
+                    outcome
+                        .map(id)
+                        .context("a pending rebase commit disappeared while completing time-travel")
+                })
+                .collect::<Result<Vec<_>>>()?;
+            completed_graph = Some(history::HistoryGraph::for_commits(&repository, &affected)?);
+        }
     }
-    let graph = completed_graph.as_ref().unwrap_or(graph);
-    let source_review = review_tree(&repository, graph, &review_roots, head_id)?;
-    let destination_review = review_tree(&repository, graph, &review_roots, selected)?;
-    let crosses_review_boundary =
-        source_review.as_ref().map(|review| review.root) != destination_review.as_ref().map(|review| review.root);
     let workdir = repository
         .workdir()
         .context("time-travel requires a worktree")?
@@ -977,19 +1002,17 @@ fn pending_base(repository: &gix::Repository, selected: ObjectId) -> Result<Opti
     Ok(base)
 }
 
-fn selected_pin(repository: &gix::Repository, selected: ObjectId) -> Result<Option<history::Pin>> {
-    let mut pins: Vec<_> = history::all_pins(repository)?
-        .into_iter()
+fn selected_pin(pins: &[history::Pin], selected: ObjectId) -> Option<history::Pin> {
+    pins.iter()
         .filter(|pin| !pin.is_head() && pin.id == selected)
-        .collect();
-    pins.sort_by(|a, b| {
-        a.target
-            .try_name()
-            .is_none()
-            .cmp(&b.target.try_name().is_none())
-            .then_with(|| a.name.cmp(&b.name))
-    });
-    Ok(pins.into_iter().next())
+        .min_by(|a, b| {
+            a.target
+                .try_name()
+                .is_none()
+                .cmp(&b.target.try_name().is_none())
+                .then_with(|| a.name.cmp(&b.name))
+        })
+        .cloned()
 }
 
 #[cfg(test)]
@@ -1747,12 +1770,27 @@ mod tests {
             .set_target_id(topic, "advance pinned branch")?;
         let advanced = history::snapshot(&repository, &[], &[], false)?;
         assert!(advanced.view_tips.contains(&topic), "a symbolic pin follows its branch");
+        create_pin(&repository, Target::Object(topic), topic, "overlap with the HEAD pin")?;
+        assert_eq!(history::all_pins(&repository)?.len(), 2, "both return paths coexist");
         drop(repository);
 
+        let reflog_entries = git(fixture.path(), &["reflog", "show", "--format=%H", "HEAD"])?
+            .split(|byte| *byte == b'\n')
+            .filter(|line| !line.is_empty())
+            .count();
         let returned = perform(&repository_path, false, topic, &graph, &[], &[], false)?;
         let Perform::Complete { ref_changes, .. } = returned else {
             return Err("returning through the HEAD pin must complete".into());
         };
+        let returned_reflog_entries = git(fixture.path(), &["reflog", "show", "--format=%H", "HEAD"])?
+            .split(|byte| *byte == b'\n')
+            .filter(|line| !line.is_empty())
+            .count();
+        assert_eq!(
+            returned_reflog_entries,
+            reflog_entries + 1,
+            "returning through the HEAD pin performs one checkout"
+        );
         let repository = crate::test_repository::open(fixture.path())?;
         assert_eq!(
             repository.head_name()?.map(|name| name.as_bstr().to_owned()),
@@ -1766,8 +1804,10 @@ mod tests {
             .apply_with_worktrees(&repository)?;
         assert!(repository.head()?.is_detached(), "undo restores the detached HEAD");
         assert_eq!(repository.head_id()?.detach(), middle);
+        let pins = history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 2, "undo restores both return paths");
         assert!(
-            history::all_pins(&repository)?.iter().any(history::Pin::is_head),
+            pins.iter().any(history::Pin::is_head),
             "undo restores the symbolic HEAD pin"
         );
         super::super::undo::plan_redo(&repository)?
@@ -2333,6 +2373,67 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn pending_time_travel_does_not_load_unrelated_ref_history() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let graph = super::super::loaded_graph(&repository)?;
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repository.head_id()?.detach();
+        let mut commit = repository.find_commit(middle)?.decode()?.into_owned()?;
+        commit.tree = repository
+            .find_commit(repository.rev_parse_single("HEAD~2")?)?
+            .tree_id()?
+            .detach();
+        let marked = super::super::rebase::perform(
+            &repository,
+            &graph,
+            super::super::rebase::Edit::Replace { target: middle, commit },
+            super::super::rebase::Signature::InvalidateExisting,
+            super::super::rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let pending_tip = marked.map(old_tip).context("the marked tip is retained")?;
+        assert!(super::super::rebase::is_pending(
+            &repository.find_commit(pending_tip)?.decode()?.into_owned()?
+        ));
+
+        let missing_parent = ObjectId::Sha1([0x42; 20]);
+        let mut unrelated = repository.find_commit(pending_tip)?.decode()?.into_owned()?;
+        unrelated.parents = [missing_parent].into_iter().collect();
+        unrelated.message = "unrelated incomplete history".into();
+        let unrelated = repository.write_object(&unrelated)?.detach();
+        drop(repository);
+        git(
+            fixture.path(),
+            &["update-ref", "refs/heads/unrelated", &unrelated.to_string()],
+        )?;
+
+        let repository = crate::test_repository::open(fixture.path())?;
+        let graph = loaded_graph(&repository, &[OsString::from("main")])?;
+        drop(repository);
+        let mut rebased = Vec::new();
+        let outcome = perform_reporting_rebased(&repository_path, false, pending_tip, &graph, &[], &[], false, |id| {
+            rebased.push(id);
+        })?;
+        let Perform::Complete { selected, .. } = outcome else {
+            return Err("the pending rebase must complete".into());
+        };
+        assert_eq!(rebased, [pending_tip], "only the selected pending path is replayed");
+
+        let repository = crate::test_repository::open(fixture.path())?;
+        assert!(!super::super::rebase::is_pending(
+            &repository.find_commit(selected)?.decode()?.into_owned()?
+        ));
+        assert_eq!(
+            repository.find_reference("refs/heads/unrelated")?.id().detach(),
+            unrelated,
+            "time-travel leaves the unrelated incomplete history untouched"
+        );
+        Ok(())
+    }
+
     #[test]
     fn time_travel_materializes_only_the_pending_path_to_the_destination() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {

From 9951f415d63d276379ee26882df4c17f66a16cdf Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 05:12:34 +0200
Subject: [PATCH 251/282] fix: remove Tix UI animations

Present history refreshes and time travel as complete frames so viewport-dependent alignment is not redrawn through intermediate layouts.

Keep changes panes visible during navigation and make conflict markers steady, leaving Ratatui responsible for normal buffer diffing.
---
 gix-tix/AGENTS.md                             |   5 -
 gix-tix/spec.md                               |  31 +-
 gix-tix/src/animation.rs                      | 311 ------------
 gix-tix/src/app.rs                            |   6 +-
 gix-tix/src/lib.rs                            | 450 +-----------------
 gix-tix/src/logging.rs                        |  26 -
 ...sts__filesystem_new_top_commit_frames.snap |  16 -
 ...tion__tests__filesystem_reword_frames.snap |  14 -
 gix-tix/src/ui.rs                             | 136 +-----
 9 files changed, 45 insertions(+), 950 deletions(-)
 delete mode 100644 gix-tix/src/animation.rs
 delete mode 100644 gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
 delete mode 100644 gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 2ed748e22c2..8878716974e 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -54,8 +54,3 @@
 - Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
 - The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
 - Filesystem watchers retain paths and native watcher handles, never repositories.
-
-## Filesystem emphasis snapshots
-
-- Transition tests use `insta` snapshots containing every distinct frame; unchanged hold frames are intentionally omitted.
-- Run them with `cargo insta test -p gix-tix -F sha1`; review updates with `cargo insta review`. Never edit `.snap` files manually.
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6c1ca1ab769..15a438a7ca9 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -596,10 +596,7 @@ space first; changes blocks adapt within the remaining history width.
   block shows its distinct status line.
 - `p` cycles the comparison parent while Tree has focus. Merge commits are
   compared to one parent at a time; root commits compare against an empty tree.
-- Repeated history keys, including printable `j`/`k` reported through enhanced
-  keyboard input, and vertical mouse bursts temporarily hide changes
-  overlays. They return after 75 ms of navigation idle, with the same path
-  selection and viewport where possible.
+- History navigation leaves enabled changes overlays visible.
 - Tree diff results, detached diff resources, and line counts use a bounded MRU
   while changes remain enabled. Worktree results are cached separately and
   invalidated by relevant filesystem events.
@@ -785,7 +782,7 @@ space first; changes blocks adapt within the remaining history width.
   A conflict retains the ours tree, exact merge-result
   tree, conflict stages, prepared commits, and in-memory objects without changing
   the repository. The actual conflicting row is selected and centered with normal
-  history-boundary clamping and shows a blinking red `C`; `<enter>` persists
+  history-boundary clamping and shows a steady red conflict marker; `<enter>` persists
   the prepared rebase, leaves later descendants lazy, checks out the conflicting
   commit at the ours tree, then checks out the merge result and derives the
   unmerged index from it. `Esc` discards the suspended operation; navigation and
@@ -993,8 +990,8 @@ space first; changes blocks adapt within the remaining history width.
   ordinary steps remain lazy while squash groups are still materialized.
   Any conflict while applying a history todo first remains entirely in memory.
   The TUI projects the partial result, selects and centers the actual conflicting
-  result with normal history-boundary clamping, and marks it with a blinking red
-  `C`; predicted ref decorations remain at their
+  result with normal history-boundary clamping, and marks it with a steady red
+  conflict marker; predicted ref decorations remain at their
   repository positions. Repository-backed overlay content is hidden while these
   candidate objects exist only in memory. History and pane navigation and other
   read-only actions leave the preview armed; repository-changing actions and
@@ -1017,13 +1014,9 @@ space first; changes blocks adapt within the remaining history width.
   requires only that `HEAD` names a commit and the index has no unresolved stages;
   the index tree, including additional staged changes, becomes the resolved tree.
   There is no hidden sequencer state or separate continue/abort command.
-- Interactive todo application and time travel run on a scoped worker so the
-  terminal can remain renderable without cloning the cached history graph.
-  Todo application shows its modal gauge after 300 ms. During TUI time travel,
-  the history selection instead follows each pending commit after it is rebased.
-  The first and latest rows are drawn even for fast multi-commit operations;
-  intermediate rows may be coalesced to keep drawing at or below 60 fps.
-  Command-line `tix rebase apply` and `tix travel` do not animate.
+- Interactive todo application runs on a scoped worker and shows its modal gauge
+  after 300 ms. TUI and command-line time travel complete without intermediate
+  history-selection frames.
 - Displayed mutable refs follow their explicit locations in the edited todo;
   omission deletes them and newly named refs require nonexistence. Refs checked
   out by linked worktrees are displayed normally and may move, with their index
@@ -1137,11 +1130,8 @@ space first; changes blocks adapt within the remaining history width.
   failure while still needed.
 - Refresh status remains hidden for 500 ms so quick background work does not
   flicker the footer.
-- A filesystem history refresh is presented immediately. New or replaced visible
-  rows are bold for 180 ms, matched first by commit ID and then by tree ID so
-  rewords retain visual identity. Removals, unrelated replacements, manual
-  actions, hidden toggles, and worktree-only updates are immediate without
-  emphasis. Input, focus changes, and resizing end emphasis immediately.
+- A filesystem history refresh is presented immediately as one complete frame,
+  without animating or retaining intermediate history layouts.
 - While the terminal is unfocused, filesystem-attributed redraws replace footer
   separators with persistent orange discs. Focus restores normal separators.
 - Filesystem responses receive correlated IDs in daily tracing logs, including
@@ -1205,8 +1195,5 @@ space first; changes blocks adapt within the remaining history width.
 - Unit tests cover navigation, projections, pane layout, status summaries,
   selection restoration, watcher classification, cached graph walks, diff
   preparation, signatures, rewording, and terminal rendering.
-- Filesystem row emphasis uses `insta` snapshots containing every distinct frame;
-  unchanged hold frames are omitted. Run `cargo insta test -p gix-tix -F sha1`
-  and review with `cargo insta review`; never edit snapshots manually.
 - Behavior changes to this specification require corresponding tests and an
   update to this document in the same semantic patch.
diff --git a/gix-tix/src/animation.rs b/gix-tix/src/animation.rs
deleted file mode 100644
index 568d81539bc..00000000000
--- a/gix-tix/src/animation.rs
+++ /dev/null
@@ -1,311 +0,0 @@
-use std::{collections::HashMap, time::Duration};
-
-use gix::ObjectId;
-use ratatui::{buffer::Buffer, layout::Rect, style::Modifier};
-
-use crate::ui::FrameLayout;
-
-const EMPHASIS_DURATION: Duration = Duration::from_millis(180);
-
-#[derive(Clone, Debug)]
-pub(crate) struct Row {
-    pub id: ObjectId,
-    pub tree: Option<ObjectId>,
-    pub y: u16,
-}
-
-#[derive(Clone, Debug)]
-pub(crate) struct Snapshot {
-    pub buffer: Buffer,
-    pub layout: FrameLayout,
-    pub rows: Vec<Row>,
-}
-
-impl Snapshot {
-    pub(crate) fn new(buffer: Buffer, layout: FrameLayout) -> Self {
-        let rows = layout
-            .rows
-            .iter()
-            .map(|(id, y)| Row {
-                id: *id,
-                tree: None,
-                y: *y,
-            })
-            .collect();
-        Snapshot { buffer, layout, rows }
-    }
-
-    pub(crate) fn set_trees(&mut self, trees: &HashMap<ObjectId, ObjectId>) {
-        for row in &mut self.rows {
-            row.tree = trees.get(&row.id).copied();
-        }
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Emphasis {
-    target: Snapshot,
-    displayed: Buffer,
-    remaining: Duration,
-}
-
-impl Emphasis {
-    pub(crate) fn new(source: Snapshot, target: Snapshot) -> Option<Self> {
-        if source.buffer.area != target.buffer.area || source.buffer == target.buffer {
-            return None;
-        }
-        let matches = row_matches(&source.rows, &target.rows);
-        if matches.is_empty() {
-            return None;
-        }
-        let mut displayed = target.buffer.clone();
-        for (target_index, target_row) in target.rows.iter().enumerate() {
-            let changed = matches
-                .iter()
-                .find(|(_, candidate)| *candidate == target_index)
-                .is_none_or(|(source_index, _)| source.rows[*source_index].id != target_row.id);
-            if changed && !covered_by_overlay(target_row.y, &target.layout.overlays) {
-                modify_row(&mut displayed, target.layout.history, target_row.y, Modifier::BOLD);
-            }
-        }
-        (displayed != target.buffer).then_some(Emphasis {
-            target,
-            displayed,
-            remaining: EMPHASIS_DURATION,
-        })
-    }
-
-    pub(crate) fn target(&self) -> &Snapshot {
-        &self.target
-    }
-
-    pub(crate) fn displayed(&self) -> &Buffer {
-        &self.displayed
-    }
-
-    pub(crate) fn timeout(&self) -> Duration {
-        self.remaining
-    }
-
-    pub(crate) fn advance(&mut self, elapsed: Duration) -> Option<&Buffer> {
-        self.remaining = self.remaining.saturating_sub(elapsed);
-        if !self.is_complete() {
-            return None;
-        }
-        self.displayed.clone_from(&self.target.buffer);
-        Some(&self.displayed)
-    }
-
-    pub(crate) fn is_complete(&self) -> bool {
-        self.remaining == Duration::ZERO
-    }
-}
-
-fn row_matches(source: &[Row], target: &[Row]) -> Vec<(usize, usize)> {
-    let width = target.len() + 1;
-    let mut scores = vec![0u16; (source.len() + 1) * width];
-    for source_index in (0..source.len()).rev() {
-        for target_index in (0..target.len()).rev() {
-            let same = row_score(&source[source_index], &target[target_index]);
-            scores[source_index * width + target_index] = if same > 0 {
-                (same + scores[(source_index + 1) * width + target_index + 1])
-                    .max(scores[(source_index + 1) * width + target_index])
-                    .max(scores[source_index * width + target_index + 1])
-            } else {
-                scores[(source_index + 1) * width + target_index].max(scores[source_index * width + target_index + 1])
-            };
-        }
-    }
-    let mut out = Vec::new();
-    let (mut source_index, mut target_index) = (0, 0);
-    while source_index < source.len() && target_index < target.len() {
-        let same = row_score(&source[source_index], &target[target_index]);
-        if same > 0
-            && scores[source_index * width + target_index]
-                == same + scores[(source_index + 1) * width + target_index + 1]
-        {
-            out.push((source_index, target_index));
-            source_index += 1;
-            target_index += 1;
-        } else if scores[(source_index + 1) * width + target_index] >= scores[source_index * width + target_index + 1] {
-            source_index += 1;
-        } else {
-            target_index += 1;
-        }
-    }
-    out
-}
-
-fn row_score(source: &Row, target: &Row) -> u16 {
-    if source.id == target.id {
-        2
-    } else if source.tree.is_some() && source.tree == target.tree {
-        1
-    } else {
-        0
-    }
-}
-
-fn covered_by_overlay(y: u16, overlays: &[Rect]) -> bool {
-    overlays.iter().any(|area| y >= area.y && y < area.bottom())
-}
-
-fn modify_row(buffer: &mut Buffer, area: Rect, y: u16, modifier: Modifier) {
-    if y < area.y || y >= area.bottom() {
-        return;
-    }
-    for x in area.x.max(buffer.area.x)..area.right().min(buffer.area.right()) {
-        buffer[(x, y)].modifier.insert(modifier);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    fn id(n: u8) -> ObjectId {
-        ObjectId::from_bytes_or_panic(&[n; 20])
-    }
-
-    fn snapshot(ids: &[u8], trees: &[u8]) -> Snapshot {
-        history_snapshot(
-            &ids.iter()
-                .zip(trees)
-                .map(|(id, tree)| (*id, *tree, id.to_string()))
-                .collect::<Vec<_>>(),
-        )
-    }
-
-    fn history_snapshot(rows: &[(u8, u8, String)]) -> Snapshot {
-        let area = Rect::new(0, 0, 24, 4);
-        let mut buffer = Buffer::empty(area);
-        let rows = rows
-            .iter()
-            .enumerate()
-            .map(|(index, (id_value, tree, text))| {
-                for (x, symbol) in text.chars().take(area.width.into()).enumerate() {
-                    buffer[(x as u16, index as u16)].set_char(symbol);
-                }
-                Row {
-                    id: id(*id_value),
-                    tree: Some(id(*tree)),
-                    y: index as u16,
-                }
-            })
-            .collect();
-        Snapshot {
-            buffer,
-            layout: FrameLayout {
-                history: area,
-                ..FrameLayout::default()
-            },
-            rows,
-        }
-    }
-
-    fn distinct_frames(mut emphasis: Emphasis) -> String {
-        let first = emphasis.displayed().clone();
-        assert!(
-            emphasis
-                .advance(EMPHASIS_DURATION.saturating_sub(Duration::from_nanos(1)))
-                .is_none(),
-            "hold ticks do not produce duplicate frames"
-        );
-        let final_frame = emphasis
-            .advance(Duration::from_nanos(1))
-            .expect("the emphasis settles after its hold")
-            .clone();
-        [first, final_frame]
-            .iter()
-            .enumerate()
-            .map(|(index, frame)| format!("--- frame {index} ---\n{}", display_frame(frame)))
-            .collect::<Vec<_>>()
-            .join("\n")
-    }
-
-    fn display_frame(buffer: &Buffer) -> String {
-        let mut out = String::new();
-        for y in buffer.area.y..buffer.area.bottom() {
-            let cells = (buffer.area.x..buffer.area.right())
-                .map(|x| &buffer[(x, y)])
-                .collect::<Vec<_>>();
-            let text = cells.iter().map(|cell| cell.symbol()).collect::<String>();
-            out.push_str(text.trim_end());
-            out.push('\n');
-            let modifiers = cells
-                .iter()
-                .map(|cell| {
-                    if cell.modifier.contains(Modifier::BOLD) {
-                        'b'
-                    } else {
-                        ' '
-                    }
-                })
-                .collect::<String>();
-            if !modifiers.trim().is_empty() {
-                out.push_str("style: ");
-                out.push_str(modifiers.trim_end());
-                out.push('\n');
-            }
-        }
-        out
-    }
-
-    #[test]
-    fn rewritten_rows_match_by_tree_even_if_the_author_changed_with_the_id() {
-        let source = snapshot(&[1, 2], &[10, 20]);
-        let target = snapshot(&[3, 2], &[10, 20]);
-        assert_eq!(row_matches(&source.rows, &target.rows), [(0, 0), (1, 1)]);
-    }
-
-    #[test]
-    fn duplicate_trees_are_matched_in_relative_order() {
-        let source = snapshot(&[1, 2, 3], &[10, 10, 20]);
-        let target = snapshot(&[4, 5, 3], &[10, 10, 20]);
-        assert_eq!(row_matches(&source.rows, &target.rows), [(0, 0), (1, 1), (2, 2)]);
-    }
-
-    #[test]
-    fn removals_and_unrelated_replacements_are_immediate() {
-        let source = snapshot(&[1, 2], &[10, 20]);
-        let removal = snapshot(&[2], &[20]);
-        assert!(
-            Emphasis::new(source, removal).is_none(),
-            "a removal has no new row to emphasize"
-        );
-
-        let source = snapshot(&[1], &[10]);
-        let unrelated = snapshot(&[2], &[20]);
-        assert!(
-            Emphasis::new(source, unrelated).is_none(),
-            "an unrelated history has no visual anchor"
-        );
-    }
-
-    #[test]
-    fn filesystem_reword_frames() {
-        let source = history_snapshot(&[(1, 10, "111 old title".into()), (2, 20, "222 unchanged".into())]);
-        let target = history_snapshot(&[(3, 10, "333 new title".into()), (2, 20, "222 unchanged".into())]);
-        insta::assert_snapshot!(distinct_frames(
-            Emphasis::new(source, target).expect("a reword is emphasized")
-        ));
-    }
-
-    #[test]
-    fn filesystem_new_top_commit_frames() {
-        let source = history_snapshot(&[
-            (1, 10, "111 first".into()),
-            (2, 20, "222 second".into()),
-            (3, 30, "333 third".into()),
-        ]);
-        let target = history_snapshot(&[
-            (4, 40, "444 new commit".into()),
-            (1, 10, "111 first".into()),
-            (2, 20, "222 second".into()),
-            (3, 30, "333 third".into()),
-        ]);
-        insta::assert_snapshot!(distinct_frames(
-            Emphasis::new(source, target).expect("a new top commit is emphasized")
-        ));
-    }
-}
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ff7495d7257..6c166a70bc0 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -541,7 +541,6 @@ pub(crate) struct App {
     pub show_commit: bool,
     pub changes_mode: Option<ChangesMode>,
     worktree_changes_available: bool,
-    pub(crate) changes_suppressed: bool,
     pub(crate) changes_focus: Option<ChangePane>,
     pub(crate) changes_layout: ChangesLayout,
     pub(crate) tree_changes_visible: bool,
@@ -649,7 +648,6 @@ impl App {
             show_commit: false,
             changes_mode: Some(ChangesMode::Both),
             worktree_changes_available: true,
-            changes_suppressed: false,
             changes_focus: None,
             changes_layout: ChangesLayout::SideBySide,
             tree_changes_visible: false,
@@ -1624,7 +1622,6 @@ impl App {
                 self.reset_changes_view();
                 self.changes_parent = 0;
                 if self.changes_mode.is_none() {
-                    self.changes_suppressed = false;
                     self.changes_focus = None;
                 }
             }
@@ -2303,7 +2300,6 @@ impl App {
         self.lane_time = None;
         self.estimated_lane_width = 0;
         self.show_hidden = show_hidden;
-        self.changes_suppressed = false;
         self.horizontal_offset = 0;
         self.focus_history();
         self.reset_commit_view();
@@ -2404,7 +2400,7 @@ impl App {
     }
 
     pub(crate) fn changes_visible(&self) -> bool {
-        self.changes_mode.is_some() && !self.changes_suppressed && self.pending_rebase_conflict.is_none()
+        self.changes_mode.is_some() && self.pending_rebase_conflict.is_none()
     }
 
     fn ensure_changes_visible(&mut self) {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index d9f35481d9c..c8f05080d2b 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2,7 +2,6 @@
 
 #![forbid(unsafe_code)]
 
-mod animation;
 mod app;
 mod change_id;
 pub mod command;
@@ -263,123 +262,6 @@ struct SelectionRelationCache {
     relation: Option<SelectionRelation>,
 }
 
-#[derive(Default)]
-struct MotionState {
-    shown: Option<animation::Snapshot>,
-    pending: Option<animation::Snapshot>,
-    active: Option<animation::Emphasis>,
-    last_tick: Option<Instant>,
-}
-
-impl MotionState {
-    fn capture(&mut self) {
-        if self.pending.is_none() {
-            let source = self
-                .active
-                .as_ref()
-                .map(|emphasis| emphasis.target().clone())
-                .or_else(|| self.shown.clone());
-            if let Some(source) = source {
-                self.pending = Some(source);
-            }
-        }
-    }
-
-    fn has_pending(&self) -> bool {
-        self.pending.is_some()
-    }
-
-    fn transition_ids(&self, target: &animation::Snapshot) -> Vec<gix::ObjectId> {
-        let Some(source) = &self.pending else {
-            return Vec::new();
-        };
-        if source
-            .rows
-            .iter()
-            .map(|row| row.id)
-            .eq(target.rows.iter().map(|row| row.id))
-        {
-            return Vec::new();
-        }
-        source.rows.iter().chain(&target.rows).map(|row| row.id).collect()
-    }
-
-    fn begin(
-        &mut self,
-        target: animation::Snapshot,
-        trees: &HashMap<gix::ObjectId, gix::ObjectId>,
-        now: Instant,
-    ) -> Option<ratatui::buffer::Buffer> {
-        let Some(mut source) = self.pending.take() else {
-            self.shown = Some(target);
-            return None;
-        };
-        if source.buffer.area != target.buffer.area || source.buffer == target.buffer {
-            self.shown = Some(target);
-            self.last_tick = None;
-            return None;
-        }
-        source.set_trees(trees);
-        let mut target = target;
-        target.set_trees(trees);
-        let Some(emphasis) = animation::Emphasis::new(source, target.clone()) else {
-            self.shown = Some(target);
-            self.active = None;
-            self.last_tick = None;
-            return None;
-        };
-        let displayed = emphasis.displayed().clone();
-        self.active = Some(emphasis);
-        self.last_tick = Some(now);
-        Some(displayed)
-    }
-
-    fn timeout(&self, now: Instant) -> Option<Duration> {
-        self.active.as_ref().map(|emphasis| {
-            let since_tick = self
-                .last_tick
-                .map_or(Duration::ZERO, |last_tick| now.saturating_duration_since(last_tick));
-            emphasis.timeout().saturating_sub(since_tick)
-        })
-    }
-
-    fn advance(&mut self, now: Instant) -> Option<ratatui::buffer::Buffer> {
-        let elapsed = self
-            .last_tick
-            .replace(now)
-            .map_or(Duration::ZERO, |previous| now.saturating_duration_since(previous));
-        let emphasis = self.active.as_mut()?;
-        let frame = emphasis.advance(elapsed).cloned();
-        if emphasis.is_complete() {
-            self.shown = Some(emphasis.target().clone());
-            self.active = None;
-            self.last_tick = None;
-        }
-        frame
-    }
-
-    fn finish(&mut self) -> Option<ratatui::buffer::Buffer> {
-        let emphasis = self.active.take()?;
-        let target = emphasis.target().clone();
-        let buffer = target.buffer.clone();
-        self.shown = Some(target);
-        self.last_tick = None;
-        Some(buffer)
-    }
-
-    fn show(&mut self, target: animation::Snapshot) -> ratatui::buffer::Buffer {
-        self.active = None;
-        self.last_tick = None;
-        let buffer = target.buffer.clone();
-        self.shown = Some(target);
-        buffer
-    }
-
-    fn cancel_pending(&mut self) {
-        self.pending = None;
-    }
-}
-
 const TREE_CHANGES_CACHE_SIZE: usize = 8;
 type TreeChangesEntry = (app::TreeDiffTarget, Changes);
 
@@ -917,7 +799,6 @@ fn event_loop(
     let mut refresh_pending = false;
     let mut ref_tree_refresh_pending = false;
     let mut return_to_history_after_refresh = None;
-    let mut refresh_from_filesystem = false;
     let mut ref_refresh_deadline: Option<Instant> = None;
     let mut refresh_expand_hidden = false;
     let mut verification_receiver = None;
@@ -958,7 +839,6 @@ fn event_loop(
     }
     let mut decorations = Decorations::new();
     let mut ref_tree = ref_tree::Tree::default();
-    let mut motion = MotionState::default();
     let mut filesystem_responses = logging::FilesystemResponses::default();
     let mut focused = true;
     draw(
@@ -974,7 +854,6 @@ fn event_loop(
         &mut history_graph,
         &mut selection_relation,
         &mut line_diff_pool,
-        &mut motion,
         focused,
         &mut ref_tree,
         &mut filesystem_responses,
@@ -1029,7 +908,6 @@ fn event_loop(
             app.leave_attention("worktree removed; using the common repository without worktree changes");
             if history_graph.is_some() {
                 refresh_pending = true;
-                refresh_from_filesystem = true;
             }
             dirty = true;
             urgent = true;
@@ -1149,7 +1027,6 @@ fn event_loop(
             }
             let response_ids = filesystem_responses.references_due();
             refresh_pending = true;
-            refresh_from_filesystem = true;
             let invalidated = invalidate_worktree_changes(&mut worktree_changes);
             filesystem_responses.phase(&response_ids, "reference-worktree-cache-invalidation");
             if invalidated {
@@ -1209,14 +1086,8 @@ fn event_loop(
         }
         if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
             repeat_deadline = None;
-            if app.changes_suppressed {
-                app.changes_suppressed = false;
-                dirty = true;
-                urgent = true;
-            } else {
-                fill_repository.retain = false;
-                fill_repository.retained = None;
-            }
+            fill_repository.retain = false;
+            fill_repository.retained = None;
         }
         if let Some(result) = verification_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
@@ -1385,12 +1256,6 @@ fn event_loop(
             let hidden_changed = next.hidden != ref_snapshot.hidden;
             let worktree_tips_changed = ref_tree.is_active() && next.worktrees != ref_snapshot.worktrees;
             let tips_changed = next.view != ref_snapshot.view || hidden_changed || worktree_tips_changed;
-            let from_filesystem = std::mem::take(&mut refresh_from_filesystem);
-            if tips_changed && from_filesystem {
-                motion.capture();
-            } else {
-                motion.cancel_pending();
-            }
             tracing::debug!(
                 ?response_ids,
                 tips_changed,
@@ -1426,18 +1291,6 @@ fn event_loop(
             filesystem_responses.phase(&response_ids, "history-refresh-started");
             tracing::info!(?response_ids, "started history refresh");
         }
-        let now = Instant::now();
-        if motion.timeout(now) == Some(Duration::ZERO)
-            && let Some(frame) = motion.advance(now)
-        {
-            if present_buffer(terminal, &frame)? {
-                filesystem_responses.emphasis_finished("history-emphasis-settled", "completed");
-                filesystem_responses.frame_presented();
-            } else {
-                filesystem_responses.emphasis_aborted("terminal-area-changed");
-            }
-            last_draw = now;
-        }
         if urgent {
             draw(
                 terminal,
@@ -1452,7 +1305,6 @@ fn event_loop(
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
-                &mut motion,
                 focused,
                 &mut ref_tree,
                 &mut filesystem_responses,
@@ -1522,7 +1374,6 @@ fn event_loop(
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
-                &mut motion,
                 focused,
                 &mut ref_tree,
                 &mut filesystem_responses,
@@ -1540,7 +1391,6 @@ fn event_loop(
         let retry_timeout = watcher_retry_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let history_status_timeout =
             history_status_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
-        let animation_timeout = motion.timeout(Instant::now());
         let wake_after = [
             repeat_timeout,
             watcher_timeout,
@@ -1548,7 +1398,6 @@ fn event_loop(
             worktree_timeout,
             retry_timeout,
             history_status_timeout,
-            animation_timeout,
         ]
         .into_iter()
         .flatten()
@@ -1772,17 +1621,7 @@ fn event_loop(
                 (Some(action), repeats_history, true, true)
             }
             TerminalEvent::FocusLost => {
-                if let Some(frame) = motion.finish() {
-                    if present_buffer(terminal, &frame)? {
-                        filesystem_responses.emphasis_finished("emphasis-interrupted-by-focus", "interrupted-by-focus");
-                        filesystem_responses.frame_presented();
-                    } else {
-                        filesystem_responses.emphasis_aborted("terminal-area-changed");
-                    }
-                }
-                motion.cancel_pending();
                 focused = false;
-                app.changes_suppressed = false;
                 repeat_deadline = None;
                 dirty = true;
                 urgent = true;
@@ -1797,34 +1636,12 @@ fn event_loop(
                 continue;
             }
             TerminalEvent::Resize(_, _) => {
-                if let Some(frame) = motion.finish() {
-                    if present_buffer(terminal, &frame)? {
-                        filesystem_responses
-                            .emphasis_finished("emphasis-interrupted-by-resize", "interrupted-by-resize");
-                        filesystem_responses.frame_presented();
-                    } else {
-                        filesystem_responses.emphasis_aborted("terminal-area-changed");
-                    }
-                }
-                motion.cancel_pending();
                 dirty = true;
                 urgent = true;
                 continue;
             }
             _ => continue,
         };
-        if action.as_ref().is_some_and(|action| action != &Action::ForceQuit) {
-            if let Some(frame) = motion.finish() {
-                if present_buffer(terminal, &frame)? {
-                    filesystem_responses.emphasis_finished("emphasis-interrupted-by-input", "interrupted-by-input");
-                    filesystem_responses.frame_presented();
-                } else {
-                    filesystem_responses.emphasis_aborted("terminal-area-changed");
-                }
-                last_draw = Instant::now();
-            }
-            motion.cancel_pending();
-        }
         if !focused {
             continue;
         }
@@ -1837,14 +1654,6 @@ fn event_loop(
             fill_repository.retain = false;
             fill_repository.retained = None;
         }
-        if repeats_history && app.changes_mode.is_some() {
-            app.changes_suppressed = true;
-        } else if !is_repeat && app.changes_suppressed {
-            app.changes_suppressed = false;
-            repeat_deadline = None;
-            dirty = true;
-            urgent = true;
-        }
         if key_pressed
             && action == Some(Action::OpenDiff)
             && app.changes_focus.is_none()
@@ -3085,42 +2894,14 @@ fn event_loop(
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            run_with_rebase_selection(
-                                |report| {
-                                    edit::time_travel::perform_reporting_rebased(
-                                        &repository_path,
-                                        repository_is_bare,
-                                        id,
-                                        graph,
-                                        &review_roots,
-                                        &revisions,
-                                        false,
-                                        report,
-                                    )
-                                },
-                                |id| {
-                                    app.select_commit(id);
-                                    let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
-                                    let tree = tree_changes.as_ref().map(|(_, changes)| changes);
-                                    let worktree = worktree_changes
-                                        .as_ref()
-                                        .filter(|(marker, _)| *marker != usize::MAX)
-                                        .map(|(_, changes)| changes);
-                                    terminal
-                                        .draw(|frame| {
-                                            ui::draw_with_worktree(
-                                                frame,
-                                                &mut app,
-                                                &decorations,
-                                                &mailmap,
-                                                message,
-                                                tree,
-                                                worktree,
-                                            );
-                                        })
-                                        .context("could not draw time-travel animation")?;
-                                    Ok(())
-                                },
+                            edit::time_travel::perform(
+                                &repository_path,
+                                repository_is_bare,
+                                id,
+                                graph,
+                                &review_roots,
+                                &revisions,
+                                false,
                             )
                         });
                     match result {
@@ -3723,7 +3504,6 @@ fn draw(
     history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
-    motion: &mut MotionState,
     focused: bool,
     ref_tree: &mut ref_tree::Tree,
     filesystem_responses: &mut logging::FilesystemResponses,
@@ -3733,7 +3513,6 @@ fn draw(
         return Ok(());
     }
     if ref_tree.is_active() {
-        motion.cancel_pending();
         terminal
             .autoresize()
             .context("could not resize the terminal before drawing")?;
@@ -3989,7 +3768,7 @@ fn draw(
     terminal
         .autoresize()
         .context("could not resize the terminal before drawing")?;
-    let layout = {
+    {
         let mut frame = terminal.get_frame();
         ui::draw_with_worktree(
             &mut frame,
@@ -3999,28 +3778,12 @@ fn draw(
             message,
             tree_changes,
             worktree_changes,
-        )
-    };
-    let target = animation::Snapshot::new(terminal.current_buffer_mut().clone(), layout);
-    let ready = matches!(app.state, State::Complete | State::Cancelled);
-    let presented = if motion.has_pending() && ready {
-        let ids = motion.transition_ids(&target);
-        let trees = load_transition_trees(&fill_repository.path, fill_repository.bare, &ids);
-        let started = motion.begin(target.clone(), &trees, Instant::now());
-        if started.is_some() {
-            filesystem_responses.emphasis_started();
-        }
-        started.unwrap_or_else(|| target.buffer.clone())
-    } else {
-        filesystem_responses.emphasis_finished("history-emphasis-superseded", "superseded");
-        let frame = motion.show(target);
-        if ready {
-            let response_ids = filesystem_responses.active_reference_ids().to_vec();
-            filesystem_responses.finish_after_frame(&response_ids, "completed");
-        }
-        frame
-    };
-    terminal.current_buffer_mut().clone_from(&presented);
+        );
+    }
+    if matches!(app.state, State::Complete | State::Cancelled) {
+        let response_ids = filesystem_responses.active_reference_ids().to_vec();
+        filesystem_responses.finish_after_frame(&response_ids, "completed");
+    }
     terminal
         .apply_buffer_with_cursor(None)
         .context("could not draw terminal frame")?;
@@ -4028,59 +3791,6 @@ fn draw(
     Ok(())
 }
 
-fn load_transition_trees(
-    repository_path: &Path,
-    bare: bool,
-    ids: &[gix::ObjectId],
-) -> HashMap<gix::ObjectId, gix::ObjectId> {
-    if ids.is_empty() {
-        return HashMap::new();
-    }
-    let loaded = (|| -> Result<_> {
-        let mut repository = open_repository(repository_path, bare, true)?;
-        repository.object_cache_size(None);
-        let cache = repository
-            .commit_graph_if_enabled()
-            .context("could not open commit-graph for transition matching")?;
-        let mut buf = Vec::new();
-        let mut trees = HashMap::with_capacity(ids.len());
-        for id in ids {
-            let commit = match gix::traverse::commit::find(cache.as_ref(), &repository.objects, id, &mut buf) {
-                Ok(commit) => commit,
-                Err(err) => {
-                    tracing::debug!(%id, error = %err, "could not load transition commit");
-                    continue;
-                }
-            };
-            match commit.tree_id() {
-                Ok(tree) => {
-                    trees.insert(*id, tree);
-                }
-                Err(err) => tracing::debug!(%id, error = %err, "could not decode transition commit tree"),
-            }
-        }
-        Ok(trees)
-    })();
-    match loaded {
-        Ok(trees) => trees,
-        Err(err) => {
-            tracing::warn!(error = %err, "transition tree matching unavailable");
-            HashMap::new()
-        }
-    }
-}
-
-fn present_buffer(terminal: &mut ratatui::DefaultTerminal, buffer: &ratatui::buffer::Buffer) -> Result<bool> {
-    if terminal.get_frame().area() != buffer.area {
-        return Ok(false);
-    }
-    terminal.current_buffer_mut().clone_from(buffer);
-    terminal
-        .apply_buffer_with_cursor(None)
-        .context("could not draw animation frame")?;
-    Ok(true)
-}
-
 fn open_repository(repository_path: &Path, bare: bool, isolated: bool) -> Result<gix::Repository> {
     let options = if isolated {
         gix::open::Options::isolated()
@@ -4829,80 +4539,6 @@ enum RebaseWorkerEvent<T> {
     Complete(Result<T>),
 }
 
-enum TravelWorkerEvent<T> {
-    Rebased(gix::ObjectId),
-    Complete(Result<T>),
-}
-
-fn run_with_rebase_selection<T: Send>(
-    operation: impl FnOnce(&mut dyn FnMut(gix::ObjectId)) -> Result<T> + Send,
-    mut render: impl FnMut(gix::ObjectId) -> Result<()>,
-) -> Result<T> {
-    std::thread::scope(|scope| {
-        let (sender, receiver) = mpsc::channel();
-        let worker = scope.spawn(move || {
-            let mut report = |id| {
-                let _ = sender.send(TravelWorkerEvent::Rebased(id));
-            };
-            let result = operation(&mut report);
-            let _ = sender.send(TravelWorkerEvent::Complete(result));
-        });
-        let mut last_draw: Option<Instant> = None;
-        let mut latest = None;
-        let mut rendered = None;
-        let mut complete = None;
-        let result = loop {
-            let event = if complete.is_some() {
-                None
-            } else if latest != rendered
-                && let Some(last_draw) = last_draw
-            {
-                match receiver.recv_timeout(FRAME_INTERVAL.saturating_sub(last_draw.elapsed())) {
-                    Ok(event) => Some(event),
-                    Err(mpsc::RecvTimeoutError::Timeout) => None,
-                    Err(mpsc::RecvTimeoutError::Disconnected) => {
-                        break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly"));
-                    }
-                }
-            } else {
-                match receiver.recv() {
-                    Ok(event) => Some(event),
-                    Err(_) => break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly")),
-                }
-            };
-            match event {
-                Some(TravelWorkerEvent::Rebased(id)) => latest = Some(id),
-                Some(TravelWorkerEvent::Complete(result)) => complete = Some(result),
-                None => {}
-            }
-            if latest != rendered
-                && (last_draw.is_none()
-                    || last_draw.is_some_and(|last_draw| last_draw.elapsed() >= FRAME_INTERVAL)
-                    || complete.is_some())
-            {
-                if complete.is_some()
-                    && let Some(last_draw) = last_draw
-                {
-                    std::thread::sleep(FRAME_INTERVAL.saturating_sub(last_draw.elapsed()));
-                }
-                let id = latest.expect("a changed rebased commit is available");
-                if let Err(err) = render(id) {
-                    break Err(err);
-                }
-                rendered = latest;
-                last_draw = Some(Instant::now());
-            }
-            if let Some(result) = complete.take() {
-                break result;
-            }
-        };
-        if worker.join().is_err() {
-            return Err(anyhow::anyhow!("time-travel worker panicked"));
-        }
-        result
-    })
-}
-
 fn run_rebase_plan(
     terminal: &mut ratatui::DefaultTerminal,
     repository: gix::ThreadSafeRepository,
@@ -7884,58 +7520,6 @@ mod tests {
         assert!(todo_progress_visible(TODO_PROGRESS_DELAY));
     }
 
-    #[test]
-    fn fast_time_travel_draws_the_first_and_latest_rebased_commits() -> Result<()> {
-        let ids = [
-            gix::ObjectId::Sha1([1; 20]),
-            gix::ObjectId::Sha1([2; 20]),
-            gix::ObjectId::Sha1([3; 20]),
-        ];
-        let mut rendered = Vec::new();
-
-        run_with_rebase_selection(
-            |report| {
-                for id in ids {
-                    report(id);
-                }
-                Ok(())
-            },
-            |id| {
-                rendered.push(id);
-                Ok(())
-            },
-        )?;
-
-        assert_eq!(rendered, [ids[0], ids[2]], "fast intermediate commits are coalesced");
-        Ok(())
-    }
-
-    #[test]
-    fn slow_time_travel_only_draws_rebased_selections() -> Result<()> {
-        let ids = [gix::ObjectId::Sha1([1; 20]), gix::ObjectId::Sha1([2; 20])];
-        let mut rendered = Vec::new();
-
-        run_with_rebase_selection(
-            |report| {
-                for id in ids {
-                    report(id);
-                    std::thread::sleep(FRAME_INTERVAL * 2);
-                }
-                Ok(())
-            },
-            |id| {
-                rendered.push(id);
-                Ok(())
-            },
-        )?;
-
-        assert_eq!(
-            rendered, ids,
-            "slow travel has no rendering mode besides selection frames"
-        );
-        Ok(())
-    }
-
     #[test]
     fn continuing_a_conflict_commits_the_complete_resolved_index() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
diff --git a/gix-tix/src/logging.rs b/gix-tix/src/logging.rs
index 08fd8922d26..8853841efab 100644
--- a/gix-tix/src/logging.rs
+++ b/gix-tix/src/logging.rs
@@ -106,7 +106,6 @@ pub(crate) struct FilesystemResponses {
     pending_references: Option<u64>,
     queued_references: Vec<u64>,
     active_references: Vec<u64>,
-    emphasis: Vec<u64>,
     frame_causes: Vec<(u64, &'static str)>,
     finish_after_frame: Vec<(u64, &'static str)>,
 }
@@ -202,30 +201,6 @@ impl FilesystemResponses {
         !self.frame_causes.is_empty()
     }
 
-    pub(crate) fn keep_after_frame(&mut self, ids: &[u64]) {
-        self.finish_after_frame.retain(|(id, _)| !ids.contains(id));
-    }
-
-    pub(crate) fn emphasis_started(&mut self) {
-        let superseded = std::mem::take(&mut self.emphasis);
-        self.finish(&superseded, "superseded");
-        let ids = self.active_references.clone();
-        self.keep_after_frame(&ids);
-        self.queue_frame(&ids, "history-emphasis-started");
-        self.emphasis = ids;
-    }
-
-    pub(crate) fn emphasis_finished(&mut self, reason: &'static str, outcome: &'static str) {
-        let ids = std::mem::take(&mut self.emphasis);
-        self.queue_frame(&ids, reason);
-        self.finish_after_frame(&ids, outcome);
-    }
-
-    pub(crate) fn emphasis_aborted(&mut self, outcome: &'static str) {
-        let ids = std::mem::take(&mut self.emphasis);
-        self.finish(&ids, outcome);
-    }
-
     pub(crate) fn fail_pending_worktree(&mut self) {
         self.cancel_pending_worktree("watcher-failure");
     }
@@ -280,7 +255,6 @@ impl FilesystemResponses {
             );
         }
         self.active_references.retain(|id| !ids.contains(id));
-        self.emphasis.retain(|id| !ids.contains(id));
         self.queued_references.retain(|id| !ids.contains(id));
         self.frame_causes.retain(|(id, _)| !ids.contains(id));
         self.finish_after_frame.retain(|(id, _)| !ids.contains(id));
diff --git a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
deleted file mode 100644
index 0d05fc9416b..00000000000
--- a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_new_top_commit_frames.snap
+++ /dev/null
@@ -1,16 +0,0 @@
----
-source: gix-tix/src/animation.rs
-expression: "distinct_frames(Emphasis::new(source,\ntarget).expect(\"a new top commit is emphasized\"))"
----
---- frame 0 ---
-444 new commit
-style: bbbbbbbbbbbbbbbbbbbbbbbb
-111 first
-222 second
-333 third
-
---- frame 1 ---
-444 new commit
-111 first
-222 second
-333 third
diff --git a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap b/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap
deleted file mode 100644
index 8fe780ebdce..00000000000
--- a/gix-tix/src/snapshots/gix_tix__animation__tests__filesystem_reword_frames.snap
+++ /dev/null
@@ -1,14 +0,0 @@
----
-source: gix-tix/src/animation.rs
-expression: "distinct_frames(Emphasis::new(source,\ntarget).expect(\"a reword is emphasized\"))"
----
---- frame 0 ---
-333 new title
-style: bbbbbbbbbbbbbbbbbbbbbbbb
-222 unchanged
-
-
-
---- frame 1 ---
-333 new title
-222 unchanged
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index ab2e6debf8e..af63f2e7de4 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -151,13 +151,6 @@ fn index_separator(pane: ChangePane, changes: &Changes) -> Option<usize> {
         .then_some(index)
 }
 
-#[derive(Clone, Debug, Default)]
-pub(crate) struct FrameLayout {
-    pub history: Rect,
-    pub overlays: Vec<Rect>,
-    pub rows: Vec<(gix::ObjectId, u16)>,
-}
-
 fn changes_pane_areas(
     area: Rect,
     max_height: u16,
@@ -321,7 +314,7 @@ pub(crate) fn draw_with_worktree(
     commit_message: Option<&BStr>,
     tree_changes: Option<&Changes>,
     worktree_changes: Option<&Changes>,
-) -> FrameLayout {
+) {
     let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
     let full_body = body;
     let selected_segment = app.selected_is_segment();
@@ -697,14 +690,6 @@ pub(crate) fn draw_with_worktree(
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
 
-    let rows = visible_entries
-        .iter()
-        .enumerate()
-        .filter_map(|(index, entry)| match entry {
-            HistoryEntry::Commit(row_index) => Some((app.rows[*row_index].id, body.y.saturating_add(index as u16))),
-            HistoryEntry::Segment { .. } => None,
-        })
-        .collect();
     for (index, metadata) in metadata.into_iter().enumerate() {
         let lane = lanes.lane(index);
         let y = body.y.saturating_add(index as u16);
@@ -825,7 +810,7 @@ pub(crate) fn draw_with_worktree(
         }
         if conflict {
             frame.render_widget(
-                Paragraph::new("💥").style(color(Color::LightRed).add_modifier(Modifier::SLOW_BLINK)),
+                Paragraph::new("💥").style(color(Color::LightRed)),
                 Rect::new(
                     body.x
                         .saturating_add(enrichment_gutter)
@@ -1363,19 +1348,9 @@ pub(crate) fn draw_with_worktree(
             render_undo_progress(frame, area, notice.kind, applied, total);
         }
     }
-    let prefix_popup_area = prefix_popup
+    let _ = prefix_popup
         .filter(|_| prefix_popup_allowed)
         .and_then(|(anchor, items)| render_prefix_popup(frame, footer, anchor, items));
-    FrameLayout {
-        history: body,
-        overlays: changes_pane_underlays
-            .into_iter()
-            .chain(commit_pane.map(|(outer, _)| outer))
-            .chain(notice_area)
-            .chain(prefix_popup_area)
-            .collect(),
-        rows,
-    }
 }
 
 fn render_undo_progress(frame: &mut Frame<'_>, area: Rect, kind: NoticeKind, applied: usize, total: usize) {
@@ -2820,10 +2795,9 @@ mod tests {
         app.update(Action::ToggleInformation);
         app.show_undo_position(1, 4, "reword commit");
         let mut terminal = Terminal::new(TestBackend::new(80, 5))?;
-        let mut layout = None;
 
         terminal.draw(|frame| {
-            layout = Some(super::draw_with_worktree(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
@@ -2831,12 +2805,9 @@ mod tests {
                 None,
                 None,
                 None,
-            ));
+            );
         })?;
 
-        let layout = layout.as_ref().expect("drawing returns its layout");
-        assert_eq!(layout.history.x, 0, "undo progress does not shift history");
-        assert_eq!(layout.history.width, 80, "history retains the complete width");
         let notice_y = (0..4)
             .find(|y| rendered_line(&terminal, *y).contains("reword commit · 1 undo · 3 redo"))
             .expect("the undo message is visible");
@@ -3244,9 +3215,8 @@ mod tests {
         );
 
         app.information_expanded = true;
-        let mut layout = None;
         terminal.draw(|frame| {
-            layout = Some(super::draw_with_worktree(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
@@ -3254,18 +3224,13 @@ mod tests {
                 None,
                 None,
                 None,
-            ));
+            );
         })?;
         assert!(rendered_line(&terminal, 0).trim_start().starts_with("REBASE PAUSED"));
         assert!(
             rendered_line(&terminal, 1).contains("[ title"),
             "the popup keeps its footer-adjacent row"
         );
-        assert_eq!(
-            layout.expect("drawing returns its layout").history.height,
-            1,
-            "moving the notice leaves history geometry unchanged"
-        );
         app.information_expanded = false;
 
         app.update(Action::MoveDown);
@@ -4170,10 +4135,9 @@ mod tests {
         app.configure_hidden_filter(true);
         app.history_display_expanded = true;
         let mut terminal = Terminal::new(TestBackend::new(180, 2))?;
-        let mut layout = None;
 
         terminal.draw(|frame| {
-            layout = Some(super::draw_with_worktree(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
@@ -4181,7 +4145,7 @@ mod tests {
                 None,
                 None,
                 None,
-            ));
+            );
         })?;
 
         let footer = rendered_line(&terminal, 1);
@@ -4205,13 +4169,6 @@ mod tests {
         );
         assert_reversed_group(&terminal, 1, "view");
         assert_reversed_group(&terminal, 0, &format!(" {view} "));
-        let popup_area = Rect::new(view_x, 0, Line::raw(format!(" {view} ")).width() as u16, 1);
-        let layout = layout.expect("drawing returns its layout");
-        assert_eq!(layout.history.height, 1, "the popout does not reserve history space");
-        assert!(
-            layout.overlays.contains(&popup_area),
-            "animation treats the floating menu as an overlay"
-        );
 
         app.history_display_expanded = false;
         app.commit_expanded = true;
@@ -5101,10 +5058,10 @@ mod tests {
         );
         assert_eq!(terminal.backend().buffer()[(6, 0)].fg, Color::LightRed);
         assert!(
-            terminal.backend().buffer()[(6, 0)]
+            !terminal.backend().buffer()[(6, 0)]
                 .modifier
                 .contains(Modifier::SLOW_BLINK),
-            "the conflict marker remains visually urgent"
+            "the conflict marker remains steady"
         );
 
         terminal.draw(|frame| {
@@ -5468,10 +5425,9 @@ mod tests {
             ..Changes::default()
         };
         let mut terminal = Terminal::new(TestBackend::new(120, 6))?;
-        let mut layout = None;
 
         terminal.draw(|frame| {
-            layout = Some(super::draw_with_worktree(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
@@ -5479,30 +5435,12 @@ mod tests {
                 None,
                 Some(&changes),
                 None,
-            ));
+            );
         })?;
 
         assert!(rendered_line(&terminal, 3).contains("diff: failed deliberately"));
         assert_eq!(terminal.backend().buffer()[(2, 3)].bg, PANE_STATUS_BACKGROUND);
         assert!(rendered_line(&terminal, 4).contains("[ title"));
-        let layout = layout.expect("drawing returns its layout");
-        assert_eq!(
-            layout.history.height, 5,
-            "moving the changes pane leaves history geometry unchanged"
-        );
-        let popup = layout
-            .overlays
-            .iter()
-            .copied()
-            .find(|area| area.y == 4 && area.height == 1)
-            .expect("the popup is a one-line overlay above the footer");
-        assert!(popup.width < 120, "the popup leaves pane underlay visible on its row");
-        assert!(
-            (0..popup.x)
-                .chain(popup.right()..120)
-                .all(|x| terminal.backend().buffer()[(x, popup.y)].symbol() == " "),
-            "the grown changes pane keeps history covered beneath the floating popup"
-        );
         Ok(())
     }
 
@@ -5805,28 +5743,6 @@ mod tests {
         );
         assert!(!rendered_line(&terminal, 15).contains("<tab> switch"));
 
-        app.changes_suppressed = true;
-        app.information_expanded = true;
-        terminal.draw(|frame| {
-            super::draw(
-                frame,
-                &mut app,
-                &Decorations::new(),
-                &gix::mailmap::Snapshot::default(),
-                None,
-                Some(&changes),
-            );
-        })?;
-        assert!(
-            !rendered_line(&terminal, 7).contains("files changed"),
-            "repeated history navigation temporarily hides the changes pane"
-        );
-        assert!(
-            app.changes_mode.is_some() && !popup_is_dim(&terminal, "changes"),
-            "temporary suppression leaves the persistent changes setting enabled"
-        );
-        app.changes_suppressed = false;
-
         app.update(Action::ToggleChangesFocus);
         app.update(Action::MoveDown);
         terminal.draw(|frame| {
@@ -6409,9 +6325,8 @@ mod tests {
         app.leave_success(
             "success success success success success success success success success success success success",
         );
-        let mut notice_layout = None;
         terminal.draw(|frame| {
-            notice_layout = Some(super::draw_with_worktree(
+            super::draw_with_worktree(
                 frame,
                 &mut app,
                 &Decorations::new(),
@@ -6419,9 +6334,8 @@ mod tests {
                 None,
                 Some(&tree),
                 Some(&worktree),
-            ));
+            );
         })?;
-        let notice = Rect::new(62, 4, 56, 2);
         assert_eq!(terminal.backend().buffer()[(62, 4)].bg, Color::Green);
         assert_eq!(
             terminal.backend().buffer()[(60, 4)].bg,
@@ -6433,13 +6347,6 @@ mod tests {
             Color::Reset,
             "the footer is never covered"
         );
-        assert!(
-            notice_layout
-                .expect("drawing returns its layout")
-                .overlays
-                .contains(&notice),
-            "animation treats the wrapped notice as reserved space"
-        );
         Ok(())
     }
 
@@ -7228,12 +7135,11 @@ mod tests {
         app.show_commit = true;
 
         let mut terminal = Terminal::new(TestBackend::new(80, 3))?;
-        let mut layout = None;
         let decorations = Decorations::new();
         let mailmap = gix::mailmap::Snapshot::default();
         let stale_tree_changes = Changes::default();
         terminal.draw(|frame| {
-            layout = Some(draw_with_worktree(
+            draw_with_worktree(
                 frame,
                 &mut app,
                 &decorations,
@@ -7241,7 +7147,7 @@ mod tests {
                 Some(BStr::new(b"stale commit message")),
                 Some(&stale_tree_changes),
                 None,
-            ));
+            );
         })?;
 
         assert!(
@@ -7263,16 +7169,10 @@ mod tests {
         for hidden in [" · commit", " · actions", " · enrich", " · copy"] {
             assert!(!footer.contains(hidden), "synthetic selection hides {hidden:?}");
         }
-        let layout = layout.expect("drawing returns its layout");
         assert!(
-            layout.overlays.is_empty(),
+            (0..3).all(|y| !rendered_line(&terminal, y).contains("stale commit message")),
             "stale commit-message and tree-change panes stay hidden"
         );
-        assert_eq!(
-            layout.rows,
-            vec![(ids[0], 0)],
-            "a selectable summary still has no commit identity for animation"
-        );
         Ok(())
     }
 

From a3adfe43f8b7d39bdaeae8961949d979d813f545 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 05:24:52 +0200
Subject: [PATCH 252/282] feat: add tix admin clear-undo
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Expose the existing atomic undo-reference cleanup for recovery when the worktree-local queue should be discarded without replaying it.

Delete only this worktree’s tip and cursor refs. Repeated calls are no-ops; recorded refs and other worktrees remain untouched.
---
 gix-tix/spec.md          |  3 ++
 gix-tix/src/command.rs   | 93 ++++++++++++++++++++++++++++++++++++++++
 gix-tix/src/edit/undo.rs |  2 +-
 3 files changed, 97 insertions(+), 1 deletion(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 15a438a7ca9..ada43945781 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -41,6 +41,9 @@ without trading responsiveness for metadata that is not visible.
   then exits with an error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state in a gix stash associated with
   the `HEAD` commit through the same commit-stash operation as the TUI.
+- `tix admin clear-undo` atomically and idempotently deletes the current
+  worktree's undo and redo queue. It does not apply or reverse queued operations,
+  change their recorded references, or affect another worktree's queue.
 - `tix enrich commit todo [--clear] [REVSPEC]`, `tix enrich commit note
   [REVSPEC]`, `tix enrich commit git-note [REVSPEC]`, and `tix enrich tree
   checks-pass [--clear] [REVSPEC]` expose the TUI's enrichment actions without
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index c0fb0a36b83..ef5e3d6511e 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -38,6 +38,9 @@ enum Command {
     /// Print the complete history view without opening the terminal UI.
     #[command(visible_alias = "status")]
     Show(Show),
+    /// Perform repository maintenance.
+    #[command(subcommand)]
+    Admin(Admin),
     /// Manage commit and tree enrichments.
     #[command(subcommand)]
     Enrich(enrich::Command),
@@ -62,6 +65,12 @@ enum Command {
     Rebase(rebase::Command),
 }
 
+#[derive(Debug, clap::Subcommand)]
+enum Admin {
+    /// Clear this worktree's undo and redo history.
+    ClearUndo,
+}
+
 #[derive(Debug, clap::Args)]
 struct RefTree {
     /// Omit tags as labels, traversal tips, and topology anchors.
@@ -188,6 +197,7 @@ impl Platform {
                 println!("{}", notice_with_change_id(&repository, &notice, id)?);
             }
             Command::Pin(args) => pin(&repository, args)?,
+            Command::Admin(Admin::ClearUndo) => crate::edit::undo::clear(&repository)?,
             Command::Travel(args) => return travel::run(repository, args),
             Command::Reword(args) => return reword::run(repository, args),
             Command::New(args) => return new::run(repository, args),
@@ -821,6 +831,13 @@ mod tests {
                 .command,
             Some(Command::Stash)
         ));
+        assert!(matches!(
+            Cli::try_parse_from(["tix", "admin", "clear-undo"])
+                .expect("clear-undo parses")
+                .platform
+                .command,
+            Some(Command::Admin(Admin::ClearUndo))
+        ));
         let pin = Cli::try_parse_from(["tix", "pin", "main", "HEAD~2"])
             .expect("one or more pin revisions parse")
             .platform
@@ -1100,6 +1117,8 @@ mod tests {
             &["pin"],
             &["travel"],
             &["reword"],
+            &["admin"],
+            &["admin", "clear-undo"],
             &["enrich"],
             &["enrich", "commit"],
             &["enrich", "commit", "todo"],
@@ -1146,6 +1165,80 @@ mod tests {
         assert_eq!(cli.platform.revisions, ["amend"]);
     }
 
+    #[test]
+    fn clear_undo_is_worktree_local_and_idempotent() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let linked = gix_testtools::tempfile::tempdir()?;
+        let linked_path = linked.path().join("linked");
+        assert!(
+            ProcessCommand::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["worktree", "add", "-q", "--detach"])
+                .arg(&linked_path)
+                .arg("topic")
+                .status()?
+                .success(),
+            "git creates the linked worktree"
+        );
+        let main = crate::test_repository::open(fixture.path())?;
+        let linked = crate::test_repository::open(&linked_path)?;
+        let retained_ref: gix::refs::FullName = "refs/worktree/tix/admin-clear-test"
+            .try_into()
+            .expect("valid worktree reference");
+        for repository in [&main, &linked] {
+            let id = repository.head_id()?.detach();
+            repository.reference(
+                retained_ref.clone(),
+                id,
+                gix::refs::transaction::PreviousValue::MustNotExist,
+                "test clear-undo",
+            )?;
+            crate::edit::undo::record(
+                repository,
+                "create test ref",
+                &[crate::edit::undo::RefChange {
+                    name: retained_ref.clone(),
+                    before: crate::edit::undo::State::Missing,
+                    after: crate::edit::undo::State::Object(id),
+                }],
+            )?;
+        }
+        let main_position = crate::edit::undo::position(&main)?;
+        let linked_target = linked.find_reference(retained_ref.as_ref())?.id().detach();
+
+        Platform {
+            quit_on_finish: false,
+            hide: Vec::new(),
+            command: Some(Command::Admin(Admin::ClearUndo)),
+            revisions: Vec::new(),
+        }
+        .run(linked.into_sync())?;
+
+        let linked = crate::test_repository::open(&linked_path)?;
+        assert!(linked.try_find_reference(crate::edit::undo::TIP_REF)?.is_none());
+        assert!(linked.try_find_reference(crate::edit::undo::CURSOR_REF)?.is_none());
+        assert_eq!(
+            linked.find_reference(retained_ref.as_ref())?.id().detach(),
+            linked_target,
+            "clearing history does not apply or reverse a recorded operation"
+        );
+        assert_eq!(
+            crate::edit::undo::position(&main)?,
+            main_position,
+            "another worktree keeps its private queue"
+        );
+
+        Platform {
+            quit_on_finish: false,
+            hide: Vec::new(),
+            command: Some(Command::Admin(Admin::ClearUndo)),
+            revisions: Vec::new(),
+        }
+        .run(linked.into_sync())?;
+        Ok(())
+    }
+
     #[test]
     fn pin_follows_direct_references_and_keeps_derived_revisions_fixed() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
diff --git a/gix-tix/src/edit/undo.rs b/gix-tix/src/edit/undo.rs
index 7d21e7fa89d..50e80447aca 100644
--- a/gix-tix/src/edit/undo.rs
+++ b/gix-tix/src/edit/undo.rs
@@ -192,7 +192,7 @@ pub(crate) fn clear(repo: &gix::Repository) -> Result<()> {
         return Ok(());
     }
     repo.edit_references(edits)
-        .context("could not clear undo history for review")
+        .context("could not clear undo history")
         .map(|_| ())
 }
 

From 905dbc10fcb9c220d125806911f989288e747848 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 06:41:27 +0200
Subject: [PATCH 253/282] feat(gix-tix): add copy-insert command

---
 gix-tix/spec.md               |  24 ++-
 gix-tix/src/command.rs        | 332 ++++++++++++++++++++++++++++++++++
 gix-tix/src/command/rebase.rs | 122 +++++++------
 gix-tix/src/edit/rebase.rs    |   3 -
 4 files changed, 416 insertions(+), 65 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ada43945781..731e5b5c3e8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -41,6 +41,13 @@ without trading responsiveness for metadata that is not visible.
   then exits with an error so resolution cannot be mistaken for completion.
 - `tix stash` saves the index and worktree state in a gix stash associated with
   the `HEAD` commit through the same commit-stash operation as the TUI.
+- `tix copy-insert [--materialize-conflicts [CONTINUE]] C I` exposes the TUI
+  copy-insert action without opening it.
+  Both operands accept Git revisions or unambiguous reverse-hex change-ID
+  prefixes from the default Tix view; `C` is the commit to copy and `I` is the
+  commit above which the copy is inserted. A conflict aborts without changing
+  repository state unless explicitly materialized into the ordinary rebase
+  continuation workflow.
 - `tix admin clear-undo` atomically and idempotently deletes the current
   worktree's undo and redo queue. It does not apply or reverse queued operations,
   change their recorded references, or affect another worktree's queue.
@@ -1059,15 +1066,16 @@ space first; changes blocks adapt within the remaining history width.
   target it applies immediately; otherwise navigation is limited to eligible ancestors, `<enter>` confirms,
   and Escape cancels. A non-adjacent source is folded next to the target while intervening commits and sibling
   forks remain above the combined result. Squash uses the history-todo rebase, conflict, and continuation rules.
-- Copy-insert requires a non-root, single-parent `HEAD` that is not an active
-  review commit. It inserts another occurrence of its change above the selected
+- Copy-insert requires a non-root, single-parent source that is not an active
+  review commit. `a y` copies current `HEAD`; `tix copy-insert C I` accepts any
+  resolvable source `C`. It inserts another occurrence of its change above the
   target without removing the source occurrence, including when the target is
-  the source's current parent. The new copy becomes detached `HEAD`; an attached
-  source branch remains visible through the ordinary HEAD pin. If the target is
-  an ancestor of the source, that source occurrence is retained in its original
-  logical position while its branch follows the necessary rewrite. Git notes are
-  copied to the new occurrence. Copy-insert uses the history-todo conflict and
-  continuation rules.
+  the source's current parent. The new copy becomes detached `HEAD`; the branch
+  checked out before the operation remains visible through the ordinary HEAD
+  pin. If the target is an ancestor of the source, that source occurrence is
+  retained in its original logical position while its branch follows the
+  necessary rewrite. Git notes are copied to the new occurrence. Copy-insert
+  uses the history-todo conflict and continuation rules.
 - Move-insert requires a non-root, single-parent `HEAD`. It removes `HEAD` from
   its old position, reconnects its former children to its parent, inserts its
   rewritten change above the selected target, and reparents every former direct
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index ef5e3d6511e..a2801c5b1cc 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -2,6 +2,7 @@ use std::{
     collections::HashSet,
     ffi::{OsStr, OsString},
     io::Write,
+    path::PathBuf,
     sync::atomic::AtomicBool,
 };
 
@@ -54,6 +55,8 @@ enum Command {
     Stash,
     /// Pin one or more commits as persistent history tips.
     Pin(Pin),
+    /// Copy the change introduced by one commit above another commit.
+    CopyInsert(CopyInsert),
     /// Travel to a commit while preserving reachable history through tix pins.
     Travel(travel::Args),
     /// Edit a commit and lazily rebase every descendant retained by a tix pin.
@@ -124,6 +127,28 @@ struct Pin {
     revisions: Vec<OsString>,
 }
 
+#[derive(Debug, clap::Args)]
+#[command(
+    after_long_help = "Conflicts change nothing by default. To materialize one and write a continuation todo:\n  tix copy-insert --materialize-conflicts=todo.continue.md C I\nResolve the index, then run:\n  tix rebase apply todo.continue.md\nUse --materialize-conflicts=- to write a continuation to non-terminal stdout."
+)]
+struct CopyInsert {
+    /// On conflict, materialize it and write a continuation todo to FILE, or stdout if omitted or '-'.
+    #[arg(
+        long,
+        value_name = "CONTINUE",
+        num_args = 0..=1,
+        default_missing_value = "-",
+        require_equals = true
+    )]
+    materialize_conflicts: Option<PathBuf>,
+    /// Revision resolving to the commit to copy.
+    #[arg(value_name = "SOURCE")]
+    source: OsString,
+    /// Revision resolving to the commit above which to insert the copy.
+    #[arg(value_name = "TARGET")]
+    target: OsString,
+}
+
 #[derive(Debug, clap::Parser)]
 #[command(
     name = "tix",
@@ -197,6 +222,7 @@ impl Platform {
                 println!("{}", notice_with_change_id(&repository, &notice, id)?);
             }
             Command::Pin(args) => pin(&repository, args)?,
+            Command::CopyInsert(args) => return copy_insert(repository, args),
             Command::Admin(Admin::ClearUndo) => crate::edit::undo::clear(&repository)?,
             Command::Travel(args) => return travel::run(repository, args),
             Command::Reword(args) => return reword::run(repository, args),
@@ -448,6 +474,45 @@ fn resolve_commit(
     }
 }
 
+fn copy_insert(repository: gix::Repository, args: CopyInsert) -> Result<()> {
+    repository.workdir().context("copy-insert requires a worktree")?;
+    let (source, _) = resolve_commit(&repository, &args.source, "copy source")?;
+    let (target, _) = resolve_commit(&repository, &args.target, "copy target")?;
+    let revisions = [
+        OsString::from("HEAD"),
+        OsString::from(source.to_string()),
+        OsString::from(target.to_string()),
+    ];
+    let graph = crate::edit::loaded_view_graph_with(&repository, &revisions)?;
+    let plan = crate::edit::rebase::copy_insert_plan(&repository, &graph, source, target)?;
+    let repository_path = repository.git_dir().to_owned();
+    let bare = repository.is_bare();
+    match crate::edit::rebase::perform_plan(&repository, &graph, plan)? {
+        crate::edit::rebase::PlanPerform::Complete(outcome) => {
+            let copied = outcome.selected.context("copy-insert did not produce a selection")?;
+            let (_, changes) =
+                match crate::edit::time_travel::checkout_plan_reporting(&repository_path, bare, &outcome, &[], false) {
+                    Ok(result) => result,
+                    Err(err) => {
+                        record_undo(&repository, "copy-insert commit", Ok(outcome.ref_changes));
+                        return Err(err).context("copy-insert applied, but could not check out the copied commit");
+                    }
+                };
+            println!("{}", crate::change_id::display(&repository, copied, 7)?);
+            print_ref_rewrites(&repository, &outcome.ref_rewrites)?;
+            record_undo(&repository, "copy-insert commit", Ok(changes));
+            Ok(())
+        }
+        crate::edit::rebase::PlanPerform::Conflict(conflict) => rebase::handle_plan_conflict(
+            &repository,
+            conflict,
+            args.materialize_conflicts.as_deref(),
+            &[],
+            "copy-insert",
+        ),
+    }
+}
+
 fn pin(repository: &gix::Repository, args: Pin) -> Result<()> {
     let pins = create_pins(repository, &args.revisions)?;
     for (pin, _created) in &pins {
@@ -846,6 +911,31 @@ mod tests {
             panic!("pin was expected")
         };
         assert_eq!(pin.revisions, ["main", "HEAD~2"]);
+        let copy_insert = Cli::try_parse_from([
+            "tix",
+            "copy-insert",
+            "--materialize-conflicts=continue.md",
+            "main",
+            "HEAD~1",
+        ])
+        .expect("copy-insert parses")
+        .platform
+        .command;
+        let Some(Command::CopyInsert(copy_insert)) = copy_insert else {
+            panic!("copy-insert was expected")
+        };
+        assert_eq!(copy_insert.source, "main");
+        assert_eq!(copy_insert.target, "HEAD~1");
+        assert_eq!(copy_insert.materialize_conflicts, Some("continue.md".into()));
+        let Some(Command::CopyInsert(copy_insert)) =
+            Cli::try_parse_from(["tix", "copy-insert", "--materialize-conflicts", "HEAD", "main~1"])
+                .expect("copy-insert defaults continuation output to stdout")
+                .platform
+                .command
+        else {
+            panic!("copy-insert was expected")
+        };
+        assert_eq!(copy_insert.materialize_conflicts, Some("-".into()));
         let travel = Cli::try_parse_from(["tix", "travel", "--materialize-conflicts", "HEAD~1"])
             .expect("travel parses")
             .platform
@@ -1047,6 +1137,247 @@ mod tests {
         );
     }
 
+    #[test]
+    fn copy_insert_command_rewrites_the_target_stack_and_is_undoable() -> gix_testtools::Result {
+        fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
+            let output = ProcessCommand::new("git").arg("-C").arg(path).args(args).output()?;
+            if !output.status.success() {
+                return Err(format!(
+                    "git {} failed: {}",
+                    args.join(" "),
+                    String::from_utf8_lossy(&output.stderr)
+                )
+                .into());
+            }
+            Ok(output.stdout)
+        }
+
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        git(path, &["checkout", "-q", "-b", "destination", "HEAD~2"])?;
+        std::fs::write(path.join("destination"), b"target\n")?;
+        git(path, &["add", "destination"])?;
+        git(path, &["commit", "-q", "-m", "destination target"])?;
+        let target = crate::test_repository::open(path)?.head_id()?.detach();
+        std::fs::write(path.join("destination-child"), b"child\n")?;
+        git(path, &["add", "destination-child"])?;
+        git(path, &["commit", "-q", "-m", "destination child"])?;
+        let destination_before = crate::test_repository::open(path)?.head_id()?.detach();
+        git(path, &["checkout", "-q", "-b", "excluded", &target.to_string()])?;
+        std::fs::write(path.join("excluded"), b"excluded\n")?;
+        git(path, &["add", "excluded"])?;
+        git(path, &["commit", "-q", "-m", "excluded child"])?;
+        let excluded_before = crate::test_repository::open(path)?.head_id()?.detach();
+        git(path, &["checkout", "-q", "destination"])?;
+
+        let repository = crate::test_repository::open(path)?;
+        let source = repository.rev_parse_single("main")?.detach();
+        copy_insert(
+            repository,
+            CopyInsert {
+                materialize_conflicts: None,
+                source: "main".into(),
+                target: target.to_string().into(),
+            },
+        )?;
+
+        let repository = crate::test_repository::open(path)?;
+        let copied = repository.head_id()?.detach();
+        assert!(repository.head()?.is_detached(), "the new copy is checked out detached");
+        assert_eq!(
+            repository.find_reference("refs/heads/main")?.id().detach(),
+            source,
+            "the source branch remains at the original occurrence"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/excluded")?.id().detach(),
+            excluded_before,
+            "an unpinned branch outside the command view is not rewritten"
+        );
+        assert_eq!(
+            repository.find_commit(copied)?.parent_ids().next().map(gix::Id::detach),
+            Some(target),
+            "the copy is inserted immediately above the target"
+        );
+        let destination_after = repository.find_reference("refs/heads/destination")?.id().detach();
+        assert_ne!(
+            destination_after, destination_before,
+            "the target descendant is rewritten"
+        );
+        assert_eq!(
+            repository
+                .find_commit(destination_after)?
+                .parent_ids()
+                .next()
+                .map(gix::Id::detach),
+            Some(copied),
+            "the rewritten descendant follows the copy"
+        );
+        assert_eq!(
+            crate::edit::undo::position(&repository)?.title,
+            "copy-insert commit",
+            "the command records one undoable operation"
+        );
+        let pins = crate::history::all_pins(&repository)?;
+        assert_eq!(pins.len(), 1, "the previous checkout receives one HEAD pin");
+        assert_eq!(
+            pins[0].target.try_name().map(gix::refs::FullNameRef::as_bstr),
+            Some(gix::bstr::BStr::new(b"refs/heads/destination")),
+            "the HEAD pin remembers the destination branch"
+        );
+
+        crate::edit::undo::plan_undo(&repository)?
+            .context("copy-insert can be undone")?
+            .apply(&repository)?;
+        let repository = crate::test_repository::open(path)?;
+        assert_eq!(
+            repository.head_id()?.detach(),
+            destination_before,
+            "undo restores the previous checkout"
+        );
+        assert_eq!(
+            repository.head()?.referent_name().map(ToOwned::to_owned),
+            Some("refs/heads/destination".try_into().expect("valid branch name")),
+            "undo reattaches HEAD"
+        );
+        assert_eq!(
+            repository.find_reference("refs/heads/destination")?.id().detach(),
+            destination_before,
+            "undo restores the target branch"
+        );
+        assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), source);
+        assert_eq!(
+            repository.find_reference("refs/heads/excluded")?.id().detach(),
+            excluded_before
+        );
+        assert!(
+            crate::history::all_pins(&repository)?.is_empty(),
+            "undo removes the checkout pin"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn copy_insert_conflicts_are_atomic_or_materialize_a_continuation() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let path = fixture.path();
+        let repository = crate::test_repository::open(path)?;
+        let source = repository.head_id()?.detach();
+        let target = repository.rev_parse_single("HEAD~2")?.detach();
+        let before = gix_testtools::repository::snapshot(path)?;
+        let err = copy_insert(
+            repository,
+            CopyInsert {
+                materialize_conflicts: None,
+                source: source.to_string().into(),
+                target: target.to_string().into(),
+            },
+        )
+        .expect_err("copy-insert conflicts are atomic by default");
+        assert!(format!("{err:#}").contains("pass --materialize-conflicts"));
+        assert_eq!(
+            gix_testtools::repository::snapshot(path)?,
+            before,
+            "the default conflict leaves the repository unchanged"
+        );
+
+        let output_dir = gix_testtools::tempfile::tempdir()?;
+        let continuation = output_dir.path().join("continue.md");
+        let repository = crate::test_repository::open(path)?;
+        let err = copy_insert(
+            repository,
+            CopyInsert {
+                materialize_conflicts: Some(continuation.clone()),
+                source: source.to_string().into(),
+                target: target.to_string().into(),
+            },
+        )
+        .expect_err("materializing a conflict exits unsuccessfully");
+        assert!(format!("{err:#}").contains("copy-insert stopped at a materialized conflict"));
+        let document = std::fs::read(&continuation)?;
+        let repository = crate::test_repository::open(path)?;
+        assert!(
+            crate::edit::todo::parse(&repository, &document)?.is_some(),
+            "the continuation is accepted by the ordinary rebase parser"
+        );
+        assert_eq!(
+            crate::edit::undo::position(&repository)?.title,
+            "materialize rebase conflict",
+            "materialization is independently undoable"
+        );
+        let unresolved = ProcessCommand::new("git")
+            .arg("-C")
+            .arg(path)
+            .args(["diff", "--name-only", "--diff-filter=U"])
+            .output()?;
+        assert!(unresolved.status.success());
+        assert_eq!(
+            unresolved.stdout, b"file\n",
+            "materialization writes the unmerged index"
+        );
+
+        std::fs::write(path.join("file"), b"base\n")?;
+        assert!(
+            ProcessCommand::new("git")
+                .arg("-C")
+                .arg(path)
+                .args(["add", "file"])
+                .status()?
+                .success()
+        );
+        rebase::run(
+            crate::test_repository::open(path)?,
+            rebase::Command::Apply(rebase::Apply {
+                materialize_conflicts: None,
+                file: Some(continuation),
+            }),
+        )?;
+        let unresolved = ProcessCommand::new("git")
+            .arg("-C")
+            .arg(path)
+            .args(["diff", "--name-only", "--diff-filter=U"])
+            .output()?;
+        assert!(unresolved.status.success());
+        assert!(
+            unresolved.stdout.is_empty(),
+            "the continuation consumes the resolved index"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn copy_insert_rejects_a_bare_repository_before_rewriting_it() -> gix_testtools::Result {
+        let source = gix_testtools::scripted_fixture_read_only("rebase_edit.sh")?;
+        let fixture = gix_testtools::tempfile::tempdir()?;
+        assert!(
+            ProcessCommand::new("git")
+                .args(["clone", "-q", "--bare"])
+                .arg(source)
+                .arg(fixture.path())
+                .status()?
+                .success()
+        );
+        let repository = crate::test_repository::open(fixture.path())?;
+        let before = repository.head_id()?.detach();
+        let target = repository.rev_parse_single("HEAD~2")?.detach();
+        let err = copy_insert(
+            repository,
+            CopyInsert {
+                materialize_conflicts: None,
+                source: before.to_string().into(),
+                target: target.to_string().into(),
+            },
+        )
+        .expect_err("copy-insert requires a checkout");
+        assert!(format!("{err:#}").contains("requires a worktree"));
+        assert_eq!(
+            crate::test_repository::open(fixture.path())?.head_id()?.detach(),
+            before,
+            "the attached branch is unchanged"
+        );
+        Ok(())
+    }
+
     #[test]
     fn ref_tree_omits_explicit_and_inferred_hidden_references() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
@@ -1115,6 +1446,7 @@ mod tests {
             &["split"],
             &["stash"],
             &["pin"],
+            &["copy-insert"],
             &["travel"],
             &["reword"],
             &["admin"],
diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index ee519a989ed..0b62d6aff75 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -236,63 +236,77 @@ fn apply_document(repo: gix::Repository, document: &[u8], materialize_conflicts:
             super::record_undo(&repo, "rebase history", Ok(changes));
             Ok(())
         }
-        rebase::PlanPerform::Conflict(mut conflict) => {
-            let Some(destination) = materialize_conflicts else {
-                anyhow::bail!(
-                    "rebase aborted without changes: conflict while applying {}; pass --materialize-conflicts to opt in",
-                    conflict.original().to_hex_with_len(7)
-                );
-            };
-            if destination == Path::new("-") && std::io::stdout().is_terminal() {
-                anyhow::bail!(
-                    "rebase aborted without changes: refusing to materialize a conflict without a continuation output file"
-                );
-            }
-            conflict.persist_objects()?;
-            let plan = conflict.continuation_plan();
-            let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
-            let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips, true)?.document;
-            let revisions = mapped_revisions(&tips, |id| conflict.map(id));
-            if destination == Path::new("-") {
-                let mut stdout = std::io::stdout().lock();
-                stdout
-                    .write_all(&continuation)
-                    .and_then(|_| stdout.flush())
-                    .context("could not write the continuation rebase todo")?;
-            } else {
-                let mut output = std::fs::OpenOptions::new()
-                    .write(true)
-                    .create_new(true)
-                    .open(destination)
-                    .with_context(|| {
-                        format!("could not create continuation rebase todo at {}", destination.display())
-                    })?;
-                output.write_all(&continuation).with_context(|| {
-                    format!("could not write continuation rebase todo at {}", destination.display())
-                })?;
+        rebase::PlanPerform::Conflict(conflict) => {
+            handle_plan_conflict(&repo, conflict, materialize_conflicts, &tips, "rebase")
+        }
+    }
+}
+
+pub(super) fn handle_plan_conflict(
+    repo: &gix::Repository,
+    mut conflict: rebase::PlanConflict,
+    materialize_conflicts: Option<&Path>,
+    tips: &[ObjectId],
+    operation: &str,
+) -> Result<()> {
+    let Some(destination) = materialize_conflicts else {
+        anyhow::bail!(
+            "{operation} aborted without changes: conflict while applying {}; pass --materialize-conflicts to opt in",
+            conflict.original().to_hex_with_len(7)
+        );
+    };
+    if destination == Path::new("-") && std::io::stdout().is_terminal() {
+        anyhow::bail!(
+            "{operation} aborted without changes: refusing to materialize a conflict without a continuation output file"
+        );
+    }
+    conflict.persist_objects()?;
+    let plan = conflict.continuation_plan();
+    let mapped_tips = tips.iter().filter_map(|id| conflict.map(*id)).collect();
+    let continuation = todo::prepare_continuation(conflict.repository(), &plan, mapped_tips, true)?.document;
+    let revisions = mapped_revisions(tips, |id| conflict.map(id));
+    if destination == Path::new("-") {
+        let mut stdout = std::io::stdout().lock();
+        stdout
+            .write_all(&continuation)
+            .and_then(|_| stdout.flush())
+            .context("could not write the continuation rebase todo")?;
+    } else {
+        let mut output = std::fs::OpenOptions::new()
+            .write(true)
+            .create_new(true)
+            .open(destination)
+            .with_context(|| format!("could not create continuation rebase todo at {}", destination.display()))?;
+        output
+            .write_all(&continuation)
+            .with_context(|| format!("could not write continuation rebase todo at {}", destination.display()))?;
+    }
+    let materialized = edit::time_travel::materialize_plan_conflict_reporting(
+        conflict,
+        repo.git_dir(),
+        repo.is_bare(),
+        &revisions,
+        false,
+    );
+    let (notice, _, ref_rewrites, ref_changes) = match materialized {
+        Ok(materialized) => materialized,
+        Err(err) => {
+            if destination != Path::new("-") {
+                let _ = std::fs::remove_file(destination);
             }
-            let materialized = edit::time_travel::materialize_plan_conflict_reporting(
-                conflict,
-                &repository_path,
-                bare,
-                &revisions,
-                false,
-            );
-            let (notice, _, ref_rewrites, ref_changes) = match materialized {
-                Ok(materialized) => materialized,
-                Err(err) => {
-                    if destination != Path::new("-") {
-                        let _ = std::fs::remove_file(destination);
-                    }
-                    return Err(err);
-                }
-            };
-            super::print_ref_rewrites(&repo, &ref_rewrites)?;
-            super::record_undo(&repo, "materialize rebase conflict", Ok(ref_changes));
-            eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
-            anyhow::bail!("rebase stopped at a materialized conflict")
+            return Err(err);
         }
+    };
+    if destination == Path::new("-") {
+        for line in super::ref_rewrite_lines(repo, &ref_rewrites)? {
+            eprintln!("{line}");
+        }
+    } else {
+        super::print_ref_rewrites(repo, &ref_rewrites)?;
     }
+    super::record_undo(repo, "materialize rebase conflict", Ok(ref_changes));
+    eprintln!("{notice}; continue with `tix rebase apply {}`", destination.display());
+    anyhow::bail!("{operation} stopped at a materialized conflict")
 }
 
 fn mapped_revisions(tips: &[ObjectId], mut map: impl FnMut(ObjectId) -> Option<ObjectId>) -> Vec<OsString> {
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index a54d8f4604c..d444b986140 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -545,9 +545,6 @@ pub(crate) fn copy_insert_plan(
     source: ObjectId,
     target: ObjectId,
 ) -> Result<Plan> {
-    if repo.head_id()?.detach() != source {
-        anyhow::bail!("the copy source must be the current HEAD");
-    }
     let source_parents = graph
         .parents_of(source)
         .context("the copy source is not in the loaded history")?;

From 6dd62cce5e36527a65da408ec7ba7ad3f37ee88d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 07:23:32 +0200
Subject: [PATCH 254/282] fix(gix-tix): stop writing after leaving the
 alternate screen

---
 gix-tix/spec.md    | 1 +
 gix-tix/src/lib.rs | 1 +
 2 files changed, 2 insertions(+)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 731e5b5c3e8..631d22a9768 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -138,6 +138,7 @@ without trading responsiveness for metadata that is not visible.
   ignored when another hidden revision resolves; if none resolve, startup fails.
 - The UI always owns the alternate screen. Raw mode, focus reporting, mouse
   capture, and enhanced keyboard reporting are restored on every exit path.
+  Shutdown leaves the alternate screen without clearing it or writing afterward.
 - `Ctrl-C` exits immediately from any normal tix focus. `q` quits from history;
   `q` or `Escape` in a focused changes block returns focus to history.
 
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c8f05080d2b..a53f0ec9a50 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -697,6 +697,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
             )
         });
     let keyboard_restore = disable_input(terminal.backend_mut(), enhanced_keyboard);
+    drop(terminal);
     let restore = ratatui::try_restore().context("could not restore terminal");
     let lane_time = result?;
     keyboard_restore.context("could not restore keyboard events")?;

From fc463b42e41efefc8ac7c0287b4bf5bfbf748a2d Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 07:58:58 +0200
Subject: [PATCH 255/282] fix(gix-tix): call empty tree changes empty

---
 gix-tix/spec.md   |  2 +-
 gix-tix/src/ui.rs | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 631d22a9768..ff8ba648a37 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -589,7 +589,7 @@ space first; changes blocks adapt within the remaining history width.
   the selected short hash; worktree summaries distinguish staged and unstaged
   counts. Kind totals, total files when non-redundant, and non-zero line totals
   are color-coded. Empty enabled Tree and Worktree blocks remain visible, say
-  `clean` in green, and are not focusable.
+  `empty` and `clean` respectively in green, and are not focusable.
 - Tree paths preserve tree-diff order. Worktree paths show staged entries first in
   green and unstaged/untracked/conflicted entries second in bright red, sorted by
   raw path within each group. When both groups exist, a non-selectable `↑ index ↑`
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index af63f2e7de4..52a0f8e2c1c 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -1848,7 +1848,7 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
             );
             let mut spans = vec![Span::raw(format!("─ Tree {label} "))];
             if changes.paths.is_empty() {
-                spans.push(Span::styled("clean", color(Color::Green)));
+                spans.push(Span::styled("empty", color(Color::Green)));
                 spans.push(Span::raw(" "));
             }
             spans.push(Span::raw("── "));
@@ -6161,12 +6161,12 @@ mod tests {
                 Some(&Changes::default()),
             );
         })?;
-        let (clean_y, clean_tree) = (0..12)
+        let (empty_y, empty_tree) = (0..12)
             .map(|y| (y, rendered_line(&terminal, y)))
-            .find(|(_, line)| line.contains("Tree ------- clean"))
-            .expect("an empty tree remains visible and says it is clean");
-        let clean_x = clean_tree.find("clean").expect("clean tree label") as u16;
-        assert_eq!(terminal.backend().buffer()[(clean_x, clean_y)].fg, Color::Green);
+            .find(|(_, line)| line.contains("Tree ------- empty"))
+            .expect("an empty tree remains visible and says it is empty");
+        let empty_x = empty_tree.find("empty").expect("empty tree label") as u16;
+        assert_eq!(terminal.backend().buffer()[(empty_x, empty_y)].fg, Color::Green);
         assert!(!app.tree_changes_visible, "an empty tree block is not focusable");
         Ok(())
     }

From 022b67bdf0017f6f32ad393a3dd328548543d597 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 10:05:46 +0200
Subject: [PATCH 256/282] fix(gix-tix): resolve rewritten checkout conflicts
 eagerly

Replay the affected checkout ancestry before committing history edits so forget, reword, insertion, review completion, and todo rebases surface conflicts immediately while unrelated branches remain lazy.

Keep suspended conflicts transactional, recognize valid external conflict amendments, preserve undo bookkeeping, and leave normal history quit available during resolution.
---
 gix-tix/spec.md                               |  37 +-
 gix-tix/src/command/reword.rs                 |   6 +-
 gix-tix/src/command/travel.rs                 |   4 +-
 gix-tix/src/edit/create.rs                    |  47 +-
 gix-tix/src/edit/forget.rs                    |  53 +-
 gix-tix/src/edit/head.rs                      | 113 ++-
 gix-tix/src/edit/rebase.rs                    | 647 ++++++++++++++++--
 gix-tix/src/edit/review.rs                    |  28 +-
 gix-tix/src/edit/reword.rs                    | 108 ++-
 ...tests__changed-review-with-successors.snap |  20 +-
 gix-tix/src/edit/time_travel.rs               |  29 +-
 gix-tix/src/edit/todo.rs                      |  31 +-
 gix-tix/src/enrich.rs                         |  54 +-
 gix-tix/src/lib.rs                            | 617 +++++++++++++++--
 14 files changed, 1567 insertions(+), 227 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ff8ba648a37..8c724d6735d 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -139,8 +139,12 @@ without trading responsiveness for metadata that is not visible.
 - The UI always owns the alternate screen. Raw mode, focus reporting, mouse
   capture, and enhanced keyboard reporting are restored on every exit path.
   Shutdown leaves the alternate screen without clearing it or writing afterward.
-- `Ctrl-C` exits immediately from any normal tix focus. `q` quits from history;
-  `q` or `Escape` in a focused changes block returns focus to history.
+- `Ctrl-C` exits immediately from any normal tix focus without recovery
+  bookkeeping. `q` always quits from history, including while a conflict or
+  rebase continuation is suspended. Before that normal exit, tix journals
+  already-materialized reference progress and drops only in-memory candidates;
+  it never rolls repository state back. `q` or `Escape` in a focused changes
+  block still returns focus to history.
 
 ## History model
 
@@ -804,6 +808,17 @@ space first; changes blocks adapt within the remaining history width.
 - A checked-out unresolved index keeps `C` at `@`, overrides dirty `🫟`, and
   disables time travel until all conflict stages are resolved. The worktree
   changes block is shown for resolution.
+- Accepting a conflict remembers the materialized commit, HEAD attachment,
+  parents, and accumulated reference changes. If the conflict is resolved and
+  amended outside tix, refresh recognizes completion only when HEAD remains
+  attached the same way, moves to a same-parent replacement, and the
+  conflict-free index exactly matches that replacement's tree. Tix then removes
+  any pending-rebase marker preserved by Git's amend, appends both reference
+  transitions to the same undo operation, and clears the mandatory prompt.
+  Staging a resolution without amending remains incomplete. An unrelated HEAD
+  move stays blocked with a diagnostic and can still be left with normal `q`.
+  Tix's own `<enter>` amend also completes an identical-tree resolution so no
+  pending marker can survive merely because the tree did not change.
 - A materialized todo conflict keeps a high-contrast `REBASE PAUSED` attention notice until
   its in-memory continuation is consumed. The notice changes when the index is
   resolved but always advertises `<enter>` to continue and `Esc` to stop. History,
@@ -894,9 +909,13 @@ space first; changes blocks adapt within the remaining history width.
   become reachable through refs.
 - `Tree::LeaveAsIs` rewrites parentage without changing trees;
   `LeaveAsIsAndMark` writes the original first parent to `tix-rebase-parent` only
-  when later replay needs it; and `CherryPick` transplants each tree delta. User
-  edits use `LeaveAsIsAndMark`; time travel is the only eager `CherryPick` caller.
-  A successful repeated rebase clears the marker through its checkout destination.
+  when later replay needs it; and `CherryPick` transplants each tree delta.
+  Any edit that rewrites the current worktree's checked-out ancestry eagerly
+  cherry-picks that affected path before committing the operation. The edited
+  root of a direct amend or spill already has its final tree and does not receive
+  a redundant worktree transition. Descendants on unrelated branches and in
+  other worktrees remain lazy. A successful repeated rebase clears the marker
+  through its checkout destination.
   On conflict, `tix-rebase-parent` identifies the original base and later descendants
   remain marked instead of being cherry-picked.
 - `Signature::RedoIfNeeded` signs every rewritten commit when signing is
@@ -917,6 +936,10 @@ space first; changes blocks adapt within the remaining history width.
   while awaiting an explicit `<enter>` or `Esc` choice. Dropping it writes nothing;
   accepting it consumes the repository immediately after persisting the commit at
   the ours tree and materializing the retained merge result in the worktree and index.
+  Forget, reword, commit insertion, review finishing, and other shared-rebase
+  callers propagate this same suspended result instead of completing their ref
+  transaction first. Thus a checkout-path conflict is reported by the initiating
+  edit itself, and `Esc` leaves its repository snapshot unchanged.
 
 ### History rebase editor
 
@@ -997,7 +1020,9 @@ space first; changes blocks adapt within the remaining history width.
   still their planned parent retain their IDs. Eager cherry-picking and re-signing
   starts at the first pending or structurally changed commit. Any descendants
   above `@` and other resulting stacks retain their trees, receive pending-rebase
-  markers, and invalidate old signatures for later time travel. With no `@`,
+  markers, and invalidate old signatures for later time travel. With no explicit
+  `@`, the current attached branch's resulting destination is inferred and its
+  ancestry is replayed eagerly; a detached checkout is not inferred. Other
   ordinary steps remain lazy while squash groups are still materialized.
   Any conflict while applying a history todo first remains entirely in memory.
   The TUI projects the partial result, selects and centers the actual conflicting
diff --git a/gix-tix/src/command/reword.rs b/gix-tix/src/command/reword.rs
index bb11e8b10e4..98758217ce1 100644
--- a/gix-tix/src/command/reword.rs
+++ b/gix-tix/src/command/reword.rs
@@ -368,7 +368,7 @@ mod tests {
 
         let repository = crate::test_repository::open(path)?;
         let new_tip = repository.head_id()?.detach();
-        assert_ne!(new_tip, old_tip, "the descendant is lazily reparented");
+        assert_ne!(new_tip, old_tip, "the checked-out descendant is reparented");
         assert_eq!(
             repository
                 .find_commit(new_tip)?
@@ -389,8 +389,8 @@ mod tests {
                 .decode()?
                 .extra_headers()
                 .find("tix-rebase-parent")
-                .is_some(),
-            "the descendant remains marked for lazy replay"
+                .is_none(),
+            "the checked-out descendant is replayed eagerly"
         );
         assert_eq!(
             git(path, &["log", "-1", "--format=%s", "HEAD~1"])?,
diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index a2ef29debfb..b6d7c4080c8 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -585,6 +585,8 @@ mod tests {
         std::fs::write(path.join("after"), "after\n")?;
         git(path, &["add", "after"])?;
         git(path, &["commit", "-q", "-m", "after"])?;
+        let root = repository.rev_parse_single("HEAD~3")?.detach();
+        git(path, &["checkout", "-q", "--detach", &root.to_string()])?;
         let graph = crate::edit::loaded_graph(&repository)?;
         crate::edit::rebase::perform(
             &repository,
@@ -594,10 +596,10 @@ mod tests {
             crate::edit::rebase::Tree::LeaveAsIsAndMark,
         )?
         .complete()?;
-        let root = repository.rev_parse_single("HEAD~2")?.detach();
         let tip = repository.find_reference("refs/heads/main")?.id().detach();
         drop(repository);
 
+        git(path, &["checkout", "-q", "main"])?;
         run(crate::test_repository::open(path)?, args(&root.to_string()))?;
         let before = gix_testtools::repository::snapshot(path)?;
         let err = run(crate::test_repository::open(path)?, args(&tip.to_string()))
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 31711039d43..916e3b82549 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -174,7 +174,7 @@ fn prepare_inner(
     })
 }
 
-pub(super) fn index_tree(repo: &gix::Repository, index: &gix::index::File) -> Result<ObjectId> {
+pub(crate) fn index_tree(repo: &gix::Repository, index: &gix::index::File) -> Result<ObjectId> {
     let mut editor = repo.empty_tree().edit().context("could not prepare the index tree")?;
     for entry in index.entries() {
         let mode = entry
@@ -291,8 +291,17 @@ pub(crate) fn apply_reporting(
     prepared: Prepared,
     edited: &[u8],
 ) -> Result<rebase::Outcome> {
+    apply_conflict_reporting(repo, graph, prepared, edited)?.complete()
+}
+
+pub(crate) fn apply_conflict_reporting(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edited: &[u8],
+) -> Result<rebase::Perform> {
     let edit = commit_from_edit(&prepared, edited)?;
-    apply_commit(repo, graph, prepared, edit)
+    apply_commit_conflict(repo, graph, prepared, edit)
 }
 
 pub(crate) fn apply_message_reporting(
@@ -308,15 +317,22 @@ pub(crate) fn apply_message_reporting(
 }
 
 fn apply_commit(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    prepared: Prepared,
+    edit: (gix::objs::Commit, crate::enrich::Headers),
+) -> Result<rebase::Outcome> {
+    apply_commit_conflict(repo, graph, prepared, edit)?.complete()
+}
+
+fn apply_commit_conflict(
     mut repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     (commit, enrichment): (gix::objs::Commit, crate::enrich::Headers),
-) -> Result<rebase::Outcome> {
-    let repository_path = repo.git_dir().to_owned();
-    let bare = repo.is_bare();
+) -> Result<rebase::Perform> {
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let mut outcome = rebase::perform(
+    let (performed, _) = rebase::perform_with_enrichment(
         &repo,
         graph,
         rebase::Edit::Insert {
@@ -326,22 +342,9 @@ fn apply_commit(
         },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
-    )?
-    .complete()?;
-    let id = outcome
-        .selected
-        .context("inserting a commit did not produce a selection")?;
-    drop(repo);
-    let repo = crate::open_repository(&repository_path, bare, false)?;
-    let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
-    let before = super::undo::state(&repo, name.as_ref())?;
-    crate::enrich::apply_headers(&repo, id, &enrichment)
-        .context("the commit was created, but its enrichment could not be saved")?;
-    let after = super::undo::state(&repo, name.as_ref())?;
-    if before != after {
-        outcome.ref_changes.push(super::undo::RefChange { name, before, after });
-    }
-    Ok(outcome)
+        &enrichment,
+    )?;
+    Ok(performed)
 }
 
 #[tracing::instrument(skip_all, fields(parent = ?prepared.parent))]
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index ed202c1082c..f5b8aec1a7d 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -11,8 +11,43 @@ pub(crate) struct Outcome {
     pub ref_changes: Vec<super::undo::RefChange>,
 }
 
+pub(crate) enum Perform {
+    Complete(Outcome),
+    Conflict(Conflict),
+}
+
+#[cfg(test)]
+impl Perform {
+    fn complete(self) -> Result<Outcome> {
+        match self {
+            Perform::Complete(outcome) => Ok(outcome),
+            Perform::Conflict(_) => anyhow::bail!("forgetting the commit would cause a merge conflict"),
+        }
+    }
+}
+
+pub(crate) struct Conflict {
+    rebase: rebase::Conflict,
+}
+
+impl Conflict {
+    pub(crate) fn into_rebase(self) -> rebase::Conflict {
+        self.rebase
+    }
+}
+
+#[cfg(test)]
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn perform(repo: gix::Repository, graph: &crate::history::HistoryGraph, id: ObjectId) -> Result<Outcome> {
+    perform_conflict(repo, graph, id)?.complete()
+}
+
+#[tracing::instrument(skip_all, fields(commit_id = %id))]
+pub(crate) fn perform_conflict(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    id: ObjectId,
+) -> Result<Perform> {
     let commit = repo
         .find_commit(id)
         .context("could not find the commit to forget")?
@@ -51,11 +86,19 @@ pub(crate) fn perform(repo: gix::Repository, graph: &crate::history::HistoryGrap
             deletions,
         )
     }?;
-    let outcome = result.complete()?;
-    Ok(Outcome {
-        selected: outcome.selected,
-        review_return,
-        ref_changes: outcome.ref_changes,
+    Ok(match result {
+        rebase::Perform::Complete(outcome) => Perform::Complete(Outcome {
+            selected: outcome.selected,
+            review_return,
+            ref_changes: outcome.ref_changes,
+        }),
+        rebase::Perform::Conflict(rebase) => {
+            anyhow::ensure!(
+                review_return.is_none(),
+                "a checked-out review root cannot suspend while returning from review"
+            );
+            Perform::Conflict(Conflict { rebase })
+        }
     })
 }
 
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index 78e2a88be3a..f23dbbaac7b 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -18,7 +18,7 @@ pub fn perform(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
 ) -> Result<Option<ObjectId>> {
-    Ok(perform_inner(repo, graph, kind, selected_path, false)?.and_then(|outcome| outcome.selected))
+    Ok(perform_inner(repo, graph, kind, selected_path, false, false)?.and_then(|outcome| outcome.selected))
 }
 
 pub(crate) fn perform_with_changes(
@@ -26,8 +26,9 @@ pub(crate) fn perform_with_changes(
     graph: &crate::history::HistoryGraph,
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
+    resolve_pending: bool,
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, kind, selected_path, false)
+    perform_inner(repo, graph, kind, selected_path, false, resolve_pending)
 }
 
 pub(crate) fn perform_reporting(
@@ -35,20 +36,20 @@ pub(crate) fn perform_reporting(
     graph: &crate::history::HistoryGraph,
     kind: Kind,
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, kind, None, false)
+    perform_inner(repo, graph, kind, None, false, false)
 }
 
 #[tracing::instrument(skip_all)]
 #[cfg(test)]
 pub fn amend_index(repo: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<Option<ObjectId>> {
-    Ok(perform_inner(repo, graph, Kind::Amend, None, true)?.and_then(|outcome| outcome.selected))
+    Ok(perform_inner(repo, graph, Kind::Amend, None, true, true)?.and_then(|outcome| outcome.selected))
 }
 
 pub(crate) fn amend_index_reporting(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, Kind::Amend, None, true)
+    perform_inner(repo, graph, Kind::Amend, None, true, true)
 }
 
 fn perform_inner(
@@ -57,6 +58,7 @@ fn perform_inner(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
     index_only: bool,
+    resolve_pending: bool,
 ) -> Result<Option<rebase::Outcome>> {
     let head = repo
         .head_id()
@@ -74,6 +76,7 @@ fn perform_inner(
         .context("could not resolve commit signing configuration")?;
     repo = repo.with_object_memory();
     let old_tree = commit.tree;
+    let pending = rebase::is_pending(&commit);
     let review = super::review::is_review(&commit);
     let parent_tree = match commit.parents.first().copied() {
         Some(parent) => repo.find_commit(parent)?.tree_id()?.detach(),
@@ -102,7 +105,7 @@ fn perform_inner(
                 amend_path_tree(&repo, old_tree, path, &index)?
             } else if review || index_only {
                 let index_tree = create::index_tree(&repo, &index)?;
-                if index_tree == old_tree {
+                if index_tree == old_tree && !pending {
                     return Ok(None);
                 }
                 index_tree
@@ -117,13 +120,15 @@ fn perform_inner(
             }
         }
     };
-    if tree == old_tree {
+    if tree == old_tree && !pending {
         return Ok(None);
     }
     commit.tree = tree;
     let edit = rebase::Edit::Replace { target: head, commit };
     let signature = if review {
         rebase::Signature::Remove
+    } else if pending {
+        rebase::Signature::RedoIfNeeded
     } else {
         rebase::Signature::InvalidateExisting
     };
@@ -133,6 +138,17 @@ fn perform_inner(
         rebase::Tree::LeaveAsIsAndMark
     };
     let performed = match selected_path {
+        Some((path, _)) if kind == Kind::Amend && resolve_pending => {
+            let mut paths = vec![path.path.clone()];
+            if path.kind == ChangeKind::Renamed
+                && let Some(source) = &path.source
+            {
+                paths.push(source.clone());
+            }
+            rebase::perform_resetting_index_paths_allowing_pending_checkout(
+                &repo, graph, edit, signature, tree_mode, paths,
+            )?
+        }
         Some((path, _)) if kind == Kind::Amend => {
             let mut paths = vec![path.path.clone()];
             if path.kind == ChangeKind::Renamed
@@ -142,6 +158,9 @@ fn perform_inner(
             }
             rebase::perform_resetting_index_paths(&repo, graph, edit, signature, tree_mode, paths)?
         }
+        _ if kind == Kind::Amend && resolve_pending => {
+            rebase::perform_allowing_pending_checkout(&repo, graph, edit, signature, tree_mode)?
+        }
         _ => rebase::perform(&repo, graph, edit, signature, tree_mode)?,
     };
     Ok(Some(performed.complete()?))
@@ -327,6 +346,86 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn index_only_amend_finalizes_a_pending_commit_even_when_its_tree_is_unchanged() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let mut commit = repo.find_commit(old)?.decode()?.into_owned()?;
+        let parent = commit.parents.first().copied().expect("the fixture HEAD has a parent");
+        commit
+            .extra_headers
+            .push(("tix-rebase-parent".into(), parent.to_string().into()));
+        let pending = repo.write_object(&commit)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(pending, "prepare pending amend")?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let finalized = amend_index(repo, &graph)?.expect("a pending commit must be finalized");
+        let repo = open(fixture.path())?;
+        assert_eq!(repo.head_id()?.detach(), finalized);
+        assert!(
+            !super::super::rebase::is_pending(&repo.find_commit(finalized)?.decode()?.into_owned()?),
+            "an all-ours resolution removes the pending marker"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn ordinary_amend_rejects_a_pending_head_outside_conflict_resolution() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old = repo.head_id()?.detach();
+        let mut commit = repo.find_commit(old)?.decode()?.into_owned()?;
+        let parent = commit.parents.first().copied().expect("the fixture HEAD has a parent");
+        commit
+            .extra_headers
+            .push(("tix-rebase-parent".into(), parent.to_string().into()));
+        let pending = repo.write_object(&commit)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(pending, "prepare an externally checked-out pending commit")?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let err = match perform(repo, &graph, Kind::Amend, None) {
+            Ok(_) => return Err("an ordinary amend must not resolve an arbitrary pending HEAD".into()),
+            Err(err) => err,
+        };
+        assert!(err.to_string().contains("time-travel to HEAD"), "{err:#}");
+        assert_eq!(open(fixture.path())?.head_id()?.detach(), pending);
+        Ok(())
+    }
+
+    #[test]
+    fn amend_rejects_an_unmarked_head_above_pending_ancestry() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old_tip = repo.head_id()?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let mut pending = repo.find_commit(middle)?.decode()?.into_owned()?;
+        pending
+            .extra_headers
+            .push(("tix-rebase-parent".into(), base.to_string().into()));
+        let pending = repo.write_object(&pending)?.detach();
+        let mut tip = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        tip.parents = [pending].into_iter().collect();
+        let tip = repo.write_object(&tip)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(tip, "prepare pending checkout ancestry")?;
+        std::fs::write(fixture.path().join("tip"), b"amended\n")?;
+        git(fixture.path(), &["add", "tip"])?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let err = match perform(repo, &graph, Kind::Amend, None) {
+            Ok(_) => return Err("amend must not preserve pending checkout ancestry".into()),
+            Err(err) => err,
+        };
+        assert!(err.to_string().contains("time-travel to HEAD"), "{err:#}");
+        assert_eq!(gix_testtools::repository::snapshot(fixture.path())?, before);
+        Ok(())
+    }
+
     #[test]
     fn amending_one_worktree_path_preserves_unrelated_staging() -> gix_testtools::Result {
         for (group, expected) in [
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index d444b986140..e8dc2164b1c 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -397,6 +397,7 @@ struct Prepared {
     checkout_after_finish: bool,
     pins: Vec<ObjectId>,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
+    enrichment: Option<(ObjectId, BString)>,
 }
 
 pub(crate) fn capture_refs(repo: &gix::Repository, scope: &[ObjectId], tips: &[ObjectId]) -> Result<Vec<ExpectedRef>> {
@@ -801,7 +802,63 @@ pub(crate) fn perform(
     signature: Signature,
     tree_mode: Tree,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, |_| {})
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        false,
+        None,
+        |_| {},
+    )
+    .map(|(perform, _)| perform)
+}
+
+pub(crate) fn perform_with_enrichment(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    headers: &crate::enrich::Headers,
+) -> Result<(Perform, Option<crate::enrich::Enrichment>)> {
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        false,
+        Some(headers),
+        |_| {},
+    )
+}
+
+pub(super) fn perform_allowing_pending_checkout(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+) -> Result<Perform> {
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        true,
+        None,
+        |_| {},
+    )
+    .map(|(perform, _)| perform)
 }
 
 pub(crate) fn perform_reporting_rebased(
@@ -812,7 +869,19 @@ pub(crate) fn perform_reporting_rebased(
     tree_mode: Tree,
     report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), None, report)
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        false,
+        None,
+        report,
+    )
+    .map(|(perform, _)| perform)
 }
 
 pub(super) fn perform_resetting_index_paths(
@@ -823,7 +892,42 @@ pub(super) fn perform_resetting_index_paths(
     tree_mode: Tree,
     paths: Vec<BString>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, Vec::new(), Some(paths), |_| {})
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        Some(paths),
+        false,
+        None,
+        |_| {},
+    )
+    .map(|(perform, _)| perform)
+}
+
+pub(super) fn perform_resetting_index_paths_allowing_pending_checkout(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    paths: Vec<BString>,
+) -> Result<Perform> {
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        Some(paths),
+        true,
+        None,
+        |_| {},
+    )
+    .map(|(perform, _)| perform)
 }
 
 pub(super) fn perform_deleting_refs(
@@ -834,7 +938,19 @@ pub(super) fn perform_deleting_refs(
     tree_mode: Tree,
     deletions: Vec<(gix::refs::FullName, Target)>,
 ) -> Result<Perform> {
-    perform_inner(repo, graph, edit, signature, tree_mode, deletions, None, |_| {})
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        deletions,
+        None,
+        false,
+        None,
+        |_| {},
+    )
+    .map(|(perform, _)| perform)
 }
 
 #[expect(
@@ -849,8 +965,10 @@ fn perform_inner(
     tree_mode: Tree,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     reset_index_paths: Option<Vec<BString>>,
+    allow_pending_checkout: bool,
+    enrichment_headers: Option<&crate::enrich::Headers>,
     mut report: impl FnMut(ObjectId),
-) -> Result<Perform> {
+) -> Result<(Perform, Option<crate::enrich::Enrichment>)> {
     let mut repo = repo.clone();
     let repeat_checkout = match &edit {
         Edit::Repeat { checkout, .. } => Some(*checkout),
@@ -884,6 +1002,36 @@ fn perform_inner(
             .context("the edited commit is not in the loaded history")?,
         None => Vec::new(),
     };
+    let checkout = if repo.workdir().is_some() {
+        repo.head()?.id().map(gix::Id::detach)
+    } else {
+        None
+    };
+    let checkout_path: HashSet<_> = checkout
+        .into_iter()
+        .flat_map(|checkout| {
+            affected
+                .iter()
+                .copied()
+                .filter(move |id| graph.is_ancestor(*id, checkout))
+        })
+        .collect();
+    if !repeat && !checkout_path.is_empty() {
+        let checkout = checkout.expect("a non-empty checkout path has a checkout");
+        let scan_from = if allow_pending_checkout && root == Some(checkout) {
+            repo.find_commit(checkout)?
+                .decode()?
+                .into_owned()?
+                .parents
+                .first()
+                .copied()
+        } else {
+            Some(checkout)
+        };
+        if let Some(id) = scan_from {
+            reject_pending_checkout_path(&repo, id)?;
+        }
+    }
     validate(&repo, graph, &affected, removed, repeat, tree_mode)?;
 
     let signing = repo
@@ -901,6 +1049,7 @@ fn perform_inner(
     let mut note_rewrites = Vec::new();
     let mut selected = None;
     let mut conflict = None;
+    let mut eager_checkout_rewrite = false;
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
@@ -963,15 +1112,16 @@ fn perform_inner(
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
         let original_parents =
             recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
-        let eager =
-            repeat && repeat_checkout.is_some_and(|checkout| graph.is_ancestor(old_id, checkout)) && conflict.is_none();
-        let commit_tree_mode = if repeat {
-            if eager {
-                Tree::CherryPick
+        let eager = conflict.is_none()
+            && if repeat {
+                repeat_checkout.is_some_and(|checkout| graph.is_ancestor(old_id, checkout))
             } else {
-                Tree::LeaveAsIsAndMark
-            }
-        } else if conflict.is_some() {
+                Some(old_id) != root && checkout_path.contains(&old_id)
+            };
+        eager_checkout_rewrite |= !repeat && eager;
+        let commit_tree_mode = if eager {
+            Tree::CherryPick
+        } else if repeat || conflict.is_some() {
             Tree::LeaveAsIsAndMark
         } else {
             tree_mode
@@ -979,7 +1129,11 @@ fn perform_inner(
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
-            if !repeat { &old_parents } else { &original_parents },
+            if commit_tree_mode == Tree::CherryPick {
+                &original_parents
+            } else {
+                &old_parents
+            },
             &new_parents,
             commit_tree_mode,
         )?;
@@ -1003,7 +1157,7 @@ fn perform_inner(
         let is_conflicting_commit = new_conflict.is_some();
         let signature = if conflict.is_some() || is_conflicting_commit || (repeat && !eager) {
             Signature::InvalidateExisting
-        } else if repeat {
+        } else if eager {
             Signature::RedoIfNeeded
         } else {
             signature
@@ -1051,9 +1205,10 @@ fn perform_inner(
         root,
         reset_index: if inserted { reset_index } else { marked },
         reset_index_paths,
-        skip_worktree_transitions: inserted
-            || forked
-            || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed),
+        skip_worktree_transitions: !eager_checkout_rewrite
+            && (inserted
+                || forked
+                || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed)),
         selected,
         note_rewrites,
         stash_rewritten: rewritten.clone(),
@@ -1073,17 +1228,20 @@ fn perform_inner(
             Vec::new()
         },
         delete_refs,
+        enrichment: None,
     };
-    match conflict {
-        Some((original, merged_tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
+    let enrichment = prepare_enrichment(&mut prepared, enrichment_headers)?;
+    let perform = match conflict {
+        Some((original, merged_tree, conflicts, commit)) => Perform::Conflict(Conflict {
             prepared,
             conflicts,
             merged_tree,
             commit,
             original,
-        })),
-        None => Ok(Perform::Complete(prepared.finish()?)),
-    }
+        }),
+        None => Perform::Complete(prepared.finish()?),
+    };
+    Ok((perform, enrichment))
 }
 
 #[tracing::instrument(skip_all, fields(%review, %tip))]
@@ -1095,7 +1253,7 @@ pub(super) fn finish_review(
     review_ref: gix::refs::FullName,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     checkout: Option<(ObjectId, Option<gix::refs::FullName>)>,
-) -> Result<Outcome> {
+) -> Result<Perform> {
     let mut repo = repo.clone();
     let signing = repo
         .commit_signing_options_if_enabled()
@@ -1117,6 +1275,26 @@ pub(super) fn finish_review(
         .into_iter()
         .filter(|id| *id != tip && !review_set.contains(id))
         .collect();
+    let checkout_path: HashSet<_> = if repo.workdir().is_some() {
+        checkout
+            .as_ref()
+            .map(|(checkout, _)| {
+                natural_ids
+                    .iter()
+                    .copied()
+                    .filter(|id| graph.is_ancestor(*id, *checkout))
+                    .collect()
+            })
+            .unwrap_or_default()
+    } else {
+        HashSet::new()
+    };
+    if !checkout_path.is_empty() {
+        reject_pending_checkout_path(
+            &repo,
+            checkout.as_ref().expect("a non-empty checkout path has a checkout").0,
+        )?;
+    }
     for id in review_ids.iter().chain(&natural_ids) {
         if graph
             .parents_of(*id)
@@ -1131,6 +1309,7 @@ pub(super) fn finish_review(
     let mut rewritten = HashMap::<ObjectId, Option<ObjectId>>::new();
     let mut note_rewrites = Vec::new();
     let mut finished_review = None;
+    let mut conflict = None;
     for old in &review_ids {
         let old_parents = graph.parents_of(*old).context("a review descendant is incomplete")?;
         let mut commit = repo.find_commit(*old)?.decode()?.into_owned()?;
@@ -1197,14 +1376,40 @@ pub(super) fn finish_review(
                 }
             })
             .collect();
+        let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
+        let original_parents =
+            recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
+        let eager = conflict.is_none() && checkout_path.contains(&old);
+        let mode = if eager {
+            Tree::CherryPick
+        } else {
+            Tree::LeaveAsIsAndMark
+        };
+        let mut new_conflict = None;
+        commit.tree = match rewritten_tree(&repo, &commit, &original_parents, &new_parents, mode)? {
+            TreeRewrite::Complete(tree) => tree,
+            TreeRewrite::Conflict {
+                ours,
+                merged,
+                conflicts,
+            } => {
+                new_conflict = Some((merged, conflicts));
+                ours
+            }
+        };
         commit.parents = new_parents.into_iter().collect();
+        let pending = !eager || conflict.is_some() || new_conflict.is_some();
         let new = write_commit(
             &repo,
             commit,
             Some(old),
             &committer,
-            CommitState::Pending {
-                original_parent: old_parents.first().copied(),
+            if pending {
+                CommitState::Pending {
+                    original_parent: recorded_parent.flatten().or_else(|| old_parents.first().copied()),
+                }
+            } else {
+                CommitState::Unmarked(Signature::RedoIfNeeded)
             },
             signing.clone(),
         )?;
@@ -1212,6 +1417,9 @@ pub(super) fn finish_review(
             note_rewrites.push((old, new));
         }
         rewritten.insert(old, Some(new));
+        if let Some((tree, conflicts)) = new_conflict {
+            conflict = Some((old, tree, conflicts, new));
+        }
     }
 
     let (selected, checkout_reference) = checkout.map_or((finished_review, None), |(old, reference)| {
@@ -1231,11 +1439,21 @@ pub(super) fn finish_review(
         committer,
         expected_refs: None,
         checkout_reference,
-        checkout_after_finish: false,
+        checkout_after_finish: conflict.is_some(),
         pins: Vec::new(),
         delete_refs,
+        enrichment: None,
     };
-    prepared.finish()
+    match conflict {
+        Some((original, merged_tree, conflicts, commit)) => Ok(Perform::Conflict(Conflict {
+            prepared,
+            conflicts,
+            merged_tree,
+            commit,
+            original,
+        })),
+        None => Ok(Perform::Complete(prepared.finish()?)),
+    }
 }
 
 pub(crate) fn perform_plan(repo: &gix::Repository, graph: &HistoryGraph, plan: Plan) -> Result<PlanPerform> {
@@ -1291,8 +1509,27 @@ pub(crate) fn perform_plan_with_progress(
         }
     }
 
+    let checkout_target = if repo.workdir().is_some() {
+        plan.checkout
+            .as_ref()
+            .map(|checkout| checkout.target)
+            .or(infer_plan_checkout(&repo, graph, &plan)?)
+    } else {
+        None
+    };
+    if plan.checkout.is_none()
+        && checkout_target.is_some()
+        && !plan
+            .steps
+            .iter()
+            .any(|step| matches!(step.commit, PlanCommit::Resolved(_)))
+        && let Some(head) = repo.head()?.id().map(gix::Id::detach)
+        && plan.scope.contains(&head)
+    {
+        reject_pending_checkout_path(&repo, head)?;
+    }
     let mut eager = HashSet::new();
-    let mut cursor = plan.checkout.as_ref().map(|checkout| checkout.target);
+    let mut cursor = checkout_target;
     while let Some(PlanParent::Step(index)) = cursor {
         if !eager.insert(index) {
             anyhow::bail!("the checkout ancestry contains a cycle");
@@ -1621,6 +1858,7 @@ pub(crate) fn perform_plan_with_progress(
         checkout_after_finish: false,
         pins,
         delete_refs,
+        enrichment: None,
     };
     tracing::info!(
         total = progress.total,
@@ -1635,10 +1873,8 @@ pub(crate) fn perform_plan_with_progress(
         return Ok(PlanPerform::Complete(prepared.finish()?));
     };
 
-    let continuation_start = plan
-        .checkout
-        .as_ref()
-        .and_then(|checkout| match checkout.target {
+    let continuation_start = checkout_target
+        .and_then(|checkout| match checkout {
             PlanParent::Step(index) if index < conflict_step => Some(index),
             _ => None,
         })
@@ -1685,6 +1921,69 @@ pub(crate) fn perform_plan_with_progress(
     }))
 }
 
+fn infer_plan_checkout(repo: &gix::Repository, graph: &HistoryGraph, plan: &Plan) -> Result<Option<PlanParent>> {
+    let head = repo.head()?;
+    let Some(name) = head.referent_name() else {
+        return Ok(None);
+    };
+    let Some(expected) = plan
+        .expected_refs
+        .iter()
+        .find(|expected| expected.name.as_bstr() == name.as_bstr())
+    else {
+        return Ok(None);
+    };
+    if let Some(target) = expected.placement {
+        return Ok(Some(target));
+    }
+    let scope: HashSet<_> = plan.scope.iter().copied().collect();
+    let mut source = expected.target;
+    let mut target = loop {
+        if let Some(index) = plan.steps.iter().position(|step| {
+            matches!(
+                step.commit,
+                PlanCommit::Pick(candidate) | PlanCommit::Resolved(candidate) if candidate == source
+            ) || step.squash.contains(&source)
+        }) {
+            break Some(PlanParent::Step(index));
+        }
+        if !scope.contains(&source) {
+            break Some(PlanParent::Existing(source));
+        }
+        let Some(parent) = graph
+            .parents_of(source)
+            .context("a dropped checkout commit is incomplete")?
+            .first()
+            .copied()
+        else {
+            break Some(PlanParent::Existing(plan.base));
+        };
+        source = parent;
+    };
+    if expected.follows_tip {
+        while let Some(parent) = target {
+            let Some(index) = plan.steps.iter().position(|step| step.parent == parent) else {
+                break;
+            };
+            target = Some(PlanParent::Step(index));
+        }
+    }
+    Ok(target.filter(|target| matches!(target, PlanParent::Step(_))))
+}
+
+fn prepare_enrichment(
+    prepared: &mut Prepared,
+    headers: Option<&crate::enrich::Headers>,
+) -> Result<Option<crate::enrich::Enrichment>> {
+    let Some(headers) = headers else { return Ok(None) };
+    let selected = prepared.selected.context("an enriched edit must select its commit")?;
+    let Some((object, data, enrichment)) = crate::enrich::prepare_headers(&prepared.repo, selected, headers)? else {
+        return Ok(None);
+    };
+    prepared.enrichment = Some((object, data));
+    Ok(Some(enrichment))
+}
+
 impl Prepared {
     fn persist_objects(&mut self) -> Result<()> {
         let objects = self
@@ -1704,8 +2003,19 @@ impl Prepared {
     fn finish(&mut self) -> Result<Outcome> {
         let mut resource_edits = super::stash::rewrite_edits(&self.repo, &self.stash_rewritten, &self.removed)?;
         let note_edits = note_rewrite_edits(&self.repo, &self.note_rewrites, &self.committer)?;
+        let enrichment_edits = self
+            .enrichment
+            .take()
+            .map(|(object, data)| enrichment_edits(&self.repo, object, data, &self.committer))
+            .transpose()?
+            .unwrap_or_else(|| super::stash::RewriteEdits {
+                forward: Vec::new(),
+                rollback: Vec::new(),
+            });
         resource_edits.forward.extend(note_edits.forward);
         resource_edits.rollback.extend(note_edits.rollback);
+        resource_edits.forward.extend(enrichment_edits.forward);
+        resource_edits.rollback.extend(enrichment_edits.rollback);
         self.persist_objects()?;
         let _ = self
             .repo
@@ -1870,6 +2180,55 @@ fn note_rewrite_edits(
     })
 }
 
+fn enrichment_edits(
+    repo: &gix::Repository,
+    object: ObjectId,
+    data: BString,
+    committer: &gix::actor::Signature,
+) -> Result<super::stash::RewriteEdits> {
+    let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+    let (root, parent) = match repo.try_find_reference(name.as_ref())? {
+        Some(mut reference) => {
+            let parent = reference
+                .try_id()
+                .context("the tix enrich reference must be direct")?
+                .detach();
+            let root = reference
+                .peel_to_tree()
+                .context("could not read the tix enrich tree")?
+                .id;
+            (root, Some(parent))
+        }
+        None => (ObjectId::empty_tree(repo.object_hash()), None),
+    };
+    let note = repo.write_blob(data)?.detach();
+    let tree = gix::note::add(root, object, note, repo, &mut gix::note::Cache::default())
+        .map_err(gix::Exn::into_error)
+        .context("could not prepare the tix enrichment")?
+        .tree;
+    let author = repo
+        .author()
+        .context("no Git author is configured")?
+        .context("could not resolve the Git author")?
+        .to_owned()?;
+    let mut author_time = gix::date::parse::TimeBuf::default();
+    let mut committer_time = gix::date::parse::TimeBuf::default();
+    let commit = repo
+        .new_commit_as(
+            author.to_ref(&mut author_time),
+            committer.to_ref(&mut committer_time),
+            "Notes added by gitoxide",
+            tree,
+            parent,
+        )
+        .context("could not prepare the tix enrichment commit")?
+        .id;
+    Ok(super::stash::RewriteEdits {
+        forward: vec![ref_edit(name.clone(), parent, Some(commit))],
+        rollback: vec![ref_edit(name, Some(commit), parent)],
+    })
+}
+
 fn rollback<T>(
     repo: &gix::Repository,
     committer: &gix::actor::Signature,
@@ -2031,6 +2390,21 @@ fn validate(
     Ok(())
 }
 
+fn reject_pending_checkout_path(repo: &gix::Repository, mut id: ObjectId) -> Result<()> {
+    let mut seen = HashSet::new();
+    while seen.insert(id) {
+        let commit = repo.find_commit(id)?.decode()?.into_owned()?;
+        if is_pending(&commit) {
+            anyhow::bail!("the current checkout has a pending rebase; time-travel to HEAD before editing it");
+        }
+        let Some(parent) = commit.parents.first().copied() else {
+            break;
+        };
+        id = parent;
+    }
+    Ok(())
+}
+
 enum TreeRewrite {
     Complete(ObjectId),
     Conflict {
@@ -2242,7 +2616,7 @@ pub(super) fn has_marker(commit: &gix::objs::Commit) -> bool {
         .any(|(name, _)| name.as_slice() == ORIGINAL_PARENT)
 }
 
-pub(super) fn is_pending(commit: &gix::objs::Commit) -> bool {
+pub(crate) fn is_pending(commit: &gix::objs::Commit) -> bool {
     has_marker(commit)
         || commit
             .extra_headers
@@ -2884,23 +3258,32 @@ mod tests {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
         let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
-        commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~2")?)?.tree_id()?.detach();
-        perform(
+        commit.tree = repo.find_commit(base)?.tree_id()?.detach();
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "--detach", &base.to_string()])
+                .status()?
+                .success(),
+            "the pending stack is prepared away from the current checkout"
+        );
+        let marked = perform(
             &repo,
             &graph,
             Edit::Replace { target: middle, commit },
             Signature::InvalidateExisting,
             Tree::LeaveAsIsAndMark,
         )?
-        .complete()?
-        .selected
-        .expect("marking rewrites the selected commit");
+        .complete()?;
+        let tip = marked.map(old_tip).context("marking retains the pending tip")?;
 
         let graph = super::super::loaded_graph(&repo)?;
-        let tip = repo.head_id()?.detach();
-        perform(
+        let repeated = perform(
             &repo,
             &graph,
             Edit::Repeat {
@@ -2911,7 +3294,8 @@ mod tests {
             Tree::CherryPick,
         )?
         .complete()?;
-        let mut id = Some(repo.head_id()?.detach());
+        let repeated_tip = repeated.map(tip).context("repeating retains the pending tip")?;
+        let mut id = Some(repeated_tip);
         while let Some(current) = id {
             let commit = repo.find_commit(current)?.decode()?.into_owned()?;
             assert!(!has_marker(&commit), "repeating clears every pending marker");
@@ -2920,7 +3304,7 @@ mod tests {
         let files = Command::new("git")
             .arg("-C")
             .arg(fixture.path())
-            .args(["ls-tree", "-r", "--name-only", "HEAD"])
+            .args(["ls-tree", "-r", "--name-only", &repeated_tip.to_string()])
             .output()?;
         assert!(files.status.success());
         assert_eq!(
@@ -2944,11 +3328,21 @@ mod tests {
         );
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~3")?.detach();
         let middle = repo.rev_parse_single("HEAD~2")?.detach();
         let old_tip = repo.rev_parse_single("HEAD~1")?.detach();
         let old_newer = repo.head_id()?.detach();
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
-        commit.tree = repo.find_commit(repo.rev_parse_single("HEAD~3")?)?.tree_id()?.detach();
+        commit.tree = repo.find_commit(base)?.tree_id()?.detach();
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "--detach", &base.to_string()])
+                .status()?
+                .success(),
+            "the legacy pending stack is prepared away from the current checkout"
+        );
         let marked = perform(
             &repo,
             &graph,
@@ -2975,6 +3369,15 @@ mod tests {
             .set_target_id(legacy_newer, "test legacy pending commits")?;
         drop(repo);
 
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "main"])
+                .status()?
+                .success(),
+            "the legacy pending stack becomes the current checkout"
+        );
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -3109,7 +3512,7 @@ mod tests {
     }
 
     #[test]
-    fn a_conflicting_cherry_pick_leaves_repository_state_unmodified() -> gix_testtools::Result {
+    fn a_lazy_edit_eagerly_detects_checkout_conflicts_without_observable_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
         let repo = open(fixture.path())?;
         let graph = super::super::loaded_graph(&repo)?;
@@ -3127,7 +3530,7 @@ mod tests {
             &graph,
             Edit::Remove { target: middle },
             Signature::RedoIfNeeded,
-            Tree::CherryPick,
+            Tree::LeaveAsIsAndMark,
         )?
         else {
             return Err("the unresolved cherry-pick should suspend the complete rebase".into());
@@ -3151,6 +3554,113 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn conflicting_enriched_edits_are_atomic_and_report_one_ref_transaction() -> gix_testtools::Result {
+        let headers = crate::enrich::Headers {
+            todo: true,
+            message: Some("conflict note".into()),
+        };
+        let prepare = |repo: &gix::Repository| -> gix_testtools::Result<(HistoryGraph, ObjectId, gix::objs::Commit)> {
+            let graph = super::super::loaded_graph(repo)?;
+            let middle = repo.rev_parse_single("HEAD~1")?.detach();
+            let base = repo.rev_parse_single("HEAD~2")?.detach();
+            let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
+            commit.tree = repo.find_commit(base)?.tree_id()?.detach();
+            commit.message = "rewritten middle".into();
+            Ok((graph, middle, commit))
+        };
+
+        let cancelled = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(cancelled.path())?;
+        let (graph, middle, commit) = prepare(&repo)?;
+        let before = gix_testtools::repository::snapshot(cancelled.path())?;
+        let (Perform::Conflict(conflict), enrichment) = perform_with_enrichment(
+            &repo,
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIsAndMark,
+            &headers,
+        )?
+        else {
+            return Err("the enriched edit should suspend on its checkout conflict".into());
+        };
+        assert!(enrichment.is_some(), "the enrichment is prepared in memory");
+        drop(conflict);
+        assert_eq!(
+            gix_testtools::repository::snapshot(cancelled.path())?,
+            before,
+            "cancelling leaks neither history nor enrichment refs"
+        );
+
+        let accepted = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repo = open(accepted.path())?;
+        let (graph, middle, commit) = prepare(&repo)?;
+        let (Perform::Conflict(conflict), _) = perform_with_enrichment(
+            &repo,
+            &graph,
+            Edit::Replace { target: middle, commit },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIsAndMark,
+            &headers,
+        )?
+        else {
+            return Err("the enriched edit should suspend on its checkout conflict".into());
+        };
+        let persisted = conflict.persist()?;
+        assert!(
+            persisted
+                .ref_changes
+                .iter()
+                .any(|change| change.name.as_bstr() == crate::enrich::REF_NAME.as_bytes()),
+            "accepted conflict records the enrichment in the same undo change set"
+        );
+        assert!(
+            persisted
+                .ref_changes
+                .iter()
+                .any(|change| change.name.as_bstr() == b"refs/heads/main"),
+            "the same change set also contains the rewritten branch"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn an_edit_cannot_leave_the_checkout_on_pending_ancestry() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old_tip = repo.head_id()?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+
+        let mut pending = repo.find_commit(middle)?.decode()?.into_owned()?;
+        pending
+            .extra_headers
+            .push((ORIGINAL_PARENT.into(), base.to_string().into()));
+        let pending = repo.write_object(&pending)?.detach();
+        let mut tip = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        tip.parents = [pending].into_iter().collect();
+        let tip = repo.write_object(&tip)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(tip, "prepare pending checkout ancestry")?;
+        let before = gix_testtools::repository::snapshot(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let err = match perform(
+            &repo,
+            &graph,
+            Edit::Remove { target: tip },
+            Signature::RedoIfNeeded,
+            Tree::LeaveAsIsAndMark,
+        ) {
+            Ok(_) => return Err("removing HEAD must not expose its pending parent".into()),
+            Err(err) => err,
+        };
+        assert!(err.to_string().contains("time-travel to HEAD"), "{err:#}");
+        assert_eq!(gix_testtools::repository::snapshot(fixture.path())?, before);
+        Ok(())
+    }
+
     #[test]
     fn a_conflicting_todo_aborts_at_the_original_commit_without_observable_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
@@ -4267,6 +4777,10 @@ mod tests {
             b"replacement tip",
             "the branch advances past the retained ancestor"
         );
+        assert!(
+            !is_pending(&repo.find_commit(repo.head_id()?)?.decode()?.into_owned()?),
+            "the inferred checked-out replacement is fully replayed"
+        );
         assert!(
             crate::history::all_pins(&repo)?.is_empty(),
             "the referenced replacement leaf needs no pin"
@@ -4274,6 +4788,47 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn a_plan_without_checkout_does_not_infer_detached_head() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        let plan = Plan {
+            base,
+            scope: vec![middle, tip],
+            steps: vec![
+                PlanStep {
+                    parent: PlanParent::Existing(base),
+                    commit: PlanCommit::Pick(middle),
+                    squash: Vec::new(),
+                },
+                PlanStep {
+                    parent: PlanParent::Step(0),
+                    commit: PlanCommit::Empty("replacement tip".into()),
+                    squash: Vec::new(),
+                },
+            ],
+            checkout: None,
+            expected_refs: capture_refs(&repo, &[middle, tip], &[tip])?,
+        };
+        assert_eq!(
+            infer_plan_checkout(&repo, &graph, &plan)?,
+            Some(PlanParent::Step(1)),
+            "an attached branch preserves its implicit checkout"
+        );
+
+        git(fixture.path(), &["checkout", "-q", "--detach", &tip.to_string()])?;
+        assert_eq!(
+            infer_plan_checkout(&repo, &graph, &plan)?,
+            None,
+            "a detached HEAD never supplies an implicit checkout"
+        );
+        Ok(())
+    }
+
     #[test]
     fn a_todo_rebase_can_update_onto_a_hidden_branch_without_moving_it() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index 2ed857b17f3..e3ce28840b3 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -26,6 +26,7 @@ pub(crate) struct Finished {
 
 pub(crate) enum Finish {
     Complete(Finished),
+    Conflict(super::rebase::Conflict),
     SelectReturn { tip: ObjectId },
 }
 
@@ -280,14 +281,18 @@ pub(crate) fn finish(
             anyhow::bail!("{label} has a pending rebase");
         }
     }
-    let outcome = super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs, checkout)?;
-    let finished = outcome
-        .map(review)
-        .context("finishing review did not produce a commit")?;
-    Ok(Finish::Complete(Finished {
-        commit: finished,
-        outcome,
-    }))
+    match super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs, checkout)? {
+        super::rebase::Perform::Complete(outcome) => {
+            let finished = outcome
+                .map(review)
+                .context("finishing review did not produce a commit")?;
+            Ok(Finish::Complete(Finished {
+                commit: finished,
+                outcome,
+            }))
+        }
+        super::rebase::Perform::Conflict(conflict) => Ok(Finish::Conflict(conflict)),
+    }
 }
 
 pub(super) fn ensure_clean(workdir: &Path) -> Result<()> {
@@ -727,9 +732,10 @@ mod tests {
             b"A\n".as_bstr(),
             "the target history successor is retained"
         );
-        assert!(super::super::rebase::has_marker(
-            &repo.find_commit(successor)?.decode()?.into_owned()?
-        ));
+        assert!(
+            !super::super::rebase::is_pending(&repo.find_commit(successor)?.decode()?.into_owned()?),
+            "the checked-out review return path is fully replayed"
+        );
         insta::assert_snapshot!(
             "changed-review-with-successors",
             gix_testtools::repository::snapshot(fixture.path())?.to_string()
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 6af8c71be1a..9fbf12bd41a 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -31,6 +31,20 @@ pub(crate) struct Outcome {
     pub ref_changes: Vec<super::undo::RefChange>,
 }
 
+pub(crate) enum Perform {
+    Complete(Outcome),
+    Conflict(rebase::Conflict),
+}
+
+impl Perform {
+    fn complete(self) -> Result<Outcome> {
+        match self {
+            Perform::Complete(outcome) => Ok(outcome),
+            Perform::Conflict(_) => anyhow::bail!("rewording the commit would cause a merge conflict"),
+        }
+    }
+}
+
 pub(crate) fn relocate_after_editor(
     repo: &gix::Repository,
     revisions: &[std::ffi::OsString],
@@ -130,6 +144,16 @@ pub(crate) fn apply(
     old_id: gix::ObjectId,
     edited: &[u8],
 ) -> Result<Outcome> {
+    apply_conflict_reporting(repo, graph, old_id, edited)?.complete()
+}
+
+#[tracing::instrument(skip_all, fields(commit_id = %old_id))]
+pub(crate) fn apply_conflict_reporting(
+    repo: gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    edited: &[u8],
+) -> Result<Perform> {
     let edit = parse(edited)?;
     if edit.message.is_empty() {
         anyhow::bail!("the edited commit message is empty");
@@ -144,40 +168,43 @@ pub(crate) fn apply(
         .context("could not own commit after editing")?;
     let author = actor(edit.author, edit.author_time, "author")?;
     let commit_changed = author != commit.author || edit.message != commit.message;
-    let rebased = if commit_changed {
+    let (rebased, enrichment, enrich_change) = if commit_changed {
         commit.author = author;
         commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
         commit.message = edit.message;
-        Some(apply_commit(&repo, graph, old_id, commit)?)
+        let (performed, enrichment) =
+            apply_commit_conflict_with_enrichment(&repo, graph, old_id, commit, &edit.enrichment)?;
+        let outcome = match performed {
+            rebase::Perform::Complete(outcome) => outcome,
+            rebase::Perform::Conflict(conflict) => return Ok(Perform::Conflict(conflict)),
+        };
+        (Some(outcome), enrichment, None)
     } else {
-        None
+        let name: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
+        let before = super::undo::state(&repo, name.as_ref())?;
+        let enrichment = crate::enrich::apply_headers(&repo, old_id, &edit.enrichment)?;
+        let after = super::undo::state(&repo, name.as_ref())?;
+        let change = (before != after).then_some(super::undo::RefChange { name, before, after });
+        (None, enrichment, change)
     };
     let commit = rebased
         .as_ref()
         .and_then(|outcome| outcome.selected)
         .filter(|new_id| *new_id != old_id);
-    let enrich_ref: gix::refs::FullName = crate::enrich::REF_NAME.try_into().expect("valid enrich ref");
-    let enrich_before = super::undo::state(&repo, enrich_ref.as_ref())?;
-    let enrichment = crate::enrich::apply_headers(&repo, commit.unwrap_or(old_id), &edit.enrichment)?;
-    let enrich_after = super::undo::state(&repo, enrich_ref.as_ref())?;
     let (ref_rewrites, mut ref_changes) = rebased.map_or_else(
         || (Vec::new(), Vec::new()),
         |outcome| (outcome.ref_rewrites, outcome.ref_changes),
     );
-    if enrich_before != enrich_after {
-        ref_changes.push(super::undo::RefChange {
-            name: enrich_ref,
-            before: enrich_before,
-            after: enrich_after,
-        });
+    if let Some(change) = enrich_change {
+        ref_changes.push(change);
     }
-    Ok(Outcome {
+    Ok(Perform::Complete(Outcome {
         target: old_id,
         commit,
         enrichment,
         ref_rewrites,
         ref_changes,
-    })
+    }))
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %old_id))]
@@ -231,14 +258,39 @@ fn apply_commit(
     old_id: gix::ObjectId,
     commit: gix::objs::Commit,
 ) -> Result<rebase::Outcome> {
+    apply_commit_conflict(repo, graph, old_id, commit)?.complete()
+}
+
+fn apply_commit_conflict(
+    repo: &gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    commit: gix::objs::Commit,
+) -> Result<rebase::Perform> {
     rebase::perform(
         repo,
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
-    )?
-    .complete()
+    )
+}
+
+fn apply_commit_conflict_with_enrichment(
+    repo: &gix::Repository,
+    graph: &crate::history::HistoryGraph,
+    old_id: gix::ObjectId,
+    commit: gix::objs::Commit,
+    headers: &crate::enrich::Headers,
+) -> Result<(rebase::Perform, Option<crate::enrich::Enrichment>)> {
+    rebase::perform_with_enrichment(
+        repo,
+        graph,
+        rebase::Edit::Replace { target: old_id, commit },
+        rebase::Signature::RedoIfNeeded,
+        rebase::Tree::LeaveAsIsAndMark,
+        headers,
+    )
 }
 
 pub(super) fn write_headers(
@@ -753,7 +805,7 @@ mod tests {
     }
 
     #[test]
-    fn marks_only_reworded_descendants_for_lazy_replay() -> gix_testtools::Result {
+    fn eagerly_replays_checked_out_reword_descendants() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         let repository = crate::test_repository::open_with(
             fixture.path(),
@@ -788,14 +840,14 @@ mod tests {
             "the reworded commit already has its final tree, parent, and signature"
         );
         assert!(
-            rebase::has_marker(&repository.find_commit(new_tip)?.decode()?.into_owned()?),
-            "the reparented descendant retains its original parent for lazy replay"
+            !rebase::is_pending(&repository.find_commit(new_tip)?.decode()?.into_owned()?),
+            "the checked-out descendant is replayed eagerly"
         );
         Ok(())
     }
 
     #[test]
-    fn signed_rewords_leave_pending_descendants_unsigned() -> gix_testtools::Result {
+    fn signed_rewords_sign_eager_checked_out_descendants() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {
             return Ok(());
         }
@@ -829,15 +881,13 @@ mod tests {
             "the final edited commit receives its configured signature"
         );
 
-        let descendant = repository.find_commit(repository.head_id()?)?.decode()?.into_owned()?;
-        assert!(rebase::has_marker(&descendant), "the descendant remains pending");
         assert!(
-            descendant
-                .extra_headers
-                .iter()
-                .filter(|(name, _)| name == "gpgsig" || name == "gpgsig-sha256")
-                .all(|(_, value)| value.is_empty()),
-            "a pending descendant never carries a usable signature"
+            repository
+                .find_commit(repository.head_id()?)?
+                .verify_signature()?
+                .expect("the eagerly replayed descendant is signed")
+                .is_valid(),
+            "the checked-out descendant receives its configured signature"
         );
         Ok(())
     }
diff --git a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
index 6129f3fc1a4..f8a7a6273c0 100644
--- a/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
+++ b/gix-tix/src/edit/snapshots/gix_tix__edit__review__tests__changed-review-with-successors.snap
@@ -20,7 +20,7 @@ refs/heads/review-successor = C3
 
 [commits]
 C0
-  tree T3
+  tree T2
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
 
@@ -53,33 +53,35 @@ C3
   review successor
 
 C4
-  tree T2
+  tree T3
   parent C3
   author reviewer <reviewer@example.com> 978307200 +0000
   committer reviewer <reviewer@example.com> 978307200 +0000
   change-id xlpouomvnxrqllnkynsusvqwkkwnlrttmrvxquso
-  tix-rebase-parent 2cb49e443aa675eab8add679938ca6cd303ae353
 
   A
 
 [index]
-tree = T2
+tree = T3
 100644 B0 stage=0 "file"
-100644 B1 stage=0 "successor"
+100644 B1 stage=0 "reviewed"
+100644 B2 stage=0 "successor"
 
 [worktree]
 100644 file "file" = "B\n"
+100644 file "reviewed" = "new review change\n"
 100644 file "successor" = "A\n"
 
 [objects]
+T3 = 1104ca61473daa5765f3a6eb0a5fae3e5012a067
 C2 = 1a13dc5cbbc857de093c9a007e6b104a1a9ffbdb
 B0 = 223b7836fb19fdf64ba2d3cd6173c6a283141f78
 C1 = 2cb49e443aa675eab8add679938ca6cd303ae353
 T1 = 2e457f998ff6a6163f89e091bc4d6b92c8ed2a28
-T3 = 6d5f482d15035cdd7733b1b551d1fead28d22592
-T2 = 74c148aa829dcd83ad2608b6d0862ae1e6981501
-C4 = 7b4c1808849fabbe6f5afcd94ff930defbda47f3
+T2 = 6d5f482d15035cdd7733b1b551d1fead28d22592
+B1 = 8ab2a145f1f16e50d78eaced3311ac16027db494
 T0 = 93664bfc7cc096fcc0d1ac962596031e10f26906
 C0 = c38a9f7427b84ed8ba5e187ec385489d82d71695
 C3 = e028a8e769407c249d118ddc499f0c064685ba16
-B1 = f70f10e4db19068f79bc43844b49f3eece45c4e8
+B2 = f70f10e4db19068f79bc43844b49f3eece45c4e8
+C4 = fb6e9845e1d808bd1257db0bb3462a1747d1d2d9
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 3552c50528b..c452076045f 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -58,6 +58,24 @@ pub(crate) struct Conflict {
 }
 
 impl Conflict {
+    pub(crate) fn from_rebase(
+        rebase: super::rebase::Conflict,
+        repository_path: &Path,
+        bare: bool,
+        revisions: &[OsString],
+        include_worktrees: bool,
+    ) -> Self {
+        Conflict {
+            rebase,
+            repository_path: repository_path.to_owned(),
+            bare,
+            revisions: revisions.to_vec(),
+            include_worktrees,
+            ref_rewrites: Vec::new(),
+            ref_changes: Vec::new(),
+        }
+    }
+
     pub(crate) fn original(&self) -> ObjectId {
         self.rebase.original()
     }
@@ -1496,6 +1514,8 @@ mod tests {
             .env("GIT_COMMITTER_DATE", "2000-01-04T00:00:00 +0000")
             .status()?;
         assert!(commit.success(), "the fixture descendant commit is created");
+        let root = repository.rev_parse_single("HEAD~3")?.detach();
+        git(fixture.path(), &["checkout", "-q", "--detach", &root.to_string()])?;
         let graph = super::super::loaded_graph(&repository)?;
         super::super::rebase::perform(
             &repository,
@@ -1506,9 +1526,9 @@ mod tests {
         )?
         .complete()?;
         let graph = super::super::loaded_graph(&repository)?;
-        let root = repository.rev_parse_single("HEAD~2")?.detach();
         let tip = repository.find_reference("refs/heads/main")?.id().detach();
         drop(repository);
+        git(fixture.path(), &["checkout", "-q", "main"])?;
         Ok((fixture, repository_path, root, tip, graph))
     }
 
@@ -2380,12 +2400,11 @@ mod tests {
         let repository_path = repository.git_dir().to_owned();
         let graph = super::super::loaded_graph(&repository)?;
         let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
         let old_tip = repository.head_id()?.detach();
         let mut commit = repository.find_commit(middle)?.decode()?.into_owned()?;
-        commit.tree = repository
-            .find_commit(repository.rev_parse_single("HEAD~2")?)?
-            .tree_id()?
-            .detach();
+        commit.tree = repository.find_commit(root)?.tree_id()?.detach();
+        git(fixture.path(), &["checkout", "-q", "--detach", &root.to_string()])?;
         let marked = super::super::rebase::perform(
             &repository,
             &graph,
diff --git a/gix-tix/src/edit/todo.rs b/gix-tix/src/edit/todo.rs
index 3479c22d99b..f53e211beb1 100644
--- a/gix-tix/src/edit/todo.rs
+++ b/gix-tix/src/edit/todo.rs
@@ -1503,21 +1503,40 @@ mod tests {
     #[test]
     fn an_unchanged_todo_replays_pending_commits_with_normal_plan_semantics() -> gix_testtools::Result {
         let (fixture, repo) = repo()?;
-        let (base, middle, _tip, _) = commits(&repo)?;
+        let (base, middle, old_tip, _) = commits(&repo)?;
         let graph = super::super::loaded_graph(&repo)?;
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
         commit.tree = repo.find_commit(base)?.tree_id()?.detach();
-        let marked = rebase::perform(
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "--detach", &base.to_string()])
+                .status()?
+                .success(),
+            "the pending stack is prepared away from the current checkout"
+        );
+        let marked_outcome = rebase::perform(
             &repo,
             &graph,
             rebase::Edit::Replace { target: middle, commit },
             rebase::Signature::InvalidateExisting,
             rebase::Tree::LeaveAsIsAndMark,
         )?
-        .complete()?
-        .selected
-        .expect("the pending replacement selects its rewritten commit");
-        let tip = repo.head_id()?.detach();
+        .complete()?;
+        let marked = marked_outcome
+            .selected
+            .expect("the pending replacement selects its rewritten commit");
+        let tip = marked_outcome.map(old_tip).context("the pending tip is retained")?;
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["checkout", "-q", "main"])
+                .status()?
+                .success(),
+            "the pending branch is checked out before preparing its todo"
+        );
         let commits = vec![
             Commit {
                 id: tip,
diff --git a/gix-tix/src/enrich.rs b/gix-tix/src/enrich.rs
index 8b4544ba0b3..e6420bced77 100644
--- a/gix-tix/src/enrich.rs
+++ b/gix-tix/src/enrich.rs
@@ -182,7 +182,25 @@ pub(crate) fn apply_headers(
     commit_id: ObjectId,
     headers: &Headers,
 ) -> Result<Option<Enrichment>> {
-    let current = load(&mut open(repo)?, crate::change_id::for_commit(repo, commit_id)?)?;
+    let Some((object, data, desired)) = prepare_headers(repo, commit_id, headers)? else {
+        return Ok(None);
+    };
+    let reference: FullName = REF_NAME.try_into().expect("the tix enrich reference is valid");
+    open(repo)?
+        .add_to_ref(reference.as_ref(), object, data)
+        .map_err(gix::Exn::into_error)
+        .context("could not write the tix enrichment")?;
+    Ok(Some(desired))
+}
+
+pub(crate) fn prepare_headers(
+    repo: &gix::Repository,
+    commit_id: ObjectId,
+    headers: &Headers,
+) -> Result<Option<(ObjectId, BString, Enrichment)>> {
+    let change_id = crate::change_id::for_commit(repo, commit_id)?;
+    let mut notes = open(repo)?;
+    let current = load(&mut notes, change_id)?;
     let note = match (
         headers.message.as_ref().map(|message| message.as_bstr()),
         current.note.as_ref().map(|note| note.as_bstr()),
@@ -210,24 +228,24 @@ pub(crate) fn apply_headers(
     if desired == current {
         return Ok(None);
     }
-    update(repo, commit_id, |config| {
-        let mut section = config
-            .section_mut_or_create_new("commit", None)
-            .context("could not create the commit enrichment section")?;
-        section
-            .set("todo", if desired.todo { "true" } else { "false" })
-            .context("could not update commit.todo")?;
-        match desired.note.as_ref().map(|note| note.as_bstr()) {
-            Some(note) => {
-                section.set("note", note).context("could not update commit.note")?;
-            }
-            None => {
-                section.remove("note");
-            }
+    let object = ObjectId::from(change_id);
+    let mut config = load_config(&mut notes, object)?.unwrap_or_default();
+    let mut section = config
+        .section_mut_or_create_new("commit", None)
+        .context("could not create the commit enrichment section")?;
+    section
+        .set("todo", if desired.todo { "true" } else { "false" })
+        .context("could not update commit.todo")?;
+    match desired.note.as_ref().map(|note| note.as_bstr()) {
+        Some(note) => {
+            section.set("note", note).context("could not update commit.note")?;
         }
-        Ok(())
-    })
-    .map(Some)
+        None => {
+            section.remove("note");
+        }
+    }
+    drop(section);
+    Ok(Some((object, config.to_bstring(), desired)))
 }
 
 fn update(
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a53f0ec9a50..75bcbbb8d46 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -73,6 +73,32 @@ struct FillRepository {
     retain: bool,
 }
 
+struct PendingConflictResolution {
+    commit: gix::ObjectId,
+    head: Option<ConflictHead>,
+    ref_changes: Vec<edit::undo::RefChange>,
+    record_undo: bool,
+}
+
+struct ConflictHead {
+    reference: Option<gix::refs::FullName>,
+    parents: Vec<gix::ObjectId>,
+}
+
+enum ExternalConflictResolution {
+    Current,
+    Changed,
+    Complete(gix::ObjectId, Vec<edit::undo::RefChange>, bool),
+}
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum ConflictReconcileStatus {
+    Inactive,
+    Amend,
+    Blocked,
+    Complete,
+}
+
 struct WorktreeWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
@@ -867,10 +893,11 @@ fn event_loop(
     let mut history_status_deadline: Option<Instant> = None;
     let mut pending_terminal_event = None;
     let mut pending_rebase_conflict: Option<edit::time_travel::Conflict> = None;
+    let mut pending_conflict_clear_undo_on_accept = false;
     let mut pending_todo_rebase_conflict: Option<edit::rebase::PlanConflict> = None;
     let mut pending_todo_rebase_plan: Option<edit::rebase::Plan> = None;
     let mut pending_todo_ref_changes = Vec::new();
-    let mut pending_conflict_ref_changes = Vec::new();
+    let mut pending_conflict_resolution: Option<PendingConflictResolution> = None;
     let result: Result<Option<Duration>> = (|| loop {
         if let Some(mut recovered) =
             recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
@@ -913,6 +940,7 @@ fn event_loop(
             dirty = true;
             urgent = true;
         }
+        let mut conflict_refresh_due = false;
         let mut worktree_watch_error = None;
         if let Some(watcher) = worktree_watcher.as_mut() {
             let mut received = 0;
@@ -956,6 +984,7 @@ fn event_loop(
             urgent = true;
         }
         if take_due(&mut worktree_refresh_deadline, Instant::now()) {
+            conflict_refresh_due = true;
             if std::mem::take(&mut worktree_watch_set_changed) {
                 match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => worktree_watcher = Some(watcher),
@@ -1013,6 +1042,7 @@ fn event_loop(
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
+            conflict_refresh_due = true;
             app.clear_enrichments();
             if std::mem::take(&mut ref_watch_set_changed) {
                 match start_ref_watcher(&repository_path, &common_dir) {
@@ -1036,6 +1066,19 @@ fn event_loop(
                 urgent = true;
             }
         }
+        if conflict_refresh_due
+            && reconcile_external_conflict_reporting(
+                &mut app,
+                &repository_path,
+                repository_is_bare,
+                &mut pending_conflict_resolution,
+            ) == ConflictReconcileStatus::Complete
+        {
+            invalidate_worktree_changes(&mut worktree_changes);
+            refresh_pending = true;
+            dirty = true;
+            urgent = true;
+        }
         if take_due(&mut watcher_retry_deadline, Instant::now()) {
             let mut retry = false;
             if ref_watcher.is_none() {
@@ -1655,10 +1698,27 @@ fn event_loop(
             fill_repository.retain = false;
             fill_repository.retained = None;
         }
+        let conflict_reconcile = if action == Some(Action::ForceQuit) {
+            ConflictReconcileStatus::Inactive
+        } else {
+            reconcile_external_conflict_reporting(
+                &mut app,
+                &repository_path,
+                repository_is_bare,
+                &mut pending_conflict_resolution,
+            )
+        };
+        if conflict_reconcile == ConflictReconcileStatus::Complete {
+            invalidate_worktree_changes(&mut worktree_changes);
+            refresh_pending = true;
+            dirty = true;
+            urgent = true;
+        }
         if key_pressed
             && action == Some(Action::OpenDiff)
             && app.changes_focus.is_none()
-            && !pending_conflict_ref_changes.is_empty()
+            && pending_conflict_resolution.is_some()
+            && conflict_reconcile == ConflictReconcileStatus::Amend
         {
             action = Some(Action::Amend);
         }
@@ -1668,14 +1728,19 @@ fn event_loop(
             && pending_todo_rebase_conflict.is_none()
             && app.has_rebase_conflict()
         {
-            let recorded = record_and_clear_pending_undo(
-                &repository_path,
-                repository_is_bare,
-                "materialize time-travel conflict",
-                &mut pending_conflict_ref_changes,
-            );
+            let recorded = pending_conflict_resolution.as_mut().and_then(|pending| {
+                pending.record_undo.then(|| {
+                    record_and_clear_pending_undo(
+                        &repository_path,
+                        repository_is_bare,
+                        "materialize time-travel conflict",
+                        &mut pending.ref_changes,
+                    )
+                })
+            });
+            pending_conflict_resolution = None;
             app.clear_rebase_conflict();
-            if let Err(err) = recorded {
+            if let Some(Err(err)) = recorded {
                 app.leave_attention(format!("cancelled conflict; undo history: {err:#}"));
             }
             dirty = true;
@@ -1684,20 +1749,39 @@ fn event_loop(
         }
         if key_pressed && pending_rebase_conflict.is_some() {
             if action == Some(Action::OpenDiff) && app.changes_focus.is_none() {
+                let clear_undo_on_accept = std::mem::take(&mut pending_conflict_clear_undo_on_accept);
+                let record_undo = !clear_undo_on_accept;
                 let conflict = pending_rebase_conflict
                     .take()
                     .expect("a pending conflict was checked before accepting it");
                 let original = conflict.original();
                 match conflict.accept() {
-                    Ok((notice, id, _, ref_changes)) => {
-                        pending_conflict_ref_changes = ref_changes;
+                    Ok((mut notice, id, _, ref_changes)) => {
+                        if clear_undo_on_accept
+                            && let Err(err) = clear_undo_history(&repository_path, repository_is_bare)
+                        {
+                            notice = format!("{notice}; undo history: {err:#}");
+                        }
+                        let head = match conflict_head(&repository_path, repository_is_bare, id) {
+                            Ok(head) => Some(head),
+                            Err(err) => {
+                                notice = format!("{notice}; external-amend detection is unavailable: {err:#}");
+                                None
+                            }
+                        };
+                        pending_conflict_resolution = Some(PendingConflictResolution {
+                            commit: id,
+                            head,
+                            ref_changes,
+                            record_undo,
+                        });
                         tracing::info!(commit_id = %original, rewritten_id = %id, "accepted suspended rebase conflict");
                         app.begin_conflict_resolution();
                         app.leave_attention(notice);
                         app.select_commit_after_refresh(id);
                     }
                     Err(err) => {
-                        pending_conflict_ref_changes.clear();
+                        pending_conflict_resolution = None;
                         tracing::warn!(commit_id = %original, error = %err, "suspended rebase conflict checkout failed");
                         app.clear_rebase_conflict();
                         app.leave_error(format!("conflict checkout: {err:#}"));
@@ -1727,19 +1811,22 @@ fn event_loop(
                 continue;
             }
             if action == Some(Action::Cancel) && app.changes_focus.is_none() {
+                let record_undo = !std::mem::take(&mut pending_conflict_clear_undo_on_accept);
                 let conflict = pending_rebase_conflict
                     .take()
                     .expect("a pending conflict was checked before discarding it");
                 tracing::info!(commit_id = %conflict.original(), "discarded suspended rebase conflict");
                 let mut changes = conflict.into_ref_changes();
-                let recorded = record_and_clear_pending_undo(
-                    &repository_path,
-                    repository_is_bare,
-                    "time travel before conflict",
-                    &mut changes,
-                );
+                let recorded = record_undo.then(|| {
+                    record_and_clear_pending_undo(
+                        &repository_path,
+                        repository_is_bare,
+                        "time travel before conflict",
+                        &mut changes,
+                    )
+                });
                 app.clear_rebase_conflict();
-                if let Err(err) = recorded {
+                if let Some(Err(err)) = recorded {
                     app.leave_attention(format!("cancelled conflict; undo history: {err:#}"));
                 }
                 dirty = true;
@@ -1914,11 +2001,13 @@ fn event_loop(
             urgent = true;
             continue;
         }
-        if !pending_conflict_ref_changes.is_empty()
-            && action != Some(Action::Amend)
+        if pending_conflict_resolution.is_some()
+            && !(action == Some(Action::Amend) && conflict_reconcile == ConflictReconcileStatus::Amend)
             && !action_allowed_during_rebase_continuation(action.as_ref(), app.changes_focus.is_some())
         {
-            app.leave_attention("resolve the checked-out conflict, then press <enter> to amend");
+            if conflict_reconcile == ConflictReconcileStatus::Amend {
+                app.leave_attention("resolve the checked-out conflict, then press <enter> to amend");
+            }
             dirty = true;
             urgent = true;
             continue;
@@ -1943,6 +2032,7 @@ fn event_loop(
             tree_changes.as_ref().map(|(_, changes)| changes),
             worktree_changes.as_ref().map(|(_, changes)| changes),
         );
+        let force_quit = action == Action::ForceQuit;
         dirty = true;
         urgent |= !throttles_draw;
         let previous_changes_mode = app.changes_mode;
@@ -2032,7 +2122,7 @@ fn event_loop(
                             let position = plan.position.clone();
                             match plan.apply(&repository) {
                                 Ok(()) => {
-                                    pending_conflict_ref_changes.clear();
+                                    pending_conflict_resolution = None;
                                     app.show_undo_position(
                                         position.undo,
                                         position.undo + position.redo,
@@ -2138,12 +2228,12 @@ fn event_loop(
                         enhanced_keyboard,
                     );
                     match result {
-                        Ok(Some(edit::reword::Outcome {
+                        Ok(Some(edit::reword::Perform::Complete(edit::reword::Outcome {
                             target,
                             commit: Some(new_id),
                             ref_changes,
                             ..
-                        })) => {
+                        }))) => {
                             leave_recorded_success(
                                 &mut app,
                                 &repository_path,
@@ -2159,12 +2249,12 @@ fn event_loop(
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
-                        Ok(Some(edit::reword::Outcome {
+                        Ok(Some(edit::reword::Perform::Complete(edit::reword::Outcome {
                             target,
                             enrichment: Some(enrichment),
                             ref_changes,
                             ..
-                        })) => {
+                        }))) => {
                             app.clear_enrichments();
                             app.set_enrichment(target, enrichment);
                             leave_recorded_success(
@@ -2180,8 +2270,22 @@ fn event_loop(
                                 refresh_pending = true;
                             }
                         }
+                        Ok(Some(edit::reword::Perform::Conflict(rebase))) => {
+                            let conflict = edit::time_travel::Conflict::from_rebase(
+                                rebase,
+                                &repository_path,
+                                repository_is_bare,
+                                &revisions,
+                                false,
+                            );
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = false;
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Ok(None) => {}
-                        Ok(Some(outcome)) => {
+                        Ok(Some(edit::reword::Perform::Complete(outcome))) => {
                             if outcome.target != id {
                                 app.select_commit_after_refresh(outcome.target);
                                 refresh_pending = true;
@@ -2210,7 +2314,7 @@ fn event_loop(
                             )
                         });
                     match result {
-                        Ok(Some(outcome)) => {
+                        Ok(Some(edit::rebase::Perform::Complete(outcome))) => {
                             let new_id = outcome.selected.context("creating a commit did not select it")?;
                             leave_recorded_success(
                                 &mut app,
@@ -2223,6 +2327,20 @@ fn event_loop(
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
                         }
+                        Ok(Some(edit::rebase::Perform::Conflict(rebase))) => {
+                            let conflict = edit::time_travel::Conflict::from_rebase(
+                                rebase,
+                                &repository_path,
+                                repository_is_bare,
+                                &revisions,
+                                false,
+                            );
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = false;
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Ok(None) => app.leave_attention("no commit created: no input was provided"),
                         Err(err) => app.leave_error(format!("new commit: {err:#}")),
                     }
@@ -2245,7 +2363,7 @@ fn event_loop(
                             )
                         });
                     match created {
-                        Ok(Some(outcome)) => {
+                        Ok(Some(edit::rebase::Perform::Complete(outcome))) => {
                             let new_id = outcome.selected.context("creating a fork did not select it")?;
                             let ref_changes = outcome.ref_changes;
                             let review_roots: Vec<_> =
@@ -2293,6 +2411,7 @@ fn event_loop(
                                     let original = conflict.original();
                                     app.arm_rebase_conflict(original);
                                     app.select_commit(original);
+                                    pending_conflict_clear_undo_on_accept = false;
                                     pending_rebase_conflict = Some(conflict);
                                 }
                                 Err(err) => {
@@ -2312,6 +2431,20 @@ fn event_loop(
                                 }
                             }
                         }
+                        Ok(Some(edit::rebase::Perform::Conflict(rebase))) => {
+                            let conflict = edit::time_travel::Conflict::from_rebase(
+                                rebase,
+                                &repository_path,
+                                repository_is_bare,
+                                &revisions,
+                                false,
+                            );
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = false;
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Ok(None) => app.leave_attention("no fork created: no input was provided"),
                         Err(err) => app.leave_error(format!("fork: {err:#}")),
                     }
@@ -2389,7 +2522,7 @@ fn event_loop(
                             path.and_then(|path| {
                                 let repository = open_repository(&repository_path, repository_is_bare, false)
                                     .context("could not open repository for HEAD edit")?;
-                                if kind == edit::head::Kind::Amend && !pending_conflict_ref_changes.is_empty() {
+                                if kind == edit::head::Kind::Amend && pending_conflict_resolution.is_some() {
                                     stage_resolved_conflict_paths(&repository)?;
                                 }
                                 edit::head::perform_with_changes(
@@ -2397,31 +2530,40 @@ fn event_loop(
                                     graph,
                                     kind,
                                     path.as_ref().map(|(path, parent)| (path, *parent)),
+                                    pending_conflict_resolution.is_some(),
                                 )
                             })
                         });
                     match result {
                         Ok(Some(outcome)) => {
                             let new_id = outcome.selected.context("editing HEAD did not select its result")?;
-                            let mut changes = if kind == edit::head::Kind::Amend {
-                                std::mem::take(&mut pending_conflict_ref_changes)
+                            let pending = if kind == edit::head::Kind::Amend {
+                                pending_conflict_resolution.take()
                             } else {
-                                Vec::new()
+                                None
                             };
-                            let resolved_conflict = !changes.is_empty();
+                            let resolved_conflict = pending.is_some();
+                            let record_undo = pending.as_ref().is_none_or(|pending| pending.record_undo);
+                            let mut changes = pending.map(|pending| pending.ref_changes).unwrap_or_default();
                             changes.extend(outcome.ref_changes.iter().cloned());
-                            leave_recorded_success(
-                                &mut app,
-                                &repository_path,
-                                repository_is_bare,
-                                if resolved_conflict {
-                                    "resolve rebase conflict"
-                                } else {
-                                    verb
-                                },
-                                &changes,
-                                format!("{verb}ed {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7)),
-                            );
+                            let message =
+                                format!("{verb}ed {} as {}", id.to_hex_with_len(7), new_id.to_hex_with_len(7));
+                            if record_undo {
+                                leave_recorded_success(
+                                    &mut app,
+                                    &repository_path,
+                                    repository_is_bare,
+                                    if resolved_conflict {
+                                        "resolve rebase conflict"
+                                    } else {
+                                        verb
+                                    },
+                                    &changes,
+                                    message,
+                                );
+                            } else {
+                                app.leave_success(message);
+                            }
                             invalidate_worktree_changes(&mut worktree_changes);
                             app.select_commit_after_refresh(new_id);
                             refresh_pending = true;
@@ -2474,7 +2616,7 @@ fn event_loop(
                             forget_commit(&repository_path, repository_is_bare, graph, id)
                         });
                     match result {
-                        Ok(outcome) => {
+                        Ok(edit::forget::Perform::Complete(outcome)) => {
                             let ref_changes = outcome.ref_changes.clone();
                             let returned = outcome.review_return.as_ref().map(|name| {
                                 edit::time_travel::checkout_review_return_reporting(
@@ -2540,6 +2682,20 @@ fn event_loop(
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
+                        Ok(edit::forget::Perform::Conflict(conflict)) => {
+                            let conflict = edit::time_travel::Conflict::from_rebase(
+                                conflict.into_rebase(),
+                                &repository_path,
+                                repository_is_bare,
+                                &revisions,
+                                false,
+                            );
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = false;
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Err(err) => app.leave_error(format!("forget: {err:#}")),
                     }
                 }
@@ -2836,12 +2992,12 @@ fn event_loop(
                         .and_then(|graph| {
                             let mut repo = open_repository(&repository_path, repository_is_bare, false)
                                 .context("could not open repository to finish review")?;
-                            edit::undo::clear(&repo).context("could not clear undo history before finishing review")?;
                             repo.object_cache_size(None);
                             edit::review::finish(repo, graph, id, return_to)
                         });
                     match result {
                         Ok(edit::review::Finish::Complete(finished)) => {
+                            let undo_cleared = clear_undo_history(&repository_path, repository_is_bare);
                             let checkout = edit::time_travel::checkout_plan_reporting(
                                 &repository_path,
                                 repository_is_bare,
@@ -2849,10 +3005,13 @@ fn event_loop(
                                 &revisions,
                                 false,
                             );
-                            let message = checkout.map_or_else(
+                            let mut message = checkout.map_or_else(
                                 |err| format!("review applied, return checkout failed: {err:#}"),
                                 |(_, _changes)| format!("finished review as {}", finished.commit.to_hex_with_len(7)),
                             );
+                            if let Err(err) = undo_cleared {
+                                message = format!("{message}; undo history: {err:#}");
+                            }
                             app.dismiss_undo_position();
                             app.leave_success(message);
                             app.select_commit_after_refresh(finished.outcome.selected.unwrap_or(finished.commit));
@@ -2866,6 +3025,20 @@ fn event_loop(
                                 );
                             }
                         }
+                        Ok(edit::review::Finish::Conflict(rebase)) => {
+                            let conflict = edit::time_travel::Conflict::from_rebase(
+                                rebase,
+                                &repository_path,
+                                repository_is_bare,
+                                &revisions,
+                                false,
+                            );
+                            let original = conflict.original();
+                            app.arm_rebase_conflict(original);
+                            app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = true;
+                            pending_rebase_conflict = Some(conflict);
+                        }
                         Err(err) => app.leave_error(format!("finish review: {err:#}")),
                     }
                 }
@@ -2948,6 +3121,7 @@ fn event_loop(
                             let original = conflict.original();
                             app.arm_rebase_conflict(original);
                             app.select_commit(original);
+                            pending_conflict_clear_undo_on_accept = false;
                             pending_rebase_conflict = Some(conflict);
                         }
                         Err(err) => {
@@ -3093,7 +3267,46 @@ fn event_loop(
                         ids,
                     ));
                 }
-                Effect::Quit => return Ok(None),
+                Effect::Quit if force_quit => return Ok(None),
+                Effect::Quit => {
+                    if let Some(conflict) = pending_rebase_conflict.take() {
+                        let mut changes = conflict.into_ref_changes();
+                        if !std::mem::take(&mut pending_conflict_clear_undo_on_accept)
+                            && let Err(err) = record_and_clear_pending_undo(
+                                &repository_path,
+                                repository_is_bare,
+                                "time travel before conflict",
+                                &mut changes,
+                            )
+                        {
+                            tracing::warn!(error = %err, "could not record suspended conflict before exit");
+                        }
+                    }
+                    if let Some(mut pending) = pending_conflict_resolution.take()
+                        && pending.record_undo
+                        && let Err(err) = record_and_clear_pending_undo(
+                            &repository_path,
+                            repository_is_bare,
+                            "materialize time-travel conflict",
+                            &mut pending.ref_changes,
+                        )
+                    {
+                        tracing::warn!(error = %err, "could not record materialized conflict before exit");
+                    }
+                    let todo_pending =
+                        pending_todo_rebase_conflict.take().is_some() || pending_todo_rebase_plan.take().is_some();
+                    if todo_pending
+                        && let Err(err) = record_and_clear_pending_undo(
+                            &repository_path,
+                            repository_is_bare,
+                            "materialize rebase conflict",
+                            &mut pending_todo_ref_changes,
+                        )
+                    {
+                        tracing::warn!(error = %err, "could not record materialized rebase before exit");
+                    }
+                    return Ok(None);
+                }
             }
         }
     })();
@@ -3391,6 +3604,167 @@ fn record_and_clear_pending_undo(
     result
 }
 
+fn conflict_head(repository_path: &Path, bare: bool, commit: gix::ObjectId) -> Result<ConflictHead> {
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not reopen the repository after checking out a conflict")?;
+    let head = repository.head().context("could not inspect the conflicted HEAD")?;
+    let id = head
+        .id()
+        .map(gix::Id::detach)
+        .context("the conflicted HEAD is unborn")?;
+    anyhow::ensure!(id == commit, "the conflict checkout did not leave HEAD at {commit}");
+    let reference = head.referent_name().map(ToOwned::to_owned);
+    drop(head);
+    let name = reference
+        .clone()
+        .unwrap_or_else(|| "HEAD".try_into().expect("valid reference name"));
+    anyhow::ensure!(
+        edit::undo::state(&repository, name.as_ref())? == edit::undo::State::Object(commit),
+        "the conflicted HEAD attachment does not directly reference {commit}"
+    );
+    let parents = repository
+        .find_commit(commit)
+        .context("could not find the checked-out conflict commit")?
+        .parent_ids()
+        .map(gix::Id::detach)
+        .collect();
+    Ok(ConflictHead { reference, parents })
+}
+
+fn reconcile_external_conflict(
+    repository_path: &Path,
+    bare: bool,
+    pending: &mut Option<PendingConflictResolution>,
+) -> Result<ExternalConflictResolution> {
+    let state = pending
+        .as_ref()
+        .context("external conflict reconciliation requires pending state")?;
+    let Some(expected) = state.head.as_ref() else {
+        return Ok(ExternalConflictResolution::Current);
+    };
+    let repository =
+        open_repository(repository_path, bare, false).context("could not inspect external conflict resolution")?;
+    let head = repository.head().context("could not inspect HEAD after the conflict")?;
+    let reference = head.referent_name().map(ToOwned::to_owned);
+    anyhow::ensure!(
+        reference == expected.reference,
+        "HEAD attachment changed while resolving the conflict; return to the conflict checkout or exit"
+    );
+    let replacement = head
+        .id()
+        .map(gix::Id::detach)
+        .context("HEAD became unborn while resolving the conflict")?;
+    drop(head);
+    if replacement == state.commit {
+        return Ok(ExternalConflictResolution::Current);
+    }
+
+    let replacement_commit = repository
+        .find_commit(replacement)
+        .context("the replacement HEAD is not a commit")?
+        .decode()
+        .context("could not decode the replacement HEAD commit")?
+        .into_owned()
+        .context("could not own the replacement HEAD commit")?;
+    anyhow::ensure!(
+        replacement_commit.parents.as_slice() == expected.parents,
+        "HEAD moved to an unrelated commit while resolving the conflict; return to the conflict checkout or exit"
+    );
+    let index = repository
+        .open_index()
+        .context("could not inspect the conflict index")?;
+    if index
+        .entries()
+        .iter()
+        .any(|entry| entry.stage() != gix::index::entry::Stage::Unconflicted)
+    {
+        return Ok(ExternalConflictResolution::Changed);
+    }
+    if edit::create::index_tree(&repository, &index)? != replacement_commit.tree {
+        return Ok(ExternalConflictResolution::Changed);
+    }
+
+    let name = expected
+        .reference
+        .clone()
+        .unwrap_or_else(|| "HEAD".try_into().expect("valid reference name"));
+    anyhow::ensure!(
+        edit::undo::state(&repository, name.as_ref())? == edit::undo::State::Object(replacement),
+        "HEAD no longer directly references its replacement commit"
+    );
+    let finalized = if edit::rebase::is_pending(&replacement_commit) {
+        drop(index);
+        let graph = edit::loaded_graph(&repository).context("could not load history to finalize the external amend")?;
+        let outcome = edit::head::amend_index_reporting(repository, &graph)
+            .context("could not finalize the externally amended pending commit")?
+            .context("the externally amended pending commit was not finalized")?;
+        let selected = outcome
+            .selected
+            .context("finalizing the externally amended conflict did not select its result")?;
+        Some((selected, outcome.ref_changes))
+    } else {
+        None
+    };
+    let accepted = state.commit;
+    let mut state = pending
+        .take()
+        .expect("the pending conflict was inspected immediately before completion");
+    state.ref_changes.push(edit::undo::RefChange {
+        name,
+        before: edit::undo::State::Object(accepted),
+        after: edit::undo::State::Object(replacement),
+    });
+    let replacement = match finalized {
+        Some((selected, changes)) => {
+            state.ref_changes.extend(changes);
+            selected
+        }
+        None => replacement,
+    };
+    Ok(ExternalConflictResolution::Complete(
+        replacement,
+        state.ref_changes,
+        state.record_undo,
+    ))
+}
+
+fn reconcile_external_conflict_reporting(
+    app: &mut App,
+    repository_path: &Path,
+    bare: bool,
+    pending: &mut Option<PendingConflictResolution>,
+) -> ConflictReconcileStatus {
+    if pending.is_none() {
+        return ConflictReconcileStatus::Inactive;
+    }
+    match reconcile_external_conflict(repository_path, bare, pending) {
+        Ok(ExternalConflictResolution::Complete(replacement, changes, record_undo)) => {
+            let message = format!("resolved rebase conflict as {}", replacement.to_hex_with_len(7));
+            if record_undo {
+                leave_recorded_success(app, repository_path, bare, "resolve rebase conflict", &changes, message);
+            } else {
+                app.leave_success(message);
+            }
+            app.clear_rebase_conflict();
+            app.set_worktree_conflicted(false);
+            app.select_commit_after_refresh(replacement);
+            tracing::info!(commit_id = %replacement, "recognized externally amended conflict resolution");
+            ConflictReconcileStatus::Complete
+        }
+        Ok(ExternalConflictResolution::Current) => ConflictReconcileStatus::Amend,
+        Ok(ExternalConflictResolution::Changed) => {
+            app.leave_attention(
+                "external conflict resolution is incomplete; finish it, return to the conflict checkout, or press q",
+            );
+            ConflictReconcileStatus::Blocked
+        }
+        Err(err) => {
+            app.leave_attention(format!("conflict resolution remains pending: {err:#}"));
+            ConflictReconcileStatus::Blocked
+        }
+    }
+}
+
 fn tracked_ref_update<T>(
     repo: &gix::Repository,
     name: &str,
@@ -4299,7 +4673,7 @@ fn reword_commit(
     hidden_revisions: &[OsString],
     id: gix::ObjectId,
     enhanced_keyboard: bool,
-) -> Result<Option<edit::reword::Outcome>> {
+) -> Result<Option<edit::reword::Perform>> {
     let (editor, document, change_id) = {
         let mut repository =
             open_repository(repository_path, bare, false).context("could not open repository before editing commit")?;
@@ -4323,7 +4697,7 @@ fn reword_commit(
         open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
     repository.object_cache_size(None);
     let (graph, id) = edit::reword::relocate_after_editor(&repository, revisions, hidden_revisions, change_id)?;
-    edit::reword::apply(repository, &graph, id, &edited).map(Some)
+    edit::reword::apply_conflict_reporting(repository, &graph, id, &edited).map(Some)
 }
 
 pub(crate) fn load_rebase_todo_commits(
@@ -4637,7 +5011,7 @@ fn create_commit(
     parent: Option<gix::ObjectId>,
     mode: CreateMode,
     enhanced_keyboard: bool,
-) -> Result<Option<edit::rebase::Outcome>> {
+) -> Result<Option<edit::rebase::Perform>> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before creating commit")?;
     repository.object_cache_size(None);
@@ -4664,9 +5038,10 @@ fn create_commit(
     repository.object_cache_size(None);
     let outcome = match mode {
         CreateMode::Insert | CreateMode::InsertEmpty => {
-            edit::create::apply_reporting(repository, graph, prepared, &edited)
+            edit::create::apply_conflict_reporting(repository, graph, prepared, &edited)
         }
-        CreateMode::Fork => edit::create::apply_fork_reporting(repository, graph, prepared, &edited),
+        CreateMode::Fork => edit::create::apply_fork_reporting(repository, graph, prepared, &edited)
+            .map(edit::rebase::Perform::Complete),
     }?;
     Ok(Some(outcome))
 }
@@ -4705,11 +5080,11 @@ fn forget_commit(
     bare: bool,
     graph: &HistoryGraph,
     id: gix::ObjectId,
-) -> Result<edit::forget::Outcome> {
+) -> Result<edit::forget::Perform> {
     let mut repository =
         open_repository(repository_path, bare, false).context("could not open repository before forgetting commit")?;
     repository.object_cache_size(None);
-    edit::forget::perform(repository, graph, id)
+    edit::forget::perform_conflict(repository, graph, id)
 }
 
 fn run_external_diff(
@@ -5482,6 +5857,7 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
                 | Action::CopyPath(_)
                 | Action::CopyAuthor
                 | Action::ForceQuit
+                | Action::Quit
         )
     ) || (changes_focused && matches!(action, Some(Action::OpenDiff | Action::Cancel | Action::Quit)))
 }
@@ -5696,6 +6072,126 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn recognizes_an_external_conflict_amend_and_keeps_it_undoable() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let original = repository.head_id()?.detach();
+        let mut commit = repository.find_commit(original)?.decode()?.into_owned()?;
+        let original_parent = commit
+            .parents
+            .first()
+            .copied()
+            .context("the fixture tip has a parent")?;
+        commit
+            .extra_headers
+            .push(("tix-rebase-parent".into(), original_parent.to_string().into()));
+        let accepted = repository.write_object(&commit)?.detach();
+        let status = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args([
+                "update-ref",
+                "refs/heads/main",
+                &accepted.to_string(),
+                &original.to_string(),
+            ])
+            .status()?;
+        assert!(status.success(), "the fixture checks out a materialized pending commit");
+        let head = conflict_head(fixture.path(), false, accepted)?;
+        let mut pending = Some(PendingConflictResolution {
+            commit: accepted,
+            head: Some(head),
+            ref_changes: Vec::new(),
+            record_undo: true,
+        });
+        let status = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["commit", "--amend", "-qm", "externally resolved"])
+            .status()?;
+        assert!(status.success(), "git performs the external amend");
+        let replacement = test_repository::open(fixture.path())?.head_id()?.detach();
+        assert_ne!(replacement, accepted, "the external amend replaces HEAD");
+        let replacement_commit = test_repository::open(fixture.path())?
+            .find_commit(replacement)?
+            .decode()?
+            .into_owned()?;
+        assert!(
+            edit::rebase::is_pending(&replacement_commit),
+            "git preserves the pending marker while amending"
+        );
+
+        let mut app = App::new(1);
+        assert_eq!(
+            reconcile_external_conflict_reporting(&mut app, fixture.path(), false, &mut pending),
+            ConflictReconcileStatus::Complete,
+            "a clean same-parent replacement completes conflict resolution"
+        );
+        assert!(pending.is_none(), "completed conflict state is released");
+
+        let repository = test_repository::open(fixture.path())?;
+        let finalized = repository.head_id()?.detach();
+        assert_ne!(finalized, replacement, "Tix strips the preserved pending marker");
+        assert!(
+            !edit::rebase::is_pending(&repository.find_commit(finalized)?.decode()?.into_owned()?),
+            "the recognized resolution is fully materialized"
+        );
+        edit::undo::plan_undo(&repository)?
+            .expect("the external amend was added to the undo queue")
+            .apply(&repository)?;
+        assert_eq!(
+            repository.head_id()?.detach(),
+            accepted,
+            "undo restores the materialized conflict commit"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn external_conflict_resolution_requires_a_commit_and_rejects_unrelated_head_moves() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
+        let accepted = test_repository::open(fixture.path())?.head_id()?.detach();
+        let head = conflict_head(fixture.path(), false, accepted)?;
+        let mut pending = Some(PendingConflictResolution {
+            commit: accepted,
+            head: Some(head),
+            ref_changes: Vec::new(),
+            record_undo: true,
+        });
+        std::fs::write(fixture.path().join("file"), "resolved but not committed\n")?;
+        let status = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["add", "file"])
+            .status()?;
+        assert!(status.success(), "the resolution is staged");
+        let mut app = App::new(1);
+        assert_eq!(
+            reconcile_external_conflict_reporting(&mut app, fixture.path(), false, &mut pending),
+            ConflictReconcileStatus::Amend,
+            "staging alone still requires an amend"
+        );
+        assert!(pending.is_some(), "staged state remains mandatory");
+
+        let status = Command::new("git")
+            .arg("-C")
+            .arg(fixture.path())
+            .args(["reset", "--hard", "HEAD~1"])
+            .status()?;
+        assert!(status.success(), "git moves HEAD away from the conflict checkout");
+        assert_eq!(
+            reconcile_external_conflict_reporting(&mut app, fixture.path(), false, &mut pending),
+            ConflictReconcileStatus::Blocked,
+            "an unrelated external HEAD move is not mistaken for conflict resolution"
+        );
+        assert!(
+            pending.is_some(),
+            "invalid external movement remains explicit until exit"
+        );
+        Ok(())
+    }
+
     #[test]
     fn retains_unseen_filesystem_redraws_until_focus_returns() {
         assert!(!unseen_filesystem_redraw(false, false, false));
@@ -7159,13 +7655,16 @@ mod tests {
             Action::Rebase,
             Action::TimeTravel,
             Action::VerifySignatures,
-            Action::Quit,
         ] {
             assert!(
                 !action_allowed_during_rebase_continuation(Some(&action), false),
                 "{action:?} cannot invalidate a materialized rebase"
             );
         }
+        assert!(
+            action_allowed_during_rebase_continuation(Some(&Action::Quit), false),
+            "history q always remains available"
+        );
         for action in [Action::OpenDiff, Action::Cancel, Action::Quit] {
             assert!(
                 action_allowed_during_rebase_continuation(Some(&action), true),

From 135dcccf3885111594da07352f9458e4f5a79a65 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 11:02:51 +0200
Subject: [PATCH 257/282] fix(gix-tix): keep commit titles beside selected
 notes

Prefix the selected commit title with its highlighted note title and an unstyled separator instead of replacing the commit title.
---
 gix-tix/spec.md   |  6 ++--
 gix-tix/src/ui.rs | 70 +++++++++++++++++++++++++++++++----------------
 2 files changed, 50 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 8c724d6735d..6a90bf27df0 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -290,9 +290,9 @@ without trading responsiveness for metadata that is not visible.
   field remains visible alongside selection, dirty-worktree, and conflict markers.
   `tix show` emits the same field and aligns unmarked rows when any displayed
   commit has either enrichment.
-- Only the selected history row replaces its commit title with its note title,
-  using black text on a yellow background. Unselected rows and `tix show` retain
-  the commit title.
+- Only the selected history row prefixes its commit title with its note title,
+  using black text on a yellow background followed by one unstyled space.
+  Unselected rows and `tix show` retain only the commit title.
 - Commit and selected-note titles render Markdown styling. Block-shaped title
   output is flattened onto the single history row; plain command output retains
   the rendered text without terminal styling.
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 52a0f8e2c1c..99552be9ed2 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -577,13 +577,13 @@ pub(crate) fn draw_with_worktree(
             };
             let row = &app.rows[*row_index];
             let row_selected = selected == Some(start + index);
-            let title = row_selected.then(|| app.note(row.id)).flatten().map_or_else(
-                || app.title(row),
-                |note| gix::objs::commit::MessageRef::from_bytes(note).title,
-            );
+            let note_title = row_selected
+                .then(|| app.note(row.id))
+                .flatten()
+                .map(|note| gix::objs::commit::MessageRef::from_bytes(note).title);
             let mut metadata = metadata_columns(
                 row,
-                title,
+                app.title(row),
                 app.attributions(row),
                 decorations,
                 mailmap,
@@ -595,7 +595,7 @@ pub(crate) fn draw_with_worktree(
                     show_emails: app.show_emails,
                     show_trailers,
                     has_notes: !app.notes(row.id).is_empty(),
-                    note: row_selected && app.note(row.id).is_some(),
+                    note_title,
                     use_mailmap: app.use_mailmap && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
                     selected: (row_selected && app.show_selection_tail) || compared_parent == Some(row.id),
@@ -2226,7 +2226,7 @@ fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
 }
 
 #[derive(Clone, Copy)]
-struct MetadataOptions {
+struct MetadataOptions<'a> {
     date_mode: DateMode,
     id_mode: IdMode,
     change_id: gix::hash::ChangeId,
@@ -2234,7 +2234,7 @@ struct MetadataOptions {
     show_emails: bool,
     show_trailers: bool,
     has_notes: bool,
-    note: bool,
+    note_title: Option<&'a BStr>,
     use_mailmap: bool,
     ref_mode: RefMode,
     selected: bool,
@@ -2281,7 +2281,7 @@ fn metadata_columns<'a>(
     attributions: &'a [crate::app::Attribution],
     decorations: &'a Decorations,
     mailmap: &'a gix::mailmap::Snapshot,
-    options: MetadataOptions,
+    options: MetadataOptions<'a>,
 ) -> MetadataColumns<'a> {
     debug_assert!(row.metadata_loaded, "visible rows have metadata");
     let MetadataOptions {
@@ -2292,7 +2292,7 @@ fn metadata_columns<'a>(
         show_emails,
         show_trailers,
         has_notes,
-        note,
+        note_title,
         use_mailmap,
         ref_mode,
         selected,
@@ -2500,13 +2500,15 @@ fn metadata_columns<'a>(
     }
     let mut title_spans = Vec::new();
     if !show_emails {
-        let mut title = markdown_title_spans(title);
-        if note {
-            for span in &mut title {
+        if let Some(note_title) = note_title {
+            let mut note_title = markdown_title_spans(note_title);
+            for span in &mut note_title {
                 span.style = span.style.patch(note_style());
             }
+            title_spans.extend(note_title);
+            title_spans.push(Span::raw(" "));
         }
-        title_spans.extend(title);
+        title_spans.extend(markdown_title_spans(title));
     }
     MetadataColumns {
         fields: [
@@ -2526,7 +2528,7 @@ fn metadata_line<'a>(
     attributions: &'a [crate::app::Attribution],
     decorations: &'a Decorations,
     mailmap: &'a gix::mailmap::Snapshot,
-    options: MetadataOptions,
+    options: MetadataOptions<'a>,
 ) -> Line<'a> {
     metadata_columns(row, title, attributions, decorations, mailmap, options).into_line()
 }
@@ -2553,7 +2555,7 @@ pub(crate) fn plain_history_metadata(
             show_emails: app.show_emails,
             show_trailers: app.name_mode == NameMode::All && app.show_trailers,
             has_notes,
-            note: false,
+            note_title: None,
             use_mailmap: app.use_mailmap,
             ref_mode: app.ref_mode,
             selected: false,
@@ -2584,7 +2586,7 @@ pub(crate) fn todo_metadata(app: &App, row: &CommitRow, mailmap: &gix::mailmap::
             show_emails: app.show_emails,
             show_trailers: app.name_mode == crate::app::NameMode::All && app.show_trailers,
             has_notes: !app.notes(row.id).is_empty(),
-            note: false,
+            note_title: None,
             use_mailmap: app.use_mailmap,
             ref_mode: app.ref_mode,
             selected: false,
@@ -3029,14 +3031,36 @@ mod tests {
         assert_eq!(row[(6, 0)].symbol(), ">", "selection directly follows enrichments");
         assert_eq!(row[(8, 0)].symbol(), "●", "the graph remains separate");
         assert!(
-            rendered_line(&terminal, 0).contains("follow-up title"),
-            "the selected todo displays its note title"
+            rendered_line(&terminal, 0).contains("follow-up title subject"),
+            "the selected todo prefixes its title with the note title"
         );
         let title_x = (0..80)
             .find(|x| row[(*x, 0)].symbol() == "f")
             .expect("the note title is visible");
         assert_eq!(row[(title_x, 0)].fg, Color::Black);
         assert_eq!(row[(title_x, 0)].bg, Color::Yellow);
+        let separator = &row[(title_x + 15, 0)];
+        assert_eq!(separator.symbol(), " ", "a space separates both titles");
+        assert_eq!(separator.fg, Color::Reset, "the separator has no foreground color");
+        assert_eq!(separator.bg, Color::Reset, "the separator has no background color");
+        assert!(separator.modifier.is_empty(), "the separator has no modifiers");
+        let commit_title = &row[(title_x + 16, 0)];
+        assert_eq!(commit_title.symbol(), "s", "the commit title follows the note title");
+        assert_eq!(
+            commit_title.fg,
+            Color::Reset,
+            "the commit title has its normal foreground"
+        );
+        assert_eq!(
+            commit_title.bg,
+            Color::Reset,
+            "the commit title has its normal background"
+        );
+        assert_eq!(
+            commit_title.modifier,
+            Modifier::empty(),
+            "the commit title has its normal modifiers"
+        );
         assert!(
             (0..80).any(|x| row[(x, 0)].symbol() == "t" && row[(x, 0)].modifier.contains(Modifier::ITALIC)),
             "the Markdown title is italicized"
@@ -3065,8 +3089,8 @@ mod tests {
         );
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert!(
-            rendered_line(&terminal, 0).contains("follow-up title"),
-            "a note replaces the selected title independently of todo"
+            rendered_line(&terminal, 0).contains("follow-up title subject"),
+            "a note prefixes the selected title independently of todo"
         );
         assert_eq!(terminal.backend().buffer()[(0, 0)].symbol(), " ");
         assert_eq!(terminal.backend().buffer()[(2, 0)].symbol(), "📝");
@@ -6819,7 +6843,7 @@ mod tests {
                 show_emails: false,
                 show_trailers: true,
                 has_notes: false,
-                note: false,
+                note_title: None,
                 use_mailmap: false,
                 ref_mode: RefMode::All,
                 selected: false,
@@ -6928,7 +6952,7 @@ mod tests {
                 show_emails: false,
                 show_trailers: false,
                 has_notes: false,
-                note: false,
+                note_title: None,
                 use_mailmap: false,
                 ref_mode: RefMode::None,
                 selected: false,

From 89172b79b80f6ceb6b6ddbbf4c4259962f06fe90 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 13:04:34 +0200
Subject: [PATCH 258/282] fix(gix-tix): distinguish off-worktree selections

Keep the compact selection treatment for the current worktree, while reversing an off-worktree selection from the row start through its non-title metadata. Preserve an uninverted separator and title.
---
 gix-tix/spec.md   | 10 +++---
 gix-tix/src/ui.rs | 77 +++++++++++++++++++++++++++++++++++++++--------
 2 files changed, 71 insertions(+), 16 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6a90bf27df0..c4fa3d126a2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -236,10 +236,12 @@ without trading responsiveness for metadata that is not visible.
   entries are skipped without failing history loading.
 - The selected row uses `>` at the left. If the displayed worktree block is dirty,
   `🫟` is shown at the `HEAD` row instead; a separately selected row retains `>`.
-- Selection inversion covers the left marker, graph, commit marker, and hash.
-  Its graph background is derived from the commit-marker color. The selected
-  row's right-hand tail and contextual information always have blank margins and
-  never invert an adjacent character.
+- When selection points at the current worktree, inversion covers the left
+  marker, graph, commit marker, and hash. A separately selected row extends that
+  inversion from the row's start through all non-title metadata; its final space
+  and title remain uninverted. The graph background is derived from the
+  commit-marker color. The selected row's right-hand tail and contextual
+  information always have blank margins and never invert an adjacent character.
 - A compared merge parent is cyan, including its commit marker, and its hash is
   inverted.
 - Rows outside active review-base reachability are dimmed. When a changes block has
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 99552be9ed2..ece15879c0e 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -646,15 +646,19 @@ pub(crate) fn draw_with_worktree(
         .enumerate()
         .map(|(index, metadata)| {
             metadata.map(|metadata| match alignment {
-                HistoryAlignment::None => (metadata.into_line(), 0),
+                HistoryAlignment::None => {
+                    let (metadata, prefix_width) = metadata.into_line_with_prefix();
+                    (metadata, 0, prefix_width)
+                }
                 HistoryAlignment::Title | HistoryAlignment::Compressed => {
                     let lane_width = lanes.lane(index).chars().count();
-                    (
-                        metadata.align_title(title_column.saturating_sub(lane_width)),
-                        lane_width,
-                    )
+                    let (metadata, prefix_width) = metadata.align_title(title_column.saturating_sub(lane_width));
+                    (metadata, lane_width, prefix_width)
+                }
+                HistoryAlignment::Columns => {
+                    let (metadata, prefix_width) = metadata.align_columns(column_widths);
+                    (metadata, max_lane_width, prefix_width)
                 }
-                HistoryAlignment::Columns => (metadata.align_columns(column_widths), max_lane_width),
             })
         })
         .collect();
@@ -667,7 +671,7 @@ pub(crate) fn draw_with_worktree(
                 .chars()
                 .count()
                 .saturating_add(format!("[{count}]").chars().count()),
-            (HistoryEntry::Commit(_), Some((metadata, metadata_x))) => match alignment {
+            (HistoryEntry::Commit(_), Some((metadata, metadata_x, _))) => match alignment {
                 HistoryAlignment::None => lanes.lane(index).chars().count().saturating_add(metadata.width()),
                 HistoryAlignment::Title | HistoryAlignment::Columns | HistoryAlignment::Compressed => {
                     metadata_x.saturating_add(metadata.width())
@@ -734,7 +738,7 @@ pub(crate) fn draw_with_worktree(
             }
         };
         let row = &app.rows[row_index];
-        let (metadata, metadata_x) = metadata.expect("commit history entries have metadata");
+        let (metadata, metadata_x, metadata_prefix_width) = metadata.expect("commit history entries have metadata");
         let selected = app.selected == Some(row_index);
         let head = decorations.get(&row.id).is_some_and(|decorations| {
             decorations
@@ -752,6 +756,12 @@ pub(crate) fn draw_with_worktree(
             attached: attached_head,
         });
         let metadata_width = metadata.width();
+        let title_offset = match alignment {
+            HistoryAlignment::None => lane.chars().count().saturating_add(metadata_prefix_width),
+            HistoryAlignment::Title | HistoryAlignment::Columns | HistoryAlignment::Compressed => {
+                metadata_x.saturating_add(metadata_prefix_width)
+            }
+        };
         let hidden_branch_behind = app.hidden_branch_behind(row.id);
         let line_width = match alignment {
             HistoryAlignment::None => lane
@@ -852,6 +862,21 @@ pub(crate) fn draw_with_worktree(
             row.signature,
             head_state,
         );
+        if selected && app.show_selection_tail && !head {
+            let end = if title_offset > horizontal_offset {
+                content
+                    .x
+                    .saturating_add(u16::try_from(title_offset - horizontal_offset).unwrap_or(u16::MAX))
+                    .saturating_sub(1)
+            } else {
+                content.x
+            }
+            .min(body.right());
+            frame.buffer_mut().set_style(
+                Rect::new(body.x, y, end.saturating_sub(body.x), 1),
+                Style::default().add_modifier(Modifier::REVERSED),
+            );
+        }
         if selected && app.show_selection_tail && body.width > 0 {
             let marker_limit = hidden_branch_marker
                 .as_ref()
@@ -2259,19 +2284,24 @@ impl<'a> MetadataColumns<'a> {
         )
     }
 
-    fn align_title(mut self, width: usize) -> Line<'a> {
+    fn into_line_with_prefix(self) -> (Line<'a>, usize) {
+        let prefix_width = self.prefix_width();
+        (self.into_line(), prefix_width)
+    }
+
+    fn align_title(mut self, width: usize) -> (Line<'a>, usize) {
         let padding = width.saturating_sub(self.prefix_width());
         self.fields[4].spans.push(Span::raw(" ".repeat(padding)));
-        self.into_line()
+        self.into_line_with_prefix()
     }
 
-    fn align_columns(mut self, widths: [usize; 5]) -> Line<'a> {
+    fn align_columns(mut self, widths: [usize; 5]) -> (Line<'a>, usize) {
         for (field, width) in self.fields[..5].iter_mut().zip(widths) {
             field
                 .spans
                 .push(Span::raw(" ".repeat(width.saturating_sub(field.width()))));
         }
-        self.into_line()
+        self.into_line_with_prefix()
     }
 }
 
@@ -3867,6 +3897,29 @@ mod tests {
             "completed work cannot be cancelled"
         );
 
+        terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
+        let rendered = rendered_row(&terminal);
+        let title_byte = rendered.find("subject").expect("the selected commit title is visible");
+        let title_x = rendered[..title_byte].chars().count() as u16;
+        let row = terminal.backend().buffer();
+        assert!(
+            (0..title_x - 1).all(|x| row[(x, 0)].modifier.contains(Modifier::REVERSED)),
+            "an off-worktree selection reverses the entire non-title prefix"
+        );
+        assert_eq!(
+            row[(title_x - 1, 0)].symbol(),
+            " ",
+            "metadata keeps its title separator"
+        );
+        assert!(
+            !row[(title_x - 1, 0)].modifier.contains(Modifier::REVERSED),
+            "the metadata-title separator is not reversed"
+        );
+        assert!(
+            (title_x..title_x + "subject".len() as u16).all(|x| !row[(x, 0)].modifier.contains(Modifier::REVERSED)),
+            "the selected commit title is not reversed"
+        );
+
         app.unseen_filesystem_redraw = true;
         terminal.draw(|frame| super::draw(frame, &mut app, &decorations, &mailmap, None, None))?;
         for (x, _) in footer_text

From c86ed180c364086cebb2085433e97730d1a1c5db Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 13:17:25 +0200
Subject: [PATCH 259/282] fix(gix-tix): defer tree changes while scrolling

Temporarily hide enabled changes panes during repeated history navigation and restore them after the existing idle deadline. Keep this debounce independent from the removed frame animation machinery.
---
 gix-tix/spec.md    |  5 ++++-
 gix-tix/src/app.rs |  6 +++++-
 gix-tix/src/lib.rs | 27 ++++++++++++++++++++-------
 gix-tix/src/ui.rs  | 22 ++++++++++++++++++++++
 4 files changed, 51 insertions(+), 9 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c4fa3d126a2..ae70c26e291 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -613,7 +613,10 @@ space first; changes blocks adapt within the remaining history width.
   block shows its distinct status line.
 - `p` cycles the comparison parent while Tree has focus. Merge commits are
   compared to one parent at a time; root commits compare against an empty tree.
-- History navigation leaves enabled changes overlays visible.
+- Repeated history keys, including printable `j`/`k` reported through enhanced
+  keyboard input, and vertical mouse bursts temporarily hide changes
+  overlays. They return after 75 ms of navigation idle, with the same path
+  selection and viewport where possible.
 - Tree diff results, detached diff resources, and line counts use a bounded MRU
   while changes remain enabled. Worktree results are cached separately and
   invalidated by relevant filesystem events.
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 6c166a70bc0..ff7495d7257 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -541,6 +541,7 @@ pub(crate) struct App {
     pub show_commit: bool,
     pub changes_mode: Option<ChangesMode>,
     worktree_changes_available: bool,
+    pub(crate) changes_suppressed: bool,
     pub(crate) changes_focus: Option<ChangePane>,
     pub(crate) changes_layout: ChangesLayout,
     pub(crate) tree_changes_visible: bool,
@@ -648,6 +649,7 @@ impl App {
             show_commit: false,
             changes_mode: Some(ChangesMode::Both),
             worktree_changes_available: true,
+            changes_suppressed: false,
             changes_focus: None,
             changes_layout: ChangesLayout::SideBySide,
             tree_changes_visible: false,
@@ -1622,6 +1624,7 @@ impl App {
                 self.reset_changes_view();
                 self.changes_parent = 0;
                 if self.changes_mode.is_none() {
+                    self.changes_suppressed = false;
                     self.changes_focus = None;
                 }
             }
@@ -2300,6 +2303,7 @@ impl App {
         self.lane_time = None;
         self.estimated_lane_width = 0;
         self.show_hidden = show_hidden;
+        self.changes_suppressed = false;
         self.horizontal_offset = 0;
         self.focus_history();
         self.reset_commit_view();
@@ -2400,7 +2404,7 @@ impl App {
     }
 
     pub(crate) fn changes_visible(&self) -> bool {
-        self.changes_mode.is_some() && self.pending_rebase_conflict.is_none()
+        self.changes_mode.is_some() && !self.changes_suppressed && self.pending_rebase_conflict.is_none()
     }
 
     fn ensure_changes_visible(&mut self) {
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 75bcbbb8d46..5c560c23f9d 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1130,8 +1130,14 @@ fn event_loop(
         }
         if repeat_deadline.is_some_and(|deadline| Instant::now() >= deadline) {
             repeat_deadline = None;
-            fill_repository.retain = false;
-            fill_repository.retained = None;
+            if app.changes_suppressed {
+                app.changes_suppressed = false;
+                dirty = true;
+                urgent = true;
+            } else {
+                fill_repository.retain = false;
+                fill_repository.retained = None;
+            }
         }
         if let Some(result) = verification_receiver.as_ref().map(mpsc::Receiver::try_recv) {
             match result {
@@ -1666,6 +1672,7 @@ fn event_loop(
             }
             TerminalEvent::FocusLost => {
                 focused = false;
+                app.changes_suppressed = false;
                 repeat_deadline = None;
                 dirty = true;
                 urgent = true;
@@ -1698,6 +1705,14 @@ fn event_loop(
             fill_repository.retain = false;
             fill_repository.retained = None;
         }
+        if repeats_history && app.changes_mode.is_some() {
+            app.changes_suppressed = true;
+        } else if !is_repeat && app.changes_suppressed {
+            app.changes_suppressed = false;
+            repeat_deadline = None;
+            dirty = true;
+            urgent = true;
+        }
         let conflict_reconcile = if action == Some(Action::ForceQuit) {
             ConflictReconcileStatus::Inactive
         } else {
@@ -7578,11 +7593,9 @@ mod tests {
 
     #[test]
     fn retains_the_fill_repository_only_for_repeated_viewport_navigation() {
-        assert!(retains_fill_repository(
-            KeyEventKind::Repeat,
-            Some(&Action::MoveDown),
-            false
-        ));
+        for action in [Action::MoveDown, Action::PageDown] {
+            assert!(retains_fill_repository(KeyEventKind::Repeat, Some(&action), false));
+        }
         assert!(!retains_fill_repository(
             KeyEventKind::Repeat,
             Some(&Action::MoveDown),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index ece15879c0e..70ca8e1740a 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -5820,6 +5820,28 @@ mod tests {
         );
         assert!(!rendered_line(&terminal, 15).contains("<tab> switch"));
 
+        app.changes_suppressed = true;
+        app.information_expanded = true;
+        terminal.draw(|frame| {
+            super::draw(
+                frame,
+                &mut app,
+                &Decorations::new(),
+                &gix::mailmap::Snapshot::default(),
+                None,
+                Some(&changes),
+            );
+        })?;
+        assert!(
+            !rendered_line(&terminal, 7).contains("files changed"),
+            "repeated history navigation temporarily hides the changes pane"
+        );
+        assert!(
+            app.changes_mode.is_some() && !popup_is_dim(&terminal, "changes"),
+            "temporary suppression leaves the persistent changes setting enabled"
+        );
+        app.changes_suppressed = false;
+
         app.update(Action::ToggleChangesFocus);
         app.update(Action::MoveDown);
         terminal.draw(|frame| {

From 89b2cbd883e795a93c07cec44f18dbffa5bad447 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 14:24:06 +0200
Subject: [PATCH 260/282] fix(gix-tix): eagerly finalize empty rebased commits

Finalize zero-delta commits as soon as their rewritten parent is final, and keep linked worktree indexes synchronized without touching worktree bytes.
---
 gix-tix/spec.md                 |  25 +++--
 gix-tix/src/edit/rebase.rs      | 181 +++++++++++++++++++++++++++-----
 gix-tix/src/edit/time_travel.rs |  45 ++++----
 3 files changed, 188 insertions(+), 63 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index ae70c26e291..add9adfff4e 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -784,20 +784,22 @@ space first; changes blocks adapt within the remaining history width.
   need no replay marker; rewritten descendants use the same lazy rebase as amend
   and spill.
 - All three operations leave worktree files untouched and cheaply rewrite linear
-  descendants with their trees unchanged. Whole-commit edits reset the affected
+  descendants. Whole-commit edits reset the affected
   worktree's index to the rewritten commit; selected-path amend synchronizes only
-  its destination and renamed source. A directly amended or spilled commit already
-  has its final tree and unchanged parent, so an empty signature field alone keeps
-  a formerly signed commit pending. Reparented descendants additionally carry
-  `tix-rebase-parent`, retaining the original parent needed for later replay. Both
-  pending forms use a grey commit marker so they remain distinct from unsigned blue.
+  its destination and renamed source. A zero-delta commit immediately adopts and
+  is signed against its rewritten parent tree whenever that parent is final; it
+  remains lazy only behind a pending parent. Other reparented descendants carry
+  `tix-rebase-parent`, retaining the original parent needed for later replay.
+  Pending forms use a grey commit marker so they remain distinct from unsigned
+  blue.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
 - Time travel toward a pending destination cherry-picks and signs only the pending
-  ancestry through that destination. Every later descendant is reparented and
-  becomes or remains lazy and unsigned, including ordinary commits created above
-  pending history; traveling toward a non-pending ancestor leaves the entire
-  pending region untouched. A completed final replay does not reload history;
+  ancestry through that destination. Later non-empty descendants become or
+  remain lazy and unsigned; zero-delta descendants finalize immediately while
+  their parent is final and remain lazy behind a pending parent. Traveling toward
+  a non-pending ancestor leaves the entire pending region untouched. A completed
+  final replay does not reload history;
   another pass loads only the rewritten path and never unrelated references.
   A conflict retains the ours tree, exact merge-result
   tree, conflict stages, prepared commits, and in-memory objects without changing
@@ -919,7 +921,8 @@ space first; changes blocks adapt within the remaining history width.
   cherry-picks that affected path before committing the operation. The edited
   root of a direct amend or spill already has its final tree and does not receive
   a redundant worktree transition. Descendants on unrelated branches and in
-  other worktrees remain lazy. A successful repeated rebase clears the marker
+  other worktrees remain lazy unless their delta is empty and their parent is
+  final. A successful repeated rebase clears the marker
   through its checkout destination.
   On conflict, `tix-rebase-parent` identifies the original base and later descendants
   remain marked instead of being cherry-picked.
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index e8dc2164b1c..96dc7d7d9c8 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -383,7 +383,7 @@ impl PersistedConflict {
 struct Prepared {
     repo: gix::Repository,
     root: Option<ObjectId>,
-    reset_index: bool,
+    reset_indices: HashSet<ObjectId>,
     reset_index_paths: Option<Vec<BString>>,
     skip_worktree_transitions: bool,
     selected: Option<ObjectId>,
@@ -1050,6 +1050,7 @@ fn perform_inner(
     let mut selected = None;
     let mut conflict = None;
     let mut eager_checkout_rewrite = false;
+    let mut finalized_empty = HashSet::new();
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
@@ -1119,13 +1120,28 @@ fn perform_inner(
                 Some(old_id) != root && checkout_path.contains(&old_id)
             };
         eager_checkout_rewrite |= !repeat && eager;
-        let commit_tree_mode = if eager {
+        let mut commit_tree_mode = if eager {
             Tree::CherryPick
         } else if repeat || conflict.is_some() {
             Tree::LeaveAsIsAndMark
         } else {
             tree_mode
         };
+        let finalize_empty = conflict.is_none()
+            && matches!(
+                commit_tree_mode,
+                Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants
+            )
+            && empty_commit_has_final_parent(
+                &repo,
+                commit.tree,
+                original_parents.first().copied(),
+                new_parents.first().copied(),
+            )?;
+        if finalize_empty {
+            commit_tree_mode = Tree::CherryPick;
+            finalized_empty.insert(old_id);
+        }
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
@@ -1157,7 +1173,7 @@ fn perform_inner(
         let is_conflicting_commit = new_conflict.is_some();
         let signature = if conflict.is_some() || is_conflicting_commit || (repeat && !eager) {
             Signature::InvalidateExisting
-        } else if eager {
+        } else if eager || finalize_empty {
             Signature::RedoIfNeeded
         } else {
             signature
@@ -1200,15 +1216,24 @@ fn perform_inner(
     let marked = (!forked && matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants))
         || conflict.is_some();
     let checkout_after_finish = conflict.is_some();
+    let skip_worktree_transitions = !eager_checkout_rewrite
+        && (inserted
+            || forked
+            || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed));
+    let mut reset_indices: HashSet<_> = ((inserted && reset_index) || (!inserted && marked))
+        .then_some(root)
+        .flatten()
+        .into_iter()
+        .collect();
+    if skip_worktree_transitions {
+        reset_indices.extend(finalized_empty);
+    }
     let mut prepared = Prepared {
         repo,
         root,
-        reset_index: if inserted { reset_index } else { marked },
+        reset_indices,
         reset_index_paths,
-        skip_worktree_transitions: !eager_checkout_rewrite
-            && (inserted
-                || forked
-                || (matches!(tree_mode, Tree::LeaveAsIsAndMark | Tree::LeaveAsIsAndMarkDescendants) && !removed)),
+        skip_worktree_transitions,
         selected,
         note_rewrites,
         stash_rewritten: rewritten.clone(),
@@ -1380,11 +1405,21 @@ pub(super) fn finish_review(
         let original_parents =
             recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
         let eager = conflict.is_none() && checkout_path.contains(&old);
-        let mode = if eager {
+        let mut mode = if eager {
             Tree::CherryPick
         } else {
             Tree::LeaveAsIsAndMark
         };
+        let finalize_empty = conflict.is_none()
+            && empty_commit_has_final_parent(
+                &repo,
+                commit.tree,
+                original_parents.first().copied(),
+                new_parents.first().copied(),
+            )?;
+        if finalize_empty {
+            mode = Tree::CherryPick;
+        }
         let mut new_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &original_parents, &new_parents, mode)? {
             TreeRewrite::Complete(tree) => tree,
@@ -1398,7 +1433,7 @@ pub(super) fn finish_review(
             }
         };
         commit.parents = new_parents.into_iter().collect();
-        let pending = !eager || conflict.is_some() || new_conflict.is_some();
+        let pending = !(eager || finalize_empty) || conflict.is_some() || new_conflict.is_some();
         let new = write_commit(
             &repo,
             commit,
@@ -1428,7 +1463,7 @@ pub(super) fn finish_review(
     let mut prepared = Prepared {
         repo,
         root: Some(review),
-        reset_index: false,
+        reset_indices: HashSet::new(),
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected: Some(selected),
@@ -1618,7 +1653,10 @@ pub(crate) fn perform_plan_with_progress(
             || graph_parents.clone(),
             |parent| parent.into_iter().collect::<Vec<_>>(),
         );
-        let mode = if eager {
+        let finalize_empty = conflict.is_none()
+            && step.squash.is_empty()
+            && empty_commit_has_final_parent(&repo, commit.tree, replay_parents.first().copied(), Some(parent))?;
+        let mode = if eager || finalize_empty {
             Tree::CherryPick
         } else {
             Tree::LeaveAsIsAndMark
@@ -1705,7 +1743,7 @@ pub(crate) fn perform_plan_with_progress(
         commit.parents = [parent].into_iter().collect();
         let state = if step_conflict.is_some() {
             CommitState::Unmarked(Signature::InvalidateExisting)
-        } else if eager {
+        } else if eager || finalize_empty {
             CommitState::Unmarked(Signature::RedoIfNeeded)
         } else {
             marked = true;
@@ -1844,7 +1882,7 @@ pub(crate) fn perform_plan_with_progress(
     let mut prepared = Prepared {
         repo,
         root: Some(plan.base),
-        reset_index: marked,
+        reset_indices: marked.then_some(plan.base).into_iter().collect(),
         reset_index_paths: None,
         skip_worktree_transitions: false,
         selected,
@@ -1896,7 +1934,7 @@ pub(crate) fn perform_plan_with_progress(
     prepared.selected = None;
     prepared.checkout_reference = None;
     prepared.checkout_after_finish = true;
-    prepared.reset_index = false;
+    prepared.reset_indices.clear();
     prepared.rewritten = final_refs
         .iter()
         .filter_map(|expected| expected.old.map(|old| (old, expected.new)))
@@ -2029,9 +2067,8 @@ impl Prepared {
             self.expected_refs.as_deref(),
             self.skip_worktree_transitions,
         )?;
-        let index_reset_from = if self.reset_index { self.root } else { None };
-        let index_resets = index_reset_from
-            .map(|old| index_resets(&self.repo, &self.rewritten, old))
+        let index_resets = (!self.reset_indices.is_empty())
+            .then(|| index_resets(&self.repo, &self.rewritten, &self.reset_indices))
             .transpose()?;
         for transition in &transitions {
             super::forget::preflight_tree_transition(
@@ -2256,7 +2293,7 @@ fn rollback<T>(
 fn index_resets(
     repo: &gix::Repository,
     rewritten: &HashMap<ObjectId, Option<ObjectId>>,
-    reset_from: ObjectId,
+    reset_from: &HashSet<ObjectId>,
 ) -> Result<Vec<IndexReset>> {
     let mut repos = vec![
         repo.main_repo()
@@ -2280,7 +2317,7 @@ fn index_resets(
         else {
             continue;
         };
-        if old != reset_from {
+        if !reset_from.contains(&old) {
             continue;
         }
         let Some(Some(new)) = rewritten.get(&old).copied() else {
@@ -2573,6 +2610,21 @@ fn parent_tree(repo: &gix::Repository, parent: Option<ObjectId>) -> Result<Objec
     }
 }
 
+fn empty_commit_has_final_parent(
+    repo: &gix::Repository,
+    tree: ObjectId,
+    original_parent: Option<ObjectId>,
+    rewritten_parent: Option<ObjectId>,
+) -> Result<bool> {
+    if tree != parent_tree(repo, original_parent)? {
+        return Ok(false);
+    }
+    let Some(parent) = rewritten_parent else {
+        return Ok(true);
+    };
+    Ok(!is_pending(&repo.find_commit(parent)?.decode()?.into_owned()?))
+}
+
 fn marker(commit: &mut gix::objs::Commit, add: bool, original_parent: Option<ObjectId>) {
     commit
         .extra_headers
@@ -3034,10 +3086,10 @@ mod tests {
         )?)
     }
 
-    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result {
+    fn git(path: &Path, args: &[&str]) -> gix_testtools::Result<Vec<u8>> {
         let output = Command::new("git").arg("-C").arg(path).args(args).output()?;
         if output.status.success() {
-            Ok(())
+            Ok(output.stdout)
         } else {
             Err(format!(
                 "git {} failed: {}",
@@ -3315,7 +3367,7 @@ mod tests {
     }
 
     #[test]
-    fn a_repeat_accepts_ordinary_descendants_above_legacy_signed_pending_commits() -> gix_testtools::Result {
+    fn a_repeat_finalizes_empty_descendants_above_legacy_signed_pending_commits() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
         assert!(
             Command::new("git")
@@ -3405,21 +3457,23 @@ mod tests {
             .map(legacy_tip)
             .expect("the selected pending commit is retained");
         assert!(!has_marker(&repo.find_commit(selected)?.decode()?.into_owned()?));
+        let mut parent = selected;
         for id in [legacy_newer, ordinary].into_iter().map(|id| {
             outcome
                 .map(id)
                 .expect("every descendant is retained while repeating the rebase")
         }) {
             let commit = repo.find_commit(id)?.decode()?.into_owned()?;
-            assert!(has_marker(&commit), "later descendants become or remain pending");
+            assert!(!is_pending(&commit), "empty descendants of a final parent are final");
+            assert_eq!(commit.parents.first().copied(), Some(parent));
             assert!(
                 commit
                     .extra_headers
                     .iter()
-                    .filter(|(name, _)| name == "gpgsig" || name == "gpgsig-sha256")
-                    .all(|(_, value)| value.is_empty()),
-                "later pending descendants have no usable signature"
+                    .all(|(name, _)| name != "gpgsig" && name != "gpgsig-sha256"),
+                "final unsigned descendants discard stale signatures"
             );
+            parent = id;
         }
         Ok(())
     }
@@ -3449,6 +3503,72 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn empty_descendants_of_a_finalized_parent_are_not_left_pending() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let base = repo.rev_parse_single("HEAD~2")?.detach();
+        let middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let tip = repo.head_id()?.detach();
+        drop(repo);
+        git(fixture.path(), &["checkout", "-q", "--detach", &base.to_string()])?;
+
+        let repo = open(fixture.path())?;
+        let mut empty = repo.find_commit(tip)?.decode()?.into_owned()?;
+        empty.tree = repo.find_commit(middle)?.tree_id()?.detach();
+        let empty = repo.write_object(&empty)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(empty, "prepare an empty descendant")?;
+        drop(repo);
+        let linked_root = gix_testtools::tempfile::tempdir()?;
+        let linked = linked_root.path().join("linked");
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["worktree", "add", "-q"])
+                .arg(&linked)
+                .arg("main")
+                .status()?
+                .success(),
+            "the empty descendant is checked out in a linked worktree"
+        );
+
+        let repo = open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let mut spilled = repo.find_commit(middle)?.decode()?.into_owned()?;
+        spilled.tree = repo.find_commit(base)?.tree_id()?.detach();
+
+        let outcome = perform(
+            &repo,
+            &graph,
+            Edit::Replace {
+                target: middle,
+                commit: spilled,
+            },
+            Signature::InvalidateExisting,
+            Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let middle = outcome.map(middle).context("the spilled commit is retained")?;
+        let empty = outcome.map(empty).context("the empty descendant is retained")?;
+        let middle = repo.find_commit(middle)?.decode()?.into_owned()?;
+        let empty = repo.find_commit(empty)?.decode()?.into_owned()?;
+
+        assert!(!is_pending(&middle), "the edited commit is final");
+        assert!(!is_pending(&empty), "its empty descendant is final too");
+        assert_eq!(
+            empty.tree, middle.tree,
+            "the empty descendant follows its final parent tree"
+        );
+        assert_eq!(
+            git(&linked, &["status", "--short"])?,
+            b"?? middle\n",
+            "the linked index follows the finalized commit while spilled bytes stay in its worktree"
+        );
+        Ok(())
+    }
+
     #[test]
     fn rewrites_every_fork_without_flattening_it() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -3955,12 +4075,15 @@ mod tests {
         );
         let rewritten_descendant = outcome.map(descendant).context("the descendant is retained")?;
         let descendant = repo.find_commit(rewritten_descendant)?.decode()?.into_owned()?;
-        assert!(has_marker(&descendant), "history above the checkout remains lazy");
+        assert!(
+            !is_pending(&descendant),
+            "an empty descendant of the finalized checkout is final too"
+        );
         assert_eq!(descendant.parents.as_slice(), [rewritten_checkout]);
         assert_eq!(
             repo.find_reference("refs/heads/main")?.id().detach(),
             rewritten_descendant,
-            "the branch follows the lazily rewritten tip"
+            "the branch follows the finalized empty tip"
         );
         let progress = progress.last().context("rebase progress is reported")?;
         assert_eq!(progress.processed, 3);
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index c452076045f..9b649e5f19e 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -2500,26 +2500,26 @@ mod tests {
 
         let repository = open()?;
         let graph = super::super::loaded_graph(&repository)?;
-        let pending_middle =
+        let spilled_middle =
             super::super::head::perform(repository.clone(), &graph, super::super::head::Kind::Spill, None)?
                 .expect("spilling changes the middle commit");
         let pending_tip = repository.find_reference("refs/heads/main")?.id().detach();
-        let middle_commit = repository.find_commit(pending_middle)?.decode()?.into_owned()?;
+        let middle_commit = repository.find_commit(spilled_middle)?.decode()?.into_owned()?;
         let tip_commit = repository.find_commit(pending_tip)?.decode()?.into_owned()?;
-        assert!(super::super::rebase::is_pending(&middle_commit));
+        assert!(
+            !super::super::rebase::is_pending(&middle_commit),
+            "the fully spilled commit has its final tree and parent"
+        );
         assert!(
             !super::super::rebase::has_marker(&middle_commit),
             "the authoritative spilled tree needs no original-parent marker"
         );
-        let authors = gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(
-            history::Authors::default(),
-        ));
-        assert_eq!(
-            history::load_metadata(&repository, pending_middle, &authors)?
-                .0
-                .signature,
-            crate::app::SignatureState::PendingRebase,
-            "an empty signature keeps the authoritative commit visibly pending"
+        assert!(
+            repository
+                .find_commit(spilled_middle)?
+                .verify_signature()?
+                .expect("the fully spilled commit is signed immediately")
+                .is_valid()
         );
         assert!(super::super::rebase::has_marker(&tip_commit));
         drop(repository);
@@ -2529,8 +2529,8 @@ mod tests {
         perform(&repository_path, false, root, &graph, &[], &[], false)?.complete()?;
         let repository = open()?;
         assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), pending_tip);
-        assert!(super::super::rebase::is_pending(
-            &repository.find_commit(pending_middle)?.decode()?.into_owned()?
+        assert!(!super::super::rebase::is_pending(
+            &repository.find_commit(spilled_middle)?.decode()?.into_owned()?
         ));
         assert!(super::super::rebase::is_pending(
             &repository.find_commit(pending_tip)?.decode()?.into_owned()?
@@ -2539,21 +2539,20 @@ mod tests {
         drop(repository);
 
         let mut rebased = Vec::new();
-        perform_reporting_rebased(&repository_path, false, pending_middle, &graph, &[], &[], false, |id| {
+        perform_reporting_rebased(&repository_path, false, spilled_middle, &graph, &[], &[], false, |id| {
             rebased.push(id);
         })?
         .complete()?;
-        assert_eq!(
-            rebased,
-            [pending_middle, pending_tip],
-            "the selected commit and its pending descendant are reported in replay order"
+        assert!(
+            rebased.is_empty(),
+            "travelling to a final commit does not replay its pending descendant"
         );
 
         let repository = open()?;
         let materialized_middle = repository.head_id()?.detach();
         let still_pending_tip = repository.find_reference("refs/heads/main")?.id().detach();
-        assert_ne!(materialized_middle, pending_middle);
-        assert_ne!(still_pending_tip, pending_tip);
+        assert_eq!(materialized_middle, spilled_middle);
+        assert_eq!(still_pending_tip, pending_tip);
         let middle_commit = repository.find_commit(materialized_middle)?;
         assert!(!super::super::rebase::is_pending(
             &middle_commit.decode()?.into_owned()?
@@ -2561,7 +2560,7 @@ mod tests {
         assert!(
             middle_commit
                 .verify_signature()?
-                .expect("returning to the spilled commit adds its configured signature")
+                .expect("the fully spilled commit retained its configured signature")
                 .is_valid()
         );
         drop(middle_commit);
@@ -2572,7 +2571,7 @@ mod tests {
         assert!(
             history::all_pins(&repository)?
                 .iter()
-                .all(|pin| pin.id != pending_middle),
+                .all(|pin| pin.id != spilled_middle),
             "travelling to a rewritten detached HEAD does not pin its predecessor"
         );
         let graph = super::super::loaded_graph(&repository)?;

From 7e249928058b8b9893873822ee0a41dc771634fe Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 14:48:22 +0200
Subject: [PATCH 261/282] fix(gix-tix): preserve unaffected commits and invert
 selected rows

Skip commit writing for final descendants whose effective parents did not change while retaining eager conflict detection for affected checkout history.

Render every selected history row as one inversion through its title and remove the obsolete selection-tail state.
---
 gix-tix/spec.md            |  18 ++---
 gix-tix/src/app.rs         |   2 -
 gix-tix/src/edit/rebase.rs |  50 ++++++++++++++
 gix-tix/src/ui.rs          | 131 ++++++++++++++++---------------------
 4 files changed, 117 insertions(+), 84 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index add9adfff4e..85b3c967aca 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -216,7 +216,8 @@ without trading responsiveness for metadata that is not visible.
   loaded, unless the user navigates first. Once the viewport is known, the row
   is centered with normal history-boundary clamping so surrounding commits are
   visible. While the row is unselected, its title is shown in reverse video and
-  `@` is bold; a selected row keeps only bold `@`.
+  `@` is bold; the selected row's normal inversion replaces that title emphasis
+  while keeping `@` bold.
 - Local branches checked out in other worktrees are displayed as `short-name@`
   in light blue instead of their plain branch decoration. The current worktree's
   symbolic branch is displayed as `@short-name` in the local-reference color.
@@ -236,12 +237,12 @@ without trading responsiveness for metadata that is not visible.
   entries are skipped without failing history loading.
 - The selected row uses `>` at the left. If the displayed worktree block is dirty,
   `🫟` is shown at the `HEAD` row instead; a separately selected row retains `>`.
-- When selection points at the current worktree, inversion covers the left
-  marker, graph, commit marker, and hash. A separately selected row extends that
-  inversion from the row's start through all non-title metadata; its final space
-  and title remain uninverted. The graph background is derived from the
-  commit-marker color. The selected row's right-hand tail and contextual
-  information always have blank margins and never invert an adjacent character.
+- A selected row at the current worktree is inverted from its left edge through
+  the final displayed title character. Any other selected row is inverted through
+  its non-title metadata, leaving the final space and title uninverted. The graph
+  background is derived from the commit-marker color. The selected row's
+  right-hand tail and contextual information remain separate, have blank margins,
+  and never invert an adjacent character.
 - A compared merge parent is cyan, including its commit marker, and its hash is
   inverted.
 - Rows outside active review-base reachability are dimmed. When a changes block has
@@ -791,7 +792,8 @@ space first; changes blocks adapt within the remaining history width.
   remains lazy only behind a pending parent. Other reparented descendants carry
   `tix-rebase-parent`, retaining the original parent needed for later replay.
   Pending forms use a grey commit marker so they remain distinct from unsigned
-  blue.
+  blue. A final descendant whose effective parents did not change retains its
+  exact commit instead of being replayed merely because it is checked out.
 - Edit graph discovery follows refs that point to commits and ignores refs whose
   targets are trees, blobs, or other non-commit objects.
 - Time travel toward a pending destination cherry-picks and signs only the pending
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ff7495d7257..30eab7193ba 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -553,7 +553,6 @@ pub(crate) struct App {
     pub(crate) commit_pane_background: Option<(u8, u8, u8)>,
     commit_page: usize,
     commit_max: usize,
-    pub(crate) show_selection_tail: bool,
     reachability_anchor: Option<ObjectId>,
     review_tip: Option<ObjectId>,
     review_return: Option<(ObjectId, ObjectId)>,
@@ -661,7 +660,6 @@ impl App {
             commit_pane_background: None,
             commit_page: 1,
             commit_max: 0,
-            show_selection_tail: true,
             reachability_anchor: None,
             review_tip: None,
             review_return: None,
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 96dc7d7d9c8..c70360dce85 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1110,6 +1110,9 @@ fn perform_inner(
             .iter()
             .filter_map(|parent| rewritten.get(parent).copied().unwrap_or(Some(*parent)))
             .collect();
+        if Some(old_id) != root && old_parents == new_parents && !is_pending(&commit) {
+            continue;
+        }
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
         let original_parents =
             recorded_parent.map_or_else(|| old_parents.clone(), |parent| parent.into_iter().collect::<Vec<_>>());
@@ -3191,6 +3194,52 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn an_unchanged_checkout_descendant_retains_its_commit() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repo = open(fixture.path())?;
+        let old_middle = repo.rev_parse_single("HEAD~1")?.detach();
+        let old_tip = repo.head_id()?.detach();
+        let mut middle_commit = repo.find_commit(old_middle)?.decode()?.into_owned()?;
+        middle_commit.committer = repo
+            .committer()
+            .context("the test repository has a committer")?
+            .context("the test committer is valid")?
+            .to_owned()?;
+        crate::change_id::inherit(&repo, &mut middle_commit, old_middle)?;
+        let middle = repo.write_object(&middle_commit)?.detach();
+        let mut tip_commit = repo.find_commit(old_tip)?.decode()?.into_owned()?;
+        tip_commit.parents = [middle].into_iter().collect();
+        let tip = repo.write_object(&tip_commit)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(tip, "prepare an unchanged checkout descendant")?;
+        repo.find_reference("refs/patches/middle")?
+            .set_target_id(middle, "prepare an unchanged target")?;
+        repo.find_reference("refs/patches/tip")?
+            .set_target_id(tip, "prepare an unchanged checkout descendant")?;
+        let graph = super::super::loaded_graph(&repo)?;
+        let mut reported = Vec::new();
+
+        let outcome = perform_reporting_rebased(
+            &repo,
+            &graph,
+            Edit::Replace {
+                target: middle,
+                commit: middle_commit,
+            },
+            Signature::Remove,
+            Tree::LeaveAsIsAndMark,
+            |id| reported.push(id),
+        )?
+        .complete()?;
+
+        assert_eq!(outcome.map(middle), Some(middle), "the no-op target retains its ID");
+        assert_eq!(outcome.map(tip), Some(tip), "its unaffected descendant retains its ID");
+        assert_eq!(repo.head_id()?.detach(), tip, "HEAD remains on the original commit");
+        assert_eq!(reported, [middle], "only the explicit target enters commit writing");
+        Ok(())
+    }
+
     #[test]
     fn git_notes_follow_each_actual_rewritten_successor() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
@@ -3285,6 +3334,7 @@ mod tests {
         )?
         .complete()?;
         assert_eq!(outcome.selected, Some(base), "removal selects its parent");
+        assert_eq!(outcome.map(base), Some(base), "the unaffected parent retains its ID");
         let tip = repo.head_id()?.detach();
         assert_eq!(
             repo.find_commit(tip)?.parent_ids().next().map(gix::Id::detach),
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 70ca8e1740a..966fdbb309b 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -598,7 +598,7 @@ pub(crate) fn draw_with_worktree(
                     note_title,
                     use_mailmap: app.use_mailmap && copy_feedback != Some(CopyKind::Author),
                     ref_mode,
-                    selected: (row_selected && app.show_selection_tail) || compared_parent == Some(row.id),
+                    selected: row_selected || compared_parent == Some(row.id),
                     copy_feedback: if row_selected { copy_feedback } else { None },
                 },
             );
@@ -781,7 +781,7 @@ pub(crate) fn draw_with_worktree(
                     .x
                     .saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
                     .saturating_add(1)
-                    .saturating_add(if selected && app.show_selection_tail && selection_info_width > 0 {
+                    .saturating_add(if selected && selection_info_width > 0 {
                         u16::try_from(selection_info_width)
                             .unwrap_or(u16::MAX)
                             .saturating_add(3)
@@ -793,7 +793,7 @@ pub(crate) fn draw_with_worktree(
             })
         });
         let signature_color = signature_color(row.signature);
-        let highlight = if selected && app.show_selection_tail {
+        let highlight = if selected {
             Some(signature_color)
         } else if compared_parent == Some(row.id) {
             Some(COMPARED_PARENT_COLOR)
@@ -862,8 +862,10 @@ pub(crate) fn draw_with_worktree(
             row.signature,
             head_state,
         );
-        if selected && app.show_selection_tail && !head {
-            let end = if title_offset > horizontal_offset {
+        if selected {
+            let end = if head {
+                content.x.saturating_add(u16::try_from(line_width).unwrap_or(u16::MAX))
+            } else if title_offset > horizontal_offset {
                 content
                     .x
                     .saturating_add(u16::try_from(title_offset - horizontal_offset).unwrap_or(u16::MAX))
@@ -877,7 +879,7 @@ pub(crate) fn draw_with_worktree(
                 Style::default().add_modifier(Modifier::REVERSED),
             );
         }
-        if selected && app.show_selection_tail && body.width > 0 {
+        if selected && body.width > 0 {
             let marker_limit = hidden_branch_marker
                 .as_ref()
                 .map_or_else(|| body.right().saturating_sub(1), |(_, x, _)| x.saturating_sub(2));
@@ -894,14 +896,22 @@ pub(crate) fn draw_with_worktree(
                     .min(marker_x.saturating_sub(content.x).saturating_sub(2));
                 let area = Rect::new(marker_x.saturating_sub(width).saturating_sub(1), y, width, 1);
                 if width > 0 {
-                    frame.buffer_mut()[(area.x - 1, y)].set_symbol(" ");
-                    frame.render_widget(Paragraph::new(selection_info.clone()), area);
+                    frame.buffer_mut()[(area.x - 1, y)]
+                        .set_symbol(" ")
+                        .set_style(Style::default().remove_modifier(Modifier::DIM | Modifier::REVERSED));
+                    frame.render_widget(
+                        Paragraph::new(selection_info.clone())
+                            .style(Style::default().remove_modifier(Modifier::REVERSED)),
+                        area,
+                    );
                     selection_info_area = Some(area);
                 }
             }
             let buffer = frame.buffer_mut();
             if marker_x > body.x {
-                buffer[(marker_x - 1, y)].set_symbol(" ");
+                buffer[(marker_x - 1, y)]
+                    .set_symbol(" ")
+                    .set_style(Style::default().remove_modifier(Modifier::REVERSED));
             }
             buffer[(marker_x, y)].set_symbol(" ").set_style(style);
         }
@@ -918,7 +928,10 @@ pub(crate) fn draw_with_worktree(
                     .set_style(Style::default().add_modifier(Modifier::DIM));
             }
             if selected && let Some(area) = selection_info_area {
-                frame.render_widget(Paragraph::new(selection_info.clone()), area);
+                frame.render_widget(
+                    Paragraph::new(selection_info.clone()).style(Style::default().remove_modifier(Modifier::REVERSED)),
+                    area,
+                );
             }
         }
         if let Some((marker, x, width)) = hidden_branch_marker {
@@ -941,7 +954,10 @@ pub(crate) fn draw_with_worktree(
             .buffer_mut()
             .set_style(body, Style::default().add_modifier(Modifier::DIM));
         if let Some(area) = selection_info_area {
-            frame.render_widget(Paragraph::new(selection_info), area);
+            frame.render_widget(
+                Paragraph::new(selection_info).style(Style::default().remove_modifier(Modifier::REVERSED)),
+                area,
+            );
         }
     }
     for (pane_area, underlay) in changes_panes.iter().zip(&changes_pane_underlays) {
@@ -1569,7 +1585,9 @@ fn selection_info_line(changes: Option<&Changes>, relation: Option<SelectionRela
 }
 
 fn selection_color(color: Color) -> Style {
-    Style::default().fg(color).remove_modifier(Modifier::DIM)
+    Style::default()
+        .fg(color)
+        .remove_modifier(Modifier::DIM | Modifier::REVERSED)
 }
 
 fn push_selection_span(spans: &mut Vec<Span<'static>>, span: Span<'static>) {
@@ -3396,6 +3414,10 @@ mod tests {
         assert_eq!(buffer[(info_x, 0)].fg, Color::Green);
         assert_eq!(buffer[(info_x + 3, 0)].fg, Color::LightRed);
         assert!(!buffer[(info_x, 0)].modifier.contains(Modifier::DIM));
+        assert!(
+            !buffer[(info_x, 0)].modifier.contains(Modifier::REVERSED),
+            "contextual selection information stays outside the row inversion"
+        );
         let spacer_x = info_x + info.chars().count() as u16;
         assert_eq!(buffer[(spacer_x, 0)].symbol(), " ", "the marker has a left spacer");
         assert!(
@@ -3415,19 +3437,6 @@ mod tests {
         assert_eq!(buffer[(37, 0)].symbol(), " ", "a plain marker never inverts text");
         assert!(buffer[(37, 0)].modifier.contains(Modifier::REVERSED));
 
-        app.show_selection_tail = false;
-        terminal.draw(|frame| {
-            super::draw(
-                frame,
-                &mut app,
-                &Decorations::new(),
-                &gix::mailmap::Snapshot::default(),
-                None,
-                Some(&changes),
-            );
-        })?;
-        assert!(!rendered_row(&terminal).contains(info));
-
         let text = |relation| {
             selection_info_line(None, relation)
                 .spans
@@ -3833,7 +3842,7 @@ mod tests {
         let footer_text = "#0 · view · commit · actions · enrich · copy · refs · ? · quit";
         let selected_line = "      > @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
-        for x in 6..17 {
+        for x in 0..selected_line.chars().count() as u16 {
             expected[(x, 0)].set_style(Style::default().add_modifier(Modifier::REVERSED));
         }
         for x in 6..10 {
@@ -3847,10 +3856,10 @@ mod tests {
             );
         }
         for x in 18..29 {
-            expected[(x, 0)].set_style(Style::default().fg(Color::Blue));
+            expected[(x, 0)].set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         }
         for x in 29..43 {
-            expected[(x, 0)].set_style(Style::default().fg(Color::Green));
+            expected[(x, 0)].set_style(Style::default().fg(Color::Green).add_modifier(Modifier::REVERSED));
         }
         expected[(selected_line.chars().count() as u16 + 2, 0)]
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
@@ -3881,12 +3890,14 @@ mod tests {
 
         let row = terminal.backend().buffer();
         assert!(
-            row[(16, 0)].modifier.contains(Modifier::REVERSED),
-            "selection includes the final hash character"
+            (0..selected_line.chars().count() as u16).all(|x| row[(x, 0)].modifier.contains(Modifier::REVERSED)),
+            "the current worktree selection is reversed through its title"
         );
         assert!(
-            !row[(17, 0)].modifier.contains(Modifier::REVERSED),
-            "selection ends immediately after the hash"
+            !row[(selected_line.chars().count() as u16, 0)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "the current worktree selection ends after its title"
         );
         assert!(
             !rendered_row(&terminal).contains("HEAD"),
@@ -3903,21 +3914,13 @@ mod tests {
         let title_x = rendered[..title_byte].chars().count() as u16;
         let row = terminal.backend().buffer();
         assert!(
-            (0..title_x - 1).all(|x| row[(x, 0)].modifier.contains(Modifier::REVERSED)),
-            "an off-worktree selection reverses the entire non-title prefix"
-        );
-        assert_eq!(
-            row[(title_x - 1, 0)].symbol(),
-            " ",
-            "metadata keeps its title separator"
-        );
-        assert!(
-            !row[(title_x - 1, 0)].modifier.contains(Modifier::REVERSED),
-            "the metadata-title separator is not reversed"
+            (0..title_x.saturating_sub(1)).all(|x| row[(x, 0)].modifier.contains(Modifier::REVERSED)),
+            "an off-worktree selection reverses through its non-title metadata"
         );
         assert!(
-            (title_x..title_x + "subject".len() as u16).all(|x| !row[(x, 0)].modifier.contains(Modifier::REVERSED)),
-            "the selected commit title is not reversed"
+            (title_x.saturating_sub(1)..title_x + "subject".len() as u16)
+                .all(|x| !row[(x, 0)].modifier.contains(Modifier::REVERSED)),
+            "an off-worktree selection leaves a margin and its title uninverted"
         );
 
         app.unseen_filesystem_redraw = true;
@@ -4798,7 +4801,7 @@ mod tests {
     }
 
     #[test]
-    fn reverses_only_an_unselected_head_title_and_bolds_a_non_tip_marker() -> Result<(), Box<dyn std::error::Error>> {
+    fn reverses_an_unselected_head_title_and_the_full_selected_row() -> Result<(), Box<dyn std::error::Error>> {
         let head = gix::ObjectId::Sha1([1; 20]);
         let child = gix::ObjectId::Sha1([2; 20]);
         let commit = |id: gix::ObjectId, parent: Option<gix::ObjectId>| Commit {
@@ -4865,10 +4868,10 @@ mod tests {
         app.selected = Some(1);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
-            !terminal.backend().buffer()[(title, head_row)]
+            terminal.backend().buffer()[(title, head_row)]
                 .modifier
                 .contains(Modifier::REVERSED),
-            "selection removes the HEAD title emphasis"
+            "selection reverses the HEAD title as part of the full row"
         );
         assert!(
             terminal.backend().buffer()[(8, head_row)]
@@ -5021,6 +5024,12 @@ mod tests {
             Color::Reset,
             "selection takes precedence over foreign HEAD emphasis"
         );
+        assert!(
+            !terminal.backend().buffer()[(selected_title, 1)]
+                .modifier
+                .contains(Modifier::REVERSED),
+            "a selected foreign worktree title stays outside the row inversion"
+        );
         Ok(())
     }
 
@@ -6691,34 +6700,8 @@ mod tests {
             buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
             "a clipped selection marker uses the right border"
         );
-        let hash_color = buffer[(11, 1)].fg;
         assert_eq!(app.selected, Some(2), "drawing preserves the global selection");
         assert_eq!(app.offset, 1, "drawing preserves the global offset");
-
-        app.show_selection_tail = false;
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        let buffer = terminal.backend().buffer();
-        assert!(
-            !buffer[(6, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
-            "the inactive marker has no selection modifiers"
-        );
-        assert!(
-            !buffer[(11, 1)].modifier.contains(Modifier::REVERSED | Modifier::DIM),
-            "the inactive hash has no selection modifiers"
-        );
-        assert_eq!(buffer[(6, 1)].symbol(), ">", "the inactive row keeps its marker");
-        assert_eq!(buffer[(6, 1)].fg, Color::Reset, "the marker uses normal text color");
-        assert_eq!(
-            buffer[(6, 1)].bg,
-            Color::Reset,
-            "the marker has no selection background"
-        );
-        assert_eq!(buffer[(11, 1)].fg, hash_color, "the hash returns to its normal color");
-        assert_eq!(buffer[(11, 1)].bg, Color::Reset, "the hash has no selection background");
-        assert!(
-            !buffer[(23, 1)].modifier.contains(Modifier::REVERSED),
-            "the final frame hides the trailing selection marker"
-        );
         Ok(())
     }
 

From d4ea86a48387a69755519b1da13a38a92e7ee0a8 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 16:11:44 +0200
Subject: [PATCH 262/282] fix(gix-tix): retain metadata and the final
 diagnostic frame

Preserve every asynchronously loaded metadata field when lane computation replaces provisional rows, avoiding epoch dates and lost review state. Render --quit-on-finish inline on the normal screen after the completed frame so its result remains inspectable.
---
 gix-tix/spec.md    |  8 +++++---
 gix-tix/src/app.rs | 17 ++++++++++++-----
 gix-tix/src/lib.rs | 45 ++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 55 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 85b3c967aca..e67091ec7a2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -100,8 +100,9 @@ without trading responsiveness for metadata that is not visible.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
-- `--quit-on-finish` exits after traversal and lane computation, for measurement
-  and non-interactive use.
+- `--quit-on-finish` exits after traversal, lane computation, and one completed
+  frame, for measurement and non-interactive inspection. Its frame is drawn on
+  the normal screen and remains visible after exit.
 - `tix rebase todo [-x HIDDEN...] [--no-auto-hide]
   [--onto REV | --update-base] [TIP...]`
   writes a self-contained Markdown history-rebase plan to stdout. Visible tips
@@ -136,9 +137,10 @@ without trading responsiveness for metadata that is not visible.
 - Revisions must resolve and peel to commits. Invalid or non-commit visible
   revisions are errors. An unavailable hidden revision emits a warning and is
   ignored when another hidden revision resolves; if none resolve, startup fails.
-- The UI always owns the alternate screen. Raw mode, focus reporting, mouse
+- The interactive UI owns the alternate screen. Raw mode, focus reporting, mouse
   capture, and enhanced keyboard reporting are restored on every exit path.
   Shutdown leaves the alternate screen without clearing it or writing afterward.
+  `--quit-on-finish` instead draws without input reporting on the normal screen.
 - `Ctrl-C` exits immediately from any normal tix focus without recovery
   bookkeeping. `q` always quits from history, including while a conflict or
   rebase continuation is suspended. Before that normal exit, tix journals
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 30eab7193ba..83faaebc6b9 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2231,11 +2231,13 @@ impl App {
             if let Some(metadata) = metadata.get(&row.id) {
                 let row = Arc::make_mut(row);
                 row.committer_time = metadata.committer_time;
+                row.author_time = metadata.author_time;
                 row.author = metadata.author;
                 row.attributions = metadata.attributions.clone();
                 row.title = metadata.title.clone();
                 row.metadata_loaded = true;
                 row.has_agent_marker = metadata.has_agent_marker;
+                row.is_review = metadata.is_review;
                 row.signature = metadata.signature;
             }
         }
@@ -4391,14 +4393,14 @@ mod tests {
         app.set_metadata(
             0,
             Metadata {
-                author_time: gix::date::Time::default(),
-                committer_time: gix::date::Time::default(),
+                author_time: gix::date::Time::new(123, 60),
+                committer_time: gix::date::Time::new(456, 120),
                 author: row(1).author,
                 attributions: 0..0,
                 title: "loaded".into(),
-                has_agent_marker: false,
-                is_review: false,
-                signature: SignatureState::Unsigned,
+                has_agent_marker: true,
+                is_review: true,
+                signature: SignatureState::Verified,
             },
             Vec::new(),
         );
@@ -4407,6 +4409,11 @@ mod tests {
 
         assert!(app.rows[0].metadata_loaded);
         assert_eq!(app.title(&app.rows[0]), "loaded");
+        assert_eq!(app.rows[0].author_time, gix::date::Time::new(123, 60));
+        assert_eq!(app.rows[0].committer_time, gix::date::Time::new(456, 120));
+        assert!(app.rows[0].has_agent_marker);
+        assert!(app.rows[0].is_review);
+        assert_eq!(app.rows[0].signature, SignatureState::Verified);
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 5c560c23f9d..a291196b2af 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -51,7 +51,7 @@ use gix::{
 };
 use history::{Authors, Decorations, Event, HistoryGraph, SelectionRef, SharedAuthors};
 use notify::{RecommendedWatcher, RecursiveMode, Watcher};
-use ratatui::{backend::CrosstermBackend, text::Line};
+use ratatui::{TerminalOptions, Viewport, backend::CrosstermBackend, layout::Position, text::Line};
 
 const EVENT_BATCH_SIZE: usize = 256;
 const OBJECT_CACHE_SIZE: usize = 4 * 1024 * 1024;
@@ -707,9 +707,22 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
         "starting tix"
     );
     let commit_pane_background = detect_commit_pane_background();
-    let mut terminal = ratatui::try_init().context("could not initialize terminal")?;
-    let enhanced_keyboard = terminal::supports_keyboard_enhancement().unwrap_or(false);
-    let keyboard_setup = enable_input(terminal.backend_mut(), enhanced_keyboard);
+    let quit_on_finish = options.quit_on_finish;
+    let mut terminal = if quit_on_finish {
+        let (_, height) = terminal::size().context("could not determine terminal size")?;
+        ratatui::try_init_with_options(TerminalOptions {
+            viewport: Viewport::Inline(height),
+        })
+    } else {
+        ratatui::try_init()
+    }
+    .context("could not initialize terminal")?;
+    let enhanced_keyboard = !quit_on_finish && terminal::supports_keyboard_enhancement().unwrap_or(false);
+    let keyboard_setup = if quit_on_finish {
+        Ok(())
+    } else {
+        enable_input(terminal.backend_mut(), enhanced_keyboard)
+    };
     let result = keyboard_setup
         .context("could not enable enhanced keyboard events")
         .and_then(|()| {
@@ -722,13 +735,28 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
                 commit_pane_background,
             )
         });
-    let keyboard_restore = disable_input(terminal.backend_mut(), enhanced_keyboard);
+    let keyboard_restore = if quit_on_finish {
+        let area = terminal.get_frame().area();
+        terminal
+            .set_cursor_position(Position::new(area.x, area.bottom().saturating_sub(1)))
+            .and_then(|()| terminal.show_cursor())
+    } else {
+        disable_input(terminal.backend_mut(), enhanced_keyboard)
+    };
     drop(terminal);
-    let restore = ratatui::try_restore().context("could not restore terminal");
+    let restore = if quit_on_finish {
+        terminal::disable_raw_mode()
+    } else {
+        ratatui::try_restore()
+    }
+    .context("could not restore terminal");
     let lane_time = result?;
     keyboard_restore.context("could not restore keyboard events")?;
     restore?;
     if let Some(lane_time) = lane_time {
+        if quit_on_finish {
+            eprintln!();
+        }
         eprintln!("lane computation: {:.3}s", lane_time.as_secs_f64());
     }
     Ok(())
@@ -1179,7 +1207,7 @@ fn event_loop(
                     lane_receiver = None;
                     dirty = true;
                     if quit_on_finish {
-                        return Ok(app.lane_time);
+                        urgent = true;
                     }
                 }
                 Err(mpsc::TryRecvError::Empty) => {}
@@ -1366,6 +1394,9 @@ fn event_loop(
                 fill_repository.retain = false;
                 fill_repository.retained = None;
             }
+            if quit_on_finish && matches!(app.state, State::Complete) && lane_receiver.is_none() {
+                return Ok(app.lane_time);
+            }
             continue;
         }
         let mut events = 0;

From b20a9e560a6f992fedf9921b5f4e59c8a950416b Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 16:24:38 +0200
Subject: [PATCH 263/282] feat(gix-tix): replay diagnostic navigation inputs

Accept an optional keyboard-input string on --quit-on-finish and replay read-only actions after completed lanes have established the final layout. Keep the retained frame diagnostic safe by ignoring repository-changing, external-program, copy, and quit actions.
---
 gix-tix/spec.md        |   9 ++-
 gix-tix/src/command.rs |  21 +++++--
 gix-tix/src/lib.rs     | 135 +++++++++++++++++++++++++++++++++++------
 3 files changed, 138 insertions(+), 27 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e67091ec7a2..e66a3337508 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -100,9 +100,12 @@ without trading responsiveness for metadata that is not visible.
 - `-x/--hide REVSPEC` excludes the revision and its reachable ancestry. The
   option may be repeated.
 - `-h/--help` prints Clap's standard help for `tix` and every subcommand.
-- `--quit-on-finish` exits after traversal, lane computation, and one completed
-  frame, for measurement and non-interactive inspection. Its frame is drawn on
-  the normal screen and remains visible after exit.
+- `--quit-on-finish[=INPUTS]` exits after traversal, lane computation, and one
+  completed frame, for measurement and non-interactive inspection. Optional
+  characters are replayed as read-only keyboard input before the retained final
+  frame, allowing navigation such as `--quit-on-finish=jjjl`. Inputs that would
+  mutate the repository, launch another program, or copy data are ignored. The
+  frame is drawn on the normal screen and remains visible after exit.
 - `tix rebase todo [-x HIDDEN...] [--no-auto-hide]
   [--onto REV | --update-base] [TIP...]`
   writes a self-contained Markdown history-rebase plan to stdout. Visible tips
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index a2801c5b1cc..438e4ba9b87 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -20,9 +20,15 @@ mod travel;
 #[derive(Debug, clap::Args)]
 #[command(args_conflicts_with_subcommands = true)]
 pub struct Platform {
-    /// Exit once all commits and graph lanes have been computed.
-    #[arg(long)]
-    quit_on_finish: bool,
+    /// Exit after the final frame, optionally replaying read-only INPUTS first.
+    #[arg(
+        long,
+        value_name = "INPUTS",
+        num_args = 0..=1,
+        default_missing_value = "",
+        require_equals = true
+    )]
+    quit_on_finish: Option<String>,
     /// Hide this revision and every commit reachable from it.
     #[arg(short = 'x', long, value_name = "REVSPEC")]
     hide: Vec<OsString>,
@@ -732,7 +738,7 @@ mod tests {
     fn parses_tui_options_and_top_level_commands() {
         let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-x", "main", "--hide", "tag", "topic"])
             .expect("TUI arguments parse");
-        assert!(cli.platform.quit_on_finish);
+        assert_eq!(cli.platform.quit_on_finish, Some(String::new()));
         assert_eq!(cli.platform.hide, ["main", "tag"], "hide options append");
         assert_eq!(
             cli.platform.revisions,
@@ -741,6 +747,9 @@ mod tests {
         );
         assert!(cli.platform.command.is_none(), "omitting a command launches the TUI");
 
+        let cli = Cli::try_parse_from(["tix", "--quit-on-finish=jjjl"]).expect("diagnostic inputs parse");
+        assert_eq!(cli.platform.quit_on_finish.as_deref(), Some("jjjl"));
+
         let ref_tree = Cli::try_parse_from([
             "tix",
             "ref-tree",
@@ -1540,7 +1549,7 @@ mod tests {
         let linked_target = linked.find_reference(retained_ref.as_ref())?.id().detach();
 
         Platform {
-            quit_on_finish: false,
+            quit_on_finish: None,
             hide: Vec::new(),
             command: Some(Command::Admin(Admin::ClearUndo)),
             revisions: Vec::new(),
@@ -1562,7 +1571,7 @@ mod tests {
         );
 
         Platform {
-            quit_on_finish: false,
+            quit_on_finish: None,
             hide: Vec::new(),
             command: Some(Command::Admin(Admin::ClearUndo)),
             revisions: Vec::new(),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a291196b2af..574ded20220 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -648,8 +648,8 @@ impl BuiltInDiff {
 /// Options for [`run()`].
 #[derive(Clone, Debug, Default)]
 pub struct Options {
-    /// Exit once all commits and graph lanes have been computed.
-    pub quit_on_finish: bool,
+    /// Exit after the final frame, optionally replaying read-only keyboard input first.
+    pub quit_on_finish: Option<String>,
     /// Revisions whose reachable commits should initially be hidden.
     pub hide: Vec<OsString>,
 }
@@ -707,7 +707,7 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
         "starting tix"
     );
     let commit_pane_background = detect_commit_pane_background();
-    let quit_on_finish = options.quit_on_finish;
+    let quit_on_finish = options.quit_on_finish.is_some();
     let mut terminal = if quit_on_finish {
         let (_, height) = terminal::size().context("could not determine terminal size")?;
         ratatui::try_init_with_options(TerminalOptions {
@@ -805,6 +805,13 @@ fn event_loop(
     commit_pane_background: Option<(u8, u8, u8)>,
 ) -> Result<Option<Duration>> {
     let Options { quit_on_finish, hide } = options;
+    let mut quit_inputs: VecDeque<_> = quit_on_finish
+        .as_deref()
+        .unwrap_or_default()
+        .chars()
+        .map(diagnostic_key)
+        .collect();
+    let quit_on_finish = quit_on_finish.is_some();
     let mut repository_path = repository.git_dir().to_owned();
     let common_dir = normalize_common_dir(repository.common_dir.clone().unwrap_or_else(|| repository_path.clone()))?;
     let (mut view_repository, recovered_at_startup) = open_history_repository(&mut repository_path, &common_dir)?;
@@ -1394,7 +1401,11 @@ fn event_loop(
                 fill_repository.retain = false;
                 fill_repository.retained = None;
             }
-            if quit_on_finish && matches!(app.state, State::Complete) && lane_receiver.is_none() {
+            if quit_on_finish
+                && quit_inputs.is_empty()
+                && matches!(app.state, State::Complete)
+                && lane_receiver.is_none()
+            {
                 return Ok(app.lane_time);
             }
             continue;
@@ -1483,12 +1494,18 @@ fn event_loop(
         .into_iter()
         .flatten()
         .min();
-        let terminal_event = match pending_terminal_event.take() {
-            Some(event) => Some(event),
-            None => match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
-                Some(timeout) if event::poll(timeout)? => Some(event::read()?),
-                Some(_) => None,
-                None => Some(event::read()?),
+        let (terminal_event, diagnostic_input) = match pending_terminal_event.take() {
+            Some(event) => (Some(event), false),
+            None => match next_diagnostic_input(&mut quit_inputs, app.state, lane_receiver.is_some()) {
+                Some(key) => (Some(TerminalEvent::Key(key)), true),
+                None => (
+                    match poll_timeout(streaming, events, dirty, last_draw.elapsed(), wake_after) {
+                        Some(timeout) if event::poll(timeout)? => Some(event::read()?),
+                        Some(_) => None,
+                        None => Some(event::read()?),
+                    },
+                    false,
+                ),
             },
         };
         let Some(terminal_event) = terminal_event else {
@@ -1669,14 +1686,18 @@ fn event_loop(
         let key_pressed = is_key_press(&terminal_event);
         let (mut action, repeats_history, is_repeat, throttles_draw) = match terminal_event {
             TerminalEvent::Key(key) => {
-                let action = action_with_shortcut_groups(
-                    key,
-                    app.history_display_expanded,
-                    app.commit_expanded,
-                    app.actions_expanded,
-                    app.enrich_expanded,
-                    app.information_expanded || app.changes_focus.is_some(),
-                );
+                let action = if diagnostic_input {
+                    diagnostic_action(key, &app)
+                } else {
+                    action_with_shortcut_groups(
+                        key,
+                        app.history_display_expanded,
+                        app.commit_expanded,
+                        app.actions_expanded,
+                        app.enrich_expanded,
+                        app.information_expanded || app.changes_focus.is_some(),
+                    )
+                };
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
@@ -1727,6 +1748,11 @@ fn event_loop(
         if !focused {
             continue;
         }
+        if diagnostic_input && action.is_none() {
+            dirty = true;
+            urgent = true;
+            continue;
+        }
         if repeats_history || throttles_draw {
             repeat_deadline = Some(Instant::now() + REPEAT_IDLE);
         }
@@ -5867,6 +5893,49 @@ fn action(key: KeyEvent) -> Option<Action> {
     action_with_shortcut_groups(key, false, false, false, false, false)
 }
 
+fn diagnostic_key(character: char) -> KeyEvent {
+    let code = match character {
+        '\t' => KeyCode::Tab,
+        '\n' | '\r' => KeyCode::Enter,
+        '\u{1b}' => KeyCode::Esc,
+        character => KeyCode::Char(character),
+    };
+    let modifiers = if character.is_uppercase() {
+        KeyModifiers::SHIFT
+    } else {
+        KeyModifiers::NONE
+    };
+    KeyEvent::new(code, modifiers)
+}
+
+fn next_diagnostic_input(inputs: &mut VecDeque<KeyEvent>, state: State, lane_computing: bool) -> Option<KeyEvent> {
+    (state == State::Complete && !lane_computing)
+        .then(|| inputs.pop_front())
+        .flatten()
+}
+
+fn diagnostic_action(key: KeyEvent, app: &App) -> Option<Action> {
+    action_with_shortcut_groups(
+        key,
+        app.history_display_expanded,
+        app.commit_expanded,
+        app.actions_expanded,
+        app.enrich_expanded,
+        app.information_expanded || app.changes_focus.is_some(),
+    )
+    .filter(|action| {
+        (action_allowed_during_rebase_continuation(Some(action), app.changes_focus.is_some())
+            || matches!(
+                action,
+                Action::ToggleCommitGroup | Action::ToggleActions | Action::ToggleEnrich
+            ))
+            && !matches!(
+                action,
+                Action::Copy | Action::CopyPath(_) | Action::CopyAuthor | Action::ForceQuit | Action::Quit
+            )
+    })
+}
+
 fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_focused: bool) -> bool {
     matches!(
         action,
@@ -7607,6 +7676,36 @@ mod tests {
         );
     }
 
+    #[test]
+    fn diagnostic_inputs_replay_only_read_only_actions() {
+        let mut app = App::new(1);
+        assert_eq!(diagnostic_action(diagnostic_key('j'), &app), Some(Action::MoveDown));
+        assert_eq!(diagnostic_action(diagnostic_key('l'), &app), Some(Action::ScrollRight));
+        assert_eq!(diagnostic_action(diagnostic_key('G'), &app), Some(Action::Last));
+        assert_eq!(
+            diagnostic_action(diagnostic_key('u'), &app),
+            None,
+            "undo is not replayed"
+        );
+
+        app.actions_expanded = true;
+        assert_eq!(
+            diagnostic_action(diagnostic_key('b'), &app),
+            None,
+            "repository-changing submenu actions are not replayed"
+        );
+    }
+
+    #[test]
+    fn diagnostic_inputs_wait_for_completed_lanes() {
+        let key = diagnostic_key('j');
+        let mut inputs = VecDeque::from([key]);
+        assert!(next_diagnostic_input(&mut inputs, State::Loading, false).is_none());
+        assert!(next_diagnostic_input(&mut inputs, State::Complete, true).is_none());
+        assert_eq!(inputs.len(), 1, "premature checks do not consume input");
+        assert_eq!(next_diagnostic_input(&mut inputs, State::Complete, false), Some(key));
+    }
+
     #[test]
     fn tree_is_direct_while_trailers_remain_scoped_to_the_view_prefix() {
         let key = KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE);

From fa1853adfe8d1994ea1b612c5743f3ee0409a855 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 16:46:43 +0200
Subject: [PATCH 264/282] fix(gix-tix): align side-by-side change panes

Give tree and worktree panes a shared maximum height so the shorter pane covers history rows beneath it instead of exposing title fragments during alignment changes.
---
 gix-tix/src/ui.rs | 24 ++++++++++--------------
 1 file changed, 10 insertions(+), 14 deletions(-)

diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 966fdbb309b..b8175fad1a1 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -193,20 +193,15 @@ fn changes_pane_areas(
                     vec![
                         ChangesPaneArea {
                             pane: ChangePane::Tree,
-                            outer: Rect::new(
-                                area.x,
-                                area.bottom().saturating_sub(tree_height),
-                                tree_width,
-                                tree_height,
-                            ),
+                            outer: Rect::new(area.x, area.bottom().saturating_sub(height), tree_width, height),
                         },
                         ChangesPaneArea {
                             pane: ChangePane::Worktree,
                             outer: Rect::new(
                                 area.x.saturating_add(tree_width),
-                                area.bottom().saturating_sub(worktree_height),
+                                area.bottom().saturating_sub(height),
                                 worktree_width,
-                                worktree_height,
+                                height,
                             ),
                         },
                     ],
@@ -6352,7 +6347,7 @@ mod tests {
         assert_eq!(layout, ChangesLayout::SideBySide);
         assert_eq!(height, 5);
         assert_eq!(panes[0].outer, Rect::new(0, 15, 60, 5));
-        assert_eq!(panes[1].outer, Rect::new(60, 17, 60, 3));
+        assert_eq!(panes[1].outer, Rect::new(60, 15, 60, 5));
 
         let (layout, panes, height) = changes_pane_areas(Rect::new(0, 0, 60, 20), 10, Some((8, 31)), Some((3, 31)));
         assert_eq!(layout, ChangesLayout::Stacked);
@@ -6416,17 +6411,18 @@ mod tests {
             let right = row.chars().skip(60).collect::<String>();
             (left, right)
         };
-        let (left, _) = halves(rendered_line(&terminal, 5));
+        let (left, right) = halves(rendered_line(&terminal, 5));
         assert!(left.contains("Tree"));
+        assert!(right.contains("Worktree"));
         let (left, right) = halves(rendered_line(&terminal, 6));
         assert!(left.contains("tree-file"));
-        assert!(right.contains("Worktree"));
+        assert!(right.contains("worktree-file"));
         let (left, right) = halves(rendered_line(&terminal, 7));
         assert!(left.contains("tree-file-2"));
-        assert!(right.contains("worktree-file"));
+        assert_eq!(right.trim(), "│");
         let buffer = terminal.backend().buffer();
-        assert_eq!(buffer[(60, 5)].symbol(), "┐");
-        assert_eq!(buffer[(60, 6)].symbol(), "├");
+        assert_eq!(buffer[(60, 5)].symbol(), "┬");
+        assert_eq!(buffer[(60, 6)].symbol(), "│");
         assert_eq!(buffer[(60, 7)].symbol(), "│");
         assert_eq!(buffer[(60, 8)].symbol(), "│");
 

From 5c7c9e0f1e1ed05e3e09d4179b85159a1f6e4c87 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 18:37:41 +0200
Subject: [PATCH 265/282] fix(gix-tix): finalize amended commits immediately

Re-sign direct amend roots immediately so signed checked-out commits are never left pending. Keep reparented descendants lazy and cover the signed worktree fallback.
---
 gix-tix/spec.md          |  8 ++++--
 gix-tix/src/edit/head.rs | 59 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 63 insertions(+), 4 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index e66a3337508..c9a6395bdb0 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -792,9 +792,11 @@ space first; changes blocks adapt within the remaining history width.
 - All three operations leave worktree files untouched and cheaply rewrite linear
   descendants. Whole-commit edits reset the affected
   worktree's index to the rewritten commit; selected-path amend synchronizes only
-  its destination and renamed source. A zero-delta commit immediately adopts and
-  is signed against its rewritten parent tree whenever that parent is final; it
-  remains lazy only behind a pending parent. Other reparented descendants carry
+  its destination and renamed source. A directly amended commit already has its
+  final tree and unchanged parent, so it is signed immediately when configured
+  and is never pending. A zero-delta commit immediately adopts and is signed
+  against its rewritten parent tree whenever that parent is final; it remains
+  lazy only behind a pending parent. Other reparented descendants carry
   `tix-rebase-parent`, retaining the original parent needed for later replay.
   Pending forms use a grey commit marker so they remain distinct from unsigned
   blue. A final descendant whose effective parents did not change retains its
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index f23dbbaac7b..c8aa3784749 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -127,7 +127,7 @@ fn perform_inner(
     let edit = rebase::Edit::Replace { target: head, commit };
     let signature = if review {
         rebase::Signature::Remove
-    } else if pending {
+    } else if kind == Kind::Amend || pending {
         rebase::Signature::RedoIfNeeded
     } else {
         rebase::Signature::InvalidateExisting
@@ -323,6 +323,63 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn signed_worktree_amend_is_finalized_immediately() -> gix_testtools::Result {
+        if !gix_testtools::signature::program_available("ssh-keygen") {
+            return Ok(());
+        }
+        let (_key_home, key) = gix_testtools::signature::ssh_private_key()?;
+        let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
+        git(fixture.path(), &["reset", "-q", "HEAD", "--", "tracked"])?;
+        let repo = crate::test_repository::open_with(
+            fixture.path(),
+            [
+                "user.name=editor".to_owned(),
+                "user.email=editor@example.com".to_owned(),
+                "commit.gpgSign=true".to_owned(),
+                "gpg.format=ssh".to_owned(),
+                format!("user.signingKey={}", key.display()),
+                format!(
+                    "gpg.ssh.allowedSignersFile={}",
+                    gix_testtools::signature::fixture("ssh-allowed-signers").display()
+                ),
+            ],
+        )?;
+        let old = repo.head_id()?.detach();
+        let signed = repo.find_commit(old)?.decode()?.sign(
+            repo.commit_signing_options_if_enabled()?
+                .expect("commit signing is configured"),
+        )?;
+        let signed = repo.write_object(&signed)?.detach();
+        repo.find_reference("refs/heads/main")?
+            .set_target_id(signed, "prepare signed worktree amend")?;
+        let graph = super::super::loaded_graph(&repo)?;
+
+        let amended = perform(repo.clone(), &graph, Kind::Amend, None)?.expect("the worktree change amends HEAD");
+        assert_eq!(repo.head_id()?.detach(), amended, "HEAD follows the amended commit");
+        assert!(
+            git(fixture.path(), &["diff", "--cached", "--name-only"])?.is_empty(),
+            "the amended index is clean"
+        );
+        assert!(
+            git(fixture.path(), &["diff", "--name-only"])?.is_empty(),
+            "the amended worktree is clean"
+        );
+        let commit = repo.find_commit(amended)?;
+        assert!(
+            !super::super::rebase::is_pending(&commit.decode()?.into_owned()?),
+            "the checked-out amended commit needs no later replay"
+        );
+        assert!(
+            commit
+                .verify_signature()?
+                .expect("the amended commit is signed")
+                .is_valid(),
+            "the amended commit receives a valid configured signature"
+        );
+        Ok(())
+    }
+
     #[test]
     fn index_only_amend_does_not_fall_back_to_worktree_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;

From 5ae947297c2f9fbbd91926c1511500c206208267 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Thu, 20 Aug 2026 19:05:59 +0200
Subject: [PATCH 266/282] feat(gix-tix): restore paged time-travel animation

Animate completed pending rebases through fixed history viewports, jumping by a full page when the selection reaches the top.

Temporarily expand compressed history, keep cached panes tied to the animation origin, and preserve completed mutations if frame rendering fails.
---
 gix-tix/spec.md    |   9 +-
 gix-tix/src/app.rs | 116 ++++++++++++++++++++++-
 gix-tix/src/lib.rs | 225 +++++++++++++++++++++++++++++++++++++++++----
 gix-tix/src/ui.rs  |  48 +++++++++-
 4 files changed, 372 insertions(+), 26 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index c9a6395bdb0..0abef47702f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1068,8 +1068,13 @@ space first; changes blocks adapt within the remaining history width.
   the index tree, including additional staged changes, becomes the resolved tree.
   There is no hidden sequencer state or separate continue/abort command.
 - Interactive todo application runs on a scoped worker and shows its modal gauge
-  after 300 ms. TUI and command-line time travel complete without intermediate
-  history-selection frames.
+  after 300 ms. TUI time travel also runs on a scoped worker and follows completed
+  pending rebases with the history selection. The selection traverses each fixed
+  viewport from bottom to top; crossing its top jumps the viewport by one page and
+  places the selection at the bottom again. Compressed history temporarily uses
+  its canonical rows for these frames and is restored afterward. The first and
+  latest rows are drawn even for fast operations, with intermediate rows
+  coalesced to at most 60 fps. Command-line time travel does not animate.
 - Displayed mutable refs follow their explicit locations in the edited todo;
   omission deletes them and newly named refs require nonexistence. Refs checked
   out by linked worktrees are displayed normally and may move, with their index
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 83faaebc6b9..2b5eafdc89d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -518,6 +518,7 @@ pub(crate) struct App {
     compressed_anchor: Option<ObjectId>,
     compressed_segment: Option<ObjectId>,
     compressed_expanded: HashSet<ObjectId>,
+    time_travel_animation: Option<ObjectId>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
     test_lanes: Vec<String>,
@@ -625,6 +626,7 @@ impl App {
             compressed_anchor: None,
             compressed_segment: None,
             compressed_expanded: HashSet::new(),
+            time_travel_animation: None,
             attributions: Vec::new(),
             #[cfg(test)]
             test_lanes: Vec::new(),
@@ -1182,7 +1184,10 @@ impl App {
     }
 
     fn compressed_history_suspended(&self) -> bool {
-        self.pending_rebase_conflict.is_some() || self.rebase_continuation_pending || self.worktree_conflicted
+        self.time_travel_animation.is_some()
+            || self.pending_rebase_conflict.is_some()
+            || self.rebase_continuation_pending
+            || self.worktree_conflicted
     }
 
     fn rebuild_compressed_history(&mut self) {
@@ -2906,6 +2911,56 @@ impl App {
         }
     }
 
+    pub(crate) fn select_commit_for_time_travel(&mut self, id: ObjectId) {
+        let Some(index) = self.rows.iter().position(|row| row.id == id) else {
+            return;
+        };
+        let previous_offset = self.offset;
+        self.select(index);
+        if let Some(selected) = self
+            .selected_history_index()
+            .filter(|selected| *selected < previous_offset)
+        {
+            self.offset = selected.saturating_sub(self.viewport_rows.max(1) - 1);
+        }
+    }
+
+    pub(crate) fn begin_time_travel_animation(&mut self) {
+        let viewport_row = if self.alignment == Alignment::Compressed {
+            self.selected_history_index()
+                .map(|selected| selected.saturating_sub(self.offset))
+        } else {
+            None
+        };
+        self.time_travel_animation = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        if let (Some(selected), Some(viewport_row)) = (self.selected_history_index(), viewport_row) {
+            self.offset = selected.saturating_sub(viewport_row);
+        }
+        self.ensure_visible();
+    }
+
+    pub(crate) fn finish_time_travel_animation(&mut self) {
+        let viewport_row = if self.alignment == Alignment::Compressed {
+            self.selected_history_index()
+                .map(|selected| selected.saturating_sub(self.offset))
+        } else {
+            None
+        };
+        if self.time_travel_animation.take().is_none() || self.alignment != Alignment::Compressed {
+            return;
+        }
+        self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        self.rebuild_compressed_history();
+        if let (Some(selected), Some(viewport_row)) = (self.selected_history_index(), viewport_row) {
+            self.offset = selected.saturating_sub(viewport_row);
+        }
+        self.ensure_visible();
+    }
+
+    pub(crate) fn time_travel_animation_origin(&self) -> Option<ObjectId> {
+        self.time_travel_animation
+    }
+
     pub(crate) fn select_commit_after_refresh(&mut self, id: ObjectId) {
         self.selection_after_refresh = Some(id);
     }
@@ -4957,6 +5012,65 @@ mod tests {
         assert_eq!(app.selected, Some(1));
     }
 
+    #[test]
+    fn time_travel_selection_crosses_each_viewport_before_paging() {
+        let mut app = App::new(4);
+        app.extend_commits((1..=10).map(row).collect::<Vec<_>>());
+        complete(&mut app);
+
+        let mut positions = Vec::new();
+        for commit in (1u16..=10).rev() {
+            app.select_commit_for_time_travel(id(commit));
+            positions.push((app.selected, app.offset));
+        }
+
+        assert_eq!(
+            positions,
+            [
+                (Some(9), 6),
+                (Some(8), 6),
+                (Some(7), 6),
+                (Some(6), 6),
+                (Some(5), 2),
+                (Some(4), 2),
+                (Some(3), 2),
+                (Some(2), 2),
+                (Some(1), 0),
+                (Some(0), 0),
+            ],
+            "selection crosses a full viewport before the next page is bottom-aligned"
+        );
+    }
+
+    #[test]
+    fn time_travel_animation_temporarily_expands_compressed_history() {
+        let mut app = App::new(4);
+        app.extend_commits(
+            (1u16..=10)
+                .rev()
+                .map(|commit| numbered_row(commit, (commit > 1).then_some(commit - 1)))
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.set_view_tips(&[id(10)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        assert!(app.history_len() < app.rows.len(), "the linear history is compressed");
+
+        app.begin_time_travel_animation();
+        assert_eq!(app.history_len(), app.rows.len(), "animation uses canonical rows");
+        let mut offsets = Vec::new();
+        for commit in 1..=10 {
+            app.select_commit_for_time_travel(id(commit));
+            offsets.push(app.offset);
+        }
+        assert_eq!(offsets, [6, 6, 6, 6, 2, 2, 2, 2, 0, 0]);
+        app.finish_time_travel_animation();
+
+        assert_eq!(app.alignment, Alignment::Compressed);
+        assert!(app.history_len() < app.rows.len(), "compression is restored");
+    }
+
     #[test]
     fn compressed_history_retains_tips_and_selection_and_selects_segments() {
         let mut app = App::new(2);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 574ded20220..fae60805fa6 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3136,20 +3136,54 @@ fn event_loop(
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let review_roots: Vec<_> = app.rows.iter().filter(|row| row.is_review).map(|row| row.id).collect();
+                    app.begin_time_travel_animation();
                     let result = history_graph
                         .as_ref()
                         .context("time-travel requires a completed history graph")
                         .and_then(|graph| {
-                            edit::time_travel::perform(
-                                &repository_path,
-                                repository_is_bare,
-                                id,
-                                graph,
-                                &review_roots,
-                                &revisions,
-                                false,
+                            let repository = open_fill_repository(&repository_path, repository_is_bare)
+                                .context("could not open repository for time-travel animation")?;
+                            run_with_rebase_selection(
+                                |report| {
+                                    edit::time_travel::perform_reporting_rebased(
+                                        &repository_path,
+                                        repository_is_bare,
+                                        id,
+                                        graph,
+                                        &review_roots,
+                                        &revisions,
+                                        false,
+                                        report,
+                                    )
+                                },
+                                |id| {
+                                    app.select_commit_for_time_travel(id);
+                                    let render_rows = terminal.get_frame().area().height.saturating_sub(1) as usize;
+                                    load_visible_history_metadata(&repository, &mut app, &authors, render_rows)?;
+                                    let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
+                                    let tree = tree_changes.as_ref().map(|(_, changes)| changes);
+                                    let worktree = worktree_changes
+                                        .as_ref()
+                                        .filter(|(marker, _)| *marker != usize::MAX)
+                                        .map(|(_, changes)| changes);
+                                    terminal
+                                        .draw(|frame| {
+                                            ui::draw_with_worktree(
+                                                frame,
+                                                &mut app,
+                                                &decorations,
+                                                &mailmap,
+                                                message,
+                                                tree,
+                                                worktree,
+                                            );
+                                        })
+                                        .context("could not draw time-travel animation")?;
+                                    Ok(())
+                                },
                             )
                         });
+                    app.finish_time_travel_animation();
                     match result {
                         Ok(edit::time_travel::Perform::Complete {
                             notice: Some(notice),
@@ -3937,6 +3971,25 @@ fn restore_change_selection(view: &mut app::ChangesView, changes: &Changes, reme
     }
 }
 
+fn load_visible_history_metadata(
+    repository: &gix::Repository,
+    app: &mut App,
+    authors: &SharedAuthors,
+    render_rows: usize,
+) -> Result<()> {
+    let start = app.offset.min(app.history_len());
+    let end = start.saturating_add(render_rows).min(app.history_len());
+    for index in app.visible_history_indices(start..end) {
+        if app.rows[index].metadata_loaded {
+            continue;
+        }
+        let (metadata, attributions) =
+            history::load_metadata(repository, app.rows[index].id, authors).context("could not load visible commit")?;
+        app.set_metadata(index, metadata, attributions);
+    }
+    Ok(())
+}
+
 #[expect(clippy::too_many_arguments, reason = "drawing needs the complete view state")]
 fn draw(
     terminal: &mut ratatui::DefaultTerminal,
@@ -4195,16 +4248,7 @@ fn draw(
                 }
             }
         }
-        let start = app.offset.min(app.history_len());
-        let end = start.saturating_add(render_rows).min(app.history_len());
-        for index in app.visible_history_indices(start..end) {
-            if app.rows[index].metadata_loaded {
-                continue;
-            }
-            let (metadata, attributions) = history::load_metadata(repository, app.rows[index].id, authors)
-                .context("could not load visible commit")?;
-            app.set_metadata(index, metadata, attributions);
-        }
+        load_visible_history_metadata(repository, app, authors, render_rows)?;
     }
     let message = commit_message.as_ref().map(|(_, message)| message.as_bstr());
     let tree_changes = tree_changes.as_ref().map(|(_, changes)| changes);
@@ -4986,6 +5030,87 @@ enum RebaseWorkerEvent<T> {
     Complete(Result<T>),
 }
 
+enum TravelWorkerEvent<T> {
+    Rebased(gix::ObjectId),
+    Complete(Result<T>),
+}
+
+fn run_with_rebase_selection<T: Send>(
+    operation: impl FnOnce(&mut dyn FnMut(gix::ObjectId)) -> Result<T> + Send,
+    mut render: impl FnMut(gix::ObjectId) -> Result<()>,
+) -> Result<T> {
+    std::thread::scope(|scope| {
+        let (sender, receiver) = mpsc::channel();
+        let worker = scope.spawn(move || {
+            let mut report = |id| {
+                let _ = sender.send(TravelWorkerEvent::Rebased(id));
+            };
+            let result = operation(&mut report);
+            let _ = sender.send(TravelWorkerEvent::Complete(result));
+        });
+        let mut last_draw: Option<Instant> = None;
+        let mut latest = None;
+        let mut rendered = None;
+        let mut complete = None;
+        let mut render_error = None;
+        let result = loop {
+            let event = if complete.is_some() {
+                None
+            } else if render_error.is_none()
+                && latest != rendered
+                && let Some(last_draw) = last_draw
+            {
+                match receiver.recv_timeout(FRAME_INTERVAL.saturating_sub(last_draw.elapsed())) {
+                    Ok(event) => Some(event),
+                    Err(mpsc::RecvTimeoutError::Timeout) => None,
+                    Err(mpsc::RecvTimeoutError::Disconnected) => {
+                        break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly"));
+                    }
+                }
+            } else {
+                match receiver.recv() {
+                    Ok(event) => Some(event),
+                    Err(_) => break Err(anyhow::anyhow!("time-travel worker stopped unexpectedly")),
+                }
+            };
+            match event {
+                Some(TravelWorkerEvent::Rebased(id)) => latest = Some(id),
+                Some(TravelWorkerEvent::Complete(result)) => complete = Some(result),
+                None => {}
+            }
+            if render_error.is_none()
+                && latest != rendered
+                && (last_draw.is_none()
+                    || last_draw.is_some_and(|last_draw| last_draw.elapsed() >= FRAME_INTERVAL)
+                    || complete.is_some())
+            {
+                if complete.is_some()
+                    && let Some(last_draw) = last_draw
+                {
+                    std::thread::sleep(FRAME_INTERVAL.saturating_sub(last_draw.elapsed()));
+                }
+                let id = latest.expect("a changed rebased commit is available");
+                if let Err(err) = render(id) {
+                    render_error = Some(err);
+                    continue;
+                }
+                rendered = latest;
+                last_draw = Some(Instant::now());
+            }
+            if let Some(result) = complete.take() {
+                break result;
+            }
+        };
+        if let Some(err) = render_error {
+            tracing::warn!(error = %err, "time-travel animation stopped");
+        }
+        if worker.join().is_err() {
+            return Err(anyhow::anyhow!("time-travel worker panicked"));
+        }
+        result
+    })
+}
+
 fn run_rebase_plan(
     terminal: &mut ratatui::DefaultTerminal,
     repository: gix::ThreadSafeRepository,
@@ -8163,6 +8288,70 @@ mod tests {
         assert!(todo_progress_visible(TODO_PROGRESS_DELAY));
     }
 
+    #[test]
+    fn fast_time_travel_draws_the_first_and_latest_rebased_commits() -> Result<()> {
+        let ids = [
+            gix::ObjectId::Sha1([1; 20]),
+            gix::ObjectId::Sha1([2; 20]),
+            gix::ObjectId::Sha1([3; 20]),
+        ];
+        let mut rendered = Vec::new();
+
+        run_with_rebase_selection(
+            |report| {
+                for id in ids {
+                    report(id);
+                }
+                Ok(())
+            },
+            |id| {
+                rendered.push(id);
+                Ok(())
+            },
+        )?;
+
+        assert_eq!(rendered.first(), Some(&ids[0]), "the first completed rebase is drawn");
+        assert_eq!(rendered.last(), Some(&ids[2]), "the latest completed rebase is drawn");
+        Ok(())
+    }
+
+    #[test]
+    fn slow_time_travel_draws_every_rebased_selection() -> Result<()> {
+        let ids = [gix::ObjectId::Sha1([1; 20]), gix::ObjectId::Sha1([2; 20])];
+        let mut rendered = Vec::new();
+
+        run_with_rebase_selection(
+            |report| {
+                for id in ids {
+                    report(id);
+                    std::thread::sleep(FRAME_INTERVAL * 2);
+                }
+                Ok(())
+            },
+            |id| {
+                rendered.push(id);
+                Ok(())
+            },
+        )?;
+
+        assert_eq!(rendered, ids, "slow travel renders each completed rebase");
+        Ok(())
+    }
+
+    #[test]
+    fn failed_animation_frame_preserves_completed_time_travel() -> Result<()> {
+        let completed = run_with_rebase_selection(
+            |report| {
+                report(gix::ObjectId::Sha1([1; 20]));
+                Ok(42)
+            },
+            |_| Err(anyhow::anyhow!("frame failed")),
+        )?;
+
+        assert_eq!(completed, 42, "animation failure cannot hide a completed mutation");
+        Ok(())
+    }
+
     #[test]
     fn continuing_a_conflict_commits_the_complete_resolved_index() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_conflict.sh")?;
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index b8175fad1a1..7864cfc8888 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -313,6 +313,7 @@ pub(crate) fn draw_with_worktree(
     let [mut body, footer] = Layout::vertical([Constraint::Min(0), Constraint::Length(1)]).areas(frame.area());
     let full_body = body;
     let selected_segment = app.selected_is_segment();
+    let time_travel_animation = app.time_travel_animation_origin().is_some();
     let compared_parent = if app.changes_visible() && !selected_segment {
         tree_changes.and_then(|changes| changes.parent.map(|parent| parent.id))
     } else {
@@ -680,11 +681,13 @@ pub(crate) fn draw_with_worktree(
         .min(u16::MAX as usize);
     let horizontal_offset = app.horizontal_offset.min(max_offset);
     let selection_info = selection_info_line(
-        (!selected_segment && app.changes_visible())
+        (!time_travel_animation && !selected_segment && app.changes_visible())
             .then_some(tree_changes)
             .flatten()
             .filter(|changes| changes.is_visible()),
-        (!selected_segment).then_some(app.selection_relation).flatten(),
+        (!time_travel_animation && !selected_segment)
+            .then_some(app.selection_relation)
+            .flatten(),
     );
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
@@ -1878,9 +1881,9 @@ fn changes_summary(pane: ChangePane, app: &App, changes: &Changes) -> Line<'stat
         ChangePane::Tree => {
             let label = changes.range.map_or_else(
                 || {
-                    app.selected
-                        .and_then(|index| app.rows.get(index))
-                        .map_or_else(|| "-------".into(), |row| row.id.to_hex_with_len(7).to_string())
+                    app.time_travel_animation_origin()
+                        .or_else(|| app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id))
+                        .map_or_else(|| "-------".into(), |id| id.to_hex_with_len(7).to_string())
                 },
                 |range| format!("{}..{}", range.base.to_hex_with_len(7), range.tip.to_hex_with_len(7)),
             );
@@ -2809,6 +2812,41 @@ mod tests {
         assert!(spans[1].style.add_modifier.contains(Modifier::DIM));
     }
 
+    #[test]
+    fn time_travel_animation_keeps_the_tree_summary_on_its_origin() {
+        let ids = [1, 2].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let mut app = App::new(ids.len());
+        app.extend_commits(
+            ids.into_iter()
+                .map(|id| Commit {
+                    id,
+                    parent_ids: Default::default(),
+                    author_time: gix::date::Time::default(),
+                    committer_time: gix::date::Time::default(),
+                    author: author(b"author", b"author@example.com"),
+                    attributions: 0..0,
+                    title: "subject".into(),
+                    metadata_loaded: true,
+                    has_agent_marker: false,
+                    is_review: false,
+                    signature: SignatureState::Unsigned,
+                })
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.select_commit(ids[1]);
+        app.begin_time_travel_animation();
+        app.select_commit_for_time_travel(ids[0]);
+
+        assert!(
+            changes_summary(ChangePane::Tree, &app, &Changes::default())
+                .to_string()
+                .contains("0202020"),
+            "the cached tree diff remains labelled with its origin while selection moves"
+        );
+        app.finish_time_travel_animation();
+    }
+
     #[test]
     fn prefix_popout_clamps_and_clears_the_row_beneath_it() -> Result<(), Box<dyn std::error::Error>> {
         let mut terminal = Terminal::new(TestBackend::new(20, 2))?;

From 61a8a0cb778987cbd41a7f0470f882b8a0839bdc Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 06:59:28 +0200
Subject: [PATCH 267/282] fix(gix-tix): keep singleton history rows
 uncompressed

Emit ordinary commit rows for one-member linear groups so compressed mode always saves vertical space.

Keep multi-segment expansion and reset coverage with longer fixtures, and document the minimum segment size.
---
 gix-tix/spec.md    |  9 +++++----
 gix-tix/src/app.rs | 31 +++++++++++++++----------------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 0abef47702f..53fa4f1b24b 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -436,10 +436,11 @@ full-column alignment so clipped fields can be reached.
 Compressed history keeps the visible reference, pin, and worktree tips, the
 commit selected when compression begins, every graph endpoint or junction, and
 every hidden boundary as full, selectable commit rows. Each remaining maximal
-linear segment is represented by a selectable hollow node followed by its exact
-commit count, such as `○ [12]`. Pressing Enter on a summary expands that one
-segment in place; expansions accumulate until the display is the ordinary
-title-aligned history. Modal review and rewrite-target pickers retain the
+linear segment of at least two commits is represented by a selectable hollow
+node followed by its exact commit count, such as `○ [12]`; a singleton remains
+a full commit row. Pressing Enter on a summary expands that one segment in place;
+expansions accumulate until the display is the ordinary title-aligned history.
+Modal review and rewrite-target pickers retain the
 compressed projection so its points of interest remain available as targets,
 while conflict selection continues to show the full history. Leaving and
 re-entering compressed mode through the `[` cycle, or performing a full history
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 2b5eafdc89d..1124a0388e5 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -3225,7 +3225,7 @@ impl CompressedHistory {
             let mut row = rows[representative].as_ref().clone();
             row.parent_ids = std::mem::take(&mut parents[group]);
             compact_rows.push(Arc::new(row));
-            entries.push(if is_anchor(representative) {
+            entries.push(if is_anchor(representative) || members[group].len() == 1 {
                 HistoryEntry::Commit(representative)
             } else {
                 HistoryEntry::Segment {
@@ -5099,18 +5099,15 @@ mod tests {
                     count: 2,
                 },
                 HistoryEntry::Commit(3),
-                HistoryEntry::Segment {
-                    representative: 4,
-                    count: 1,
-                },
+                HistoryEntry::Commit(4),
                 HistoryEntry::Commit(5),
             ],
-            "linear commits between the retained endpoints and selection collapse into counted segments"
+            "linear runs collapse only when their summary saves vertical space"
         );
         assert_eq!(
             app.render_lanes(0..app.history_len()).iter().collect::<Vec<_>>(),
-            ["● ", "○ ", "● ", "○ ", "● "],
-            "segments reuse the canonical graph with a quieter ring marker"
+            ["● ", "○ ", "● ", "● ", "● "],
+            "only segments use the quieter ring marker"
         );
 
         app.update(Action::MoveUp);
@@ -5122,8 +5119,8 @@ mod tests {
             "navigation returns from a summary to its adjacent retained commit"
         );
 
-        app.select_commit(id(2));
-        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(2)));
+        app.select_commit(id(4));
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(4)));
         assert!(
             app.selected_history_index().is_some(),
             "a programmatic jump rebuilds compression around the destination"
@@ -5338,6 +5335,7 @@ mod tests {
     fn compressed_segments_are_selectable_and_expand_in_place() {
         let mut app = App::new(10);
         app.extend_commits(vec![
+            row_with_parents(7, &[6]),
             row_with_parents(6, &[5]),
             row_with_parents(5, &[4]),
             row_with_parents(4, &[3]),
@@ -5351,8 +5349,8 @@ mod tests {
             .iter()
             .map(str::to_owned)
             .collect::<Vec<_>>();
-        app.set_view_tips(&[id(6)]);
-        app.select_commit(id(3));
+        app.set_view_tips(&[id(7)]);
+        app.select_commit(id(4));
         app.alignment = Alignment::None;
         app.update(Action::ToggleAlign);
 
@@ -5374,7 +5372,7 @@ mod tests {
         );
         assert_eq!(
             app.selected.and_then(|index| app.rows.get(index)).map(|row| row.id),
-            Some(id(5)),
+            Some(id(6)),
             "expansion selects the newest commit represented by the summary"
         );
         assert!(
@@ -5403,7 +5401,7 @@ mod tests {
         );
         assert_eq!(
             app.update(Action::OpenDiff),
-            vec![Effect::OpenCommitDiff(TreeDiffTarget::Commit { id: id(2), parent: 0 })],
+            vec![Effect::OpenCommitDiff(TreeDiffTarget::Commit { id: id(3), parent: 0 })],
             "Enter resumes its normal commit behavior after expansion"
         );
     }
@@ -5535,6 +5533,7 @@ mod tests {
     fn compressed_expansions_reset_on_mode_exit_and_full_reload() {
         let commits = || {
             vec![
+                row_with_parents(6, &[5]),
                 row_with_parents(5, &[4]),
                 row_with_parents(4, &[3]),
                 row_with_parents(3, &[2]),
@@ -5549,7 +5548,7 @@ mod tests {
         let mut app = App::new(10);
         app.extend_commits(commits());
         complete(&mut app);
-        app.set_view_tips(&[id(5)]);
+        app.set_view_tips(&[id(6)]);
         app.alignment = Alignment::None;
         app.update(Action::ToggleAlign);
         app.update(Action::MoveDown);
@@ -5571,7 +5570,7 @@ mod tests {
         assert!(app.selected_is_segment(), "a summary is available to expand again");
         app.update(Action::OpenDiff);
         app.reload(false);
-        app.set_view_tips(&[id(5)]);
+        app.set_view_tips(&[id(6)]);
         app.extend_commits(commits());
         complete(&mut app);
         assert_eq!(app.alignment, Alignment::Compressed);

From 4c228d81b0190b010a87610e4cf52e1c3e44c1df Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 07:24:41 +0200
Subject: [PATCH 268/282] feat(gix-tix): add momentary topological navigation

Use Shift-modified directions for first-parent traversal and remembered branch choices in history and ref-tree views. Keep mouse and page input viewport-only by default, with Shift moving the cursor, and show fork choices without persistent motion modes.

Always invert selected ref-tree node markers.
---
 gix-tix/spec.md         |  45 +++--
 gix-tix/src/app.rs      | 411 +++++++++++++++++++++++++++++++++++++---
 gix-tix/src/lib.rs      | 238 +++++++++++++++++++----
 gix-tix/src/ref_tree.rs | 210 ++++++++++++--------
 gix-tix/src/ui.rs       |  76 +++++++-
 5 files changed, 818 insertions(+), 162 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 53fa4f1b24b..08e8143c8f2 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -350,18 +350,18 @@ without trading responsiveness for metadata that is not visible.
   `●` disk is the node marker, while the smaller `•` is the commit-count unit.
   Referenced or raw-tip nodes whose commits are present in history use the
   current-history cyan; other linked-worktree nodes use dark green.
-  Selection emphasizes the label without inverting the disk, while a selected
-  synthetic node inverts its otherwise-unlabelled disk.
+  Selection inverts both the node disk and its label, including synthetic nodes
+  whose disk is otherwise unlabelled.
 - Rendering clips lanes and node labels to the viewport.
-- `Tab` switches nearest-direction and topological movement.
-  Nearest movement chooses the closest node in the requested screen direction.
-  Topological Up moves toward leaves, Down toward roots, and Left/Right chooses
-  a remembered child; `i/n` and an emphasized edge show the choice.
+- Plain directions choose the nearest node in the requested screen direction.
+  Shift-directions instead navigate topologically: Up moves toward leaves, Down
+  toward roots, and Left/Right chooses a remembered child; `i/n` and an
+  emphasized edge always show the choice.
 - `g` selects the top ref-tree node, and `Shift-G` selects the root of the current
-  component. Shift-modified directions and the mouse pan the ref-tree viewport.
-  The existing full- and half-page Ctrl/Page keys move the cursor by the
-  corresponding viewport distance and keep it visible, matching history
-  navigation.
+  component. Unshifted mouse and full- or half-page Ctrl/Page input pan the
+  viewport without moving the cursor. Shift-mouse moves to the nearest node;
+  shifted Ctrl/Page input moves the cursor by the corresponding viewport
+  distance and keeps it visible, matching history navigation.
 - `e` opens node-level reference editing. `d` deletes every eligible local branch
   immediately. `e r` is offered only when selected remote-tracking references
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
@@ -401,11 +401,11 @@ without trading responsiveness for metadata that is not visible.
 
 | Key | Behavior |
 | --- | --- |
-| `j`/Down, `k`/Up | Move one selectable row or changed path. |
-| Mouse/trackpad vertical scroll | Move history by the coalesced scroll distance; move paths when a changes block is focused. |
-| `h`/`l` | Pan history or the focused changes block horizontally. |
-| `Ctrl-u`/`Ctrl-d` | Move half a page. |
-| `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move a page; scroll an overflowing commit message when applicable. |
+| `j`/Down, `k`/Up | Move one selectable row or changed path. Shift follows the first parent or chosen child. |
+| Mouse/trackpad vertical scroll | Pan history by the coalesced scroll distance without moving its cursor; Shift moves the cursor instead. Mouse input continues to move paths when a changes block is focused. |
+| `h`/`l` | Pan history or the focused changes block horizontally. Shift chooses a remembered topological child. Shift-horizontal mouse input does the same. |
+| `Ctrl-u`/`Ctrl-d` | Pan half a page; Shift moves the cursor half a page. |
+| `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Pan a page; Shift moves the cursor a page. Both forms scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. |
 | `t` | Toggle the rounded ref-tree overview. |
@@ -433,6 +433,14 @@ Alignment uses only rows in the current viewport to determine widths and starts
 in title mode. Horizontal navigation pans the complete padded row in title and
 full-column alignment so clipped fields can be reached.
 
+Topological navigation treats the displayed history as a first-parent forest.
+Down moves toward roots, Up moves toward leaves, and Left/Right or `h`/`l`
+select among a fork's children in display order. The choice is remembered per
+fork and shown as `i/n` beside the selected row without extending its inverted
+selection style. Movement stops at missing roots or leaves and never follows a
+merge's secondary parents. A viewport panned away with the mouse or page keys
+stays detached until the next cursor movement makes its destination visible.
+
 Compressed history keeps the visible reference, pin, and worktree tips, the
 commit selected when compression begins, every graph endpoint or junction, and
 every hidden boundary as full, selectable commit rows. Each remaining maximal
@@ -440,6 +448,9 @@ linear segment of at least two commits is represented by a selectable hollow
 node followed by its exact commit count, such as `○ [12]`; a singleton remains
 a full commit row. Pressing Enter on a summary expands that one segment in place;
 expansions accumulate until the display is the ordinary title-aligned history.
+Topological navigation treats each unexpanded segment summary as one node and
+does not expand it implicitly.
+
 Modal review and rewrite-target pickers retain the
 compressed projection so its points of interest remain available as targets,
 while conflict selection continues to show the full history. Leaving and
@@ -448,8 +459,8 @@ reload, discards accumulated expansions.
 
 The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
-for signature verification, alignment, message, and changes actions. The footer
-keeps every prefix compact. Opening one reverses its label and shows its available
+for signature verification, alignment, message, and changes actions. The
+footer keeps every prefix compact. Opening one reverses its label and shows its available
 items in a reversed, single-row popout immediately above and connected to that
 label; the `?` popout also contains its pane-switching and navigation hints through
 `<enter> diff`. The popout has horizontal padding, shifts left or clips at the
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 1124a0388e5..5cad94c908d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -340,6 +340,12 @@ pub(crate) enum Action {
     MoveDown,
     MoveUpBy(usize),
     MoveDownBy(usize),
+    TopologicalUp,
+    TopologicalDown,
+    PanUpBy(usize),
+    PanDownBy(usize),
+    PreviousChild,
+    NextChild,
     CycleDuplicate,
     ScrollLeft,
     ScrollRight,
@@ -524,6 +530,7 @@ pub(crate) struct App {
     test_lanes: Vec<String>,
     pub selected: Option<usize>,
     pub offset: usize,
+    viewport_panned: bool,
     pub state: State,
     pub(crate) deferred_history_state: Option<State>,
     pub viewport_rows: usize,
@@ -570,6 +577,7 @@ pub(crate) struct App {
     pub(crate) actions_expanded: bool,
     pub(crate) enrich_expanded: bool,
     pub(crate) information_expanded: bool,
+    topo_children: HashMap<ObjectId, ObjectId>,
     forget_confirmation: Option<ObjectId>,
     pub estimated_lane_width: usize,
     pub horizontal_offset: usize,
@@ -632,6 +640,7 @@ impl App {
             test_lanes: Vec::new(),
             selected: None,
             offset: 0,
+            viewport_panned: false,
             state: State::Loading,
             deferred_history_state: None,
             viewport_rows,
@@ -678,6 +687,7 @@ impl App {
             actions_expanded: false,
             enrich_expanded: false,
             information_expanded: false,
+            topo_children: HashMap::new(),
             forget_confirmation: None,
             estimated_lane_width: 0,
             horizontal_offset: 0,
@@ -1144,6 +1154,13 @@ impl App {
         )
     }
 
+    fn history_row(&self, index: usize) -> Option<&CommitRow> {
+        self.active_compressed_history().map_or_else(
+            || self.rows.get(index).map(Arc::as_ref),
+            |history| history.rows.get(index).map(Arc::as_ref),
+        )
+    }
+
     pub(crate) fn history_index(&self, canonical_index: usize) -> Option<usize> {
         self.active_compressed_history().map_or_else(
             || (canonical_index < self.rows.len()).then_some(canonical_index),
@@ -1255,6 +1272,136 @@ impl App {
         }
     }
 
+    fn topological_positions(&self) -> HashMap<ObjectId, usize> {
+        (0..self.history_len())
+            .filter_map(|index| self.history_row(index).map(|row| (row.id, index)))
+            .collect()
+    }
+
+    fn topological_graph(&self) -> Option<&Graph> {
+        self.active_compressed_history()
+            .map(|history| &history.graph)
+            .or(self.graph.as_ref())
+    }
+
+    fn topological_parent_from_rows(
+        &self,
+        index: usize,
+        positions: &HashMap<ObjectId, usize>,
+        stop: Option<usize>,
+    ) -> Option<usize> {
+        let mut parent = self.history_row(index)?.parent_ids.first().copied();
+        while let Some(id) = parent {
+            let index = *positions.get(&id)?;
+            if stop == Some(index) || self.history_entry_selectable(index) {
+                return Some(index);
+            }
+            parent = self.history_row(index)?.parent_ids.first().copied();
+        }
+        None
+    }
+
+    fn topological_parent(&self, index: usize, stop: Option<usize>) -> Option<usize> {
+        if let Some(graph) = self.topological_graph() {
+            let mut parent = graph.first_parents.get(index).copied().flatten();
+            while let Some(index) = parent {
+                if stop == Some(index) || self.history_entry_selectable(index) {
+                    return Some(index);
+                }
+                parent = graph.first_parents.get(index).copied().flatten();
+            }
+            return None;
+        }
+        self.topological_parent_from_rows(index, &self.topological_positions(), stop)
+    }
+
+    fn topological_children(&self, parent: usize) -> Vec<usize> {
+        if let Some(graph) = self.topological_graph() {
+            let mut pending = graph
+                .first_parent_children
+                .get(parent)
+                .into_iter()
+                .flatten()
+                .rev()
+                .copied()
+                .collect::<Vec<_>>();
+            let mut children = Vec::new();
+            while let Some(child) = pending.pop() {
+                if self.history_entry_selectable(child) {
+                    children.push(child);
+                } else if let Some(descendants) = graph.first_parent_children.get(child) {
+                    pending.extend(descendants.iter().rev().copied());
+                }
+            }
+            children.sort_unstable();
+            return children;
+        }
+        let positions = self.topological_positions();
+        (0..self.history_len())
+            .filter(|index| {
+                self.history_entry_selectable(*index)
+                    && self.topological_parent_from_rows(*index, &positions, Some(parent)) == Some(parent)
+            })
+            .collect()
+    }
+
+    fn topological_child_index(&self, parent: usize, children: &[usize]) -> usize {
+        self.history_row(parent)
+            .and_then(|row| self.topo_children.get(&row.id))
+            .and_then(|chosen| {
+                children
+                    .iter()
+                    .position(|child| self.history_row(*child).is_some_and(|row| row.id == *chosen))
+            })
+            .unwrap_or_default()
+    }
+
+    fn move_topologically(&mut self, down: bool) -> bool {
+        let Some(selected) = self.selected_history_index() else {
+            return false;
+        };
+        let next = if down {
+            self.topological_parent(selected, None)
+        } else {
+            let children = self.topological_children(selected);
+            children.get(self.topological_child_index(selected, &children)).copied()
+        };
+        let Some(next) = next else { return false };
+        self.select_history_index(next);
+        true
+    }
+
+    fn adjust_topological_child(&mut self, right: bool) {
+        let Some(selected) = self.selected_history_index() else {
+            return;
+        };
+        let children = self.topological_children(selected);
+        let Some(last) = children.len().checked_sub(1) else {
+            return;
+        };
+        let current = self.topological_child_index(selected, &children);
+        let next = if right {
+            current.saturating_add(1).min(last)
+        } else {
+            current.saturating_sub(1)
+        };
+        let Some((parent, child)) = self
+            .history_row(selected)
+            .zip(self.history_row(children[next]))
+            .map(|(parent, child)| (parent.id, child.id))
+        else {
+            return;
+        };
+        self.topo_children.insert(parent, child);
+    }
+
+    pub(crate) fn topological_choice(&self) -> Option<(usize, usize)> {
+        self.topological_graph()?;
+        let selected = self.selected_history_index()?;
+        let children = self.topological_children(selected);
+        (children.len() > 1).then(|| (self.topological_child_index(selected, &children) + 1, children.len()))
+    }
+
     fn select_history_index(&mut self, display: usize) {
         if !self.history_entry_selectable(display) {
             return;
@@ -1435,10 +1582,24 @@ impl App {
             Action::MoveDown if self.changes_focus.is_some() => self.move_changes(1, true),
             Action::MoveUpBy(distance) if self.changes_focus.is_some() => self.move_changes(distance, false),
             Action::MoveDownBy(distance) if self.changes_focus.is_some() => self.move_changes(distance, true),
-            Action::MoveUp => self.move_reachable(1, false),
-            Action::MoveDown => self.move_reachable(1, true),
-            Action::MoveUpBy(distance) => self.move_reachable(distance, false),
-            Action::MoveDownBy(distance) => self.move_reachable(distance, true),
+            Action::MoveUp => self.move_selection(1, false),
+            Action::MoveDown => self.move_selection(1, true),
+            Action::MoveUpBy(distance) => self.move_selection(distance, false),
+            Action::MoveDownBy(distance) => self.move_selection(distance, true),
+            Action::TopologicalUp => {
+                self.pending_initial_selection = None;
+                self.move_topologically(false);
+            }
+            Action::TopologicalDown => {
+                self.pending_initial_selection = None;
+                self.move_topologically(true);
+            }
+            Action::PanUpBy(distance) => self.pan_history(distance, false),
+            Action::PanDownBy(distance) => self.pan_history(distance, true),
+            Action::PreviousChild if self.changes_focus.is_some() => self.pan_horizontal(false),
+            Action::NextChild if self.changes_focus.is_some() => self.pan_horizontal(true),
+            Action::PreviousChild => self.adjust_topological_child(false),
+            Action::NextChild => self.adjust_topological_child(true),
             Action::CycleDuplicate => {
                 if self.changes_focus.is_none()
                     && self.reachable_rows.is_none()
@@ -1447,23 +1608,8 @@ impl App {
                     self.select(selected);
                 }
             }
-            Action::ScrollLeft => {
-                if self.changes_focus.is_some() {
-                    self.pan_changes(false);
-                } else {
-                    self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
-                }
-            }
-            Action::ScrollRight => {
-                if self.changes_focus.is_some() {
-                    self.pan_changes(true);
-                } else {
-                    self.horizontal_offset = self
-                        .horizontal_offset
-                        .saturating_add(self.horizontal_page)
-                        .min(self.horizontal_max);
-                }
-            }
+            Action::ScrollLeft => self.pan_horizontal(false),
+            Action::ScrollRight => self.pan_horizontal(true),
             Action::HalfPageUp if self.changes_focus.is_some() => {
                 self.move_changes((self.focused_changes().visible_paths() / 2).max(1), false);
             }
@@ -2272,7 +2418,7 @@ impl App {
         {
             self.center_selection();
         } else {
-            self.ensure_visible();
+            self.prepare_history_viewport();
         }
     }
 
@@ -2304,6 +2450,7 @@ impl App {
         self.test_lanes.clear();
         self.selected = None;
         self.offset = 0;
+        self.viewport_panned = false;
         self.state = State::Loading;
         self.lane_time = None;
         self.estimated_lane_width = 0;
@@ -2428,6 +2575,31 @@ impl App {
         };
     }
 
+    fn pan_horizontal(&mut self, right: bool) {
+        if self.changes_focus.is_some() {
+            self.pan_changes(right);
+        } else if right {
+            self.horizontal_offset = self
+                .horizontal_offset
+                .saturating_add(self.horizontal_page)
+                .min(self.horizontal_max);
+        } else {
+            self.horizontal_offset = self.horizontal_offset.saturating_sub(self.horizontal_page);
+        }
+    }
+
+    fn pan_history(&mut self, distance: usize, down: bool) {
+        self.pending_initial_selection = None;
+        self.follow_tail = false;
+        self.viewport_panned = true;
+        let max = self.history_len().saturating_sub(self.viewport_rows.max(1));
+        self.offset = if down {
+            self.offset.saturating_add(distance.max(1)).min(max)
+        } else {
+            self.offset.saturating_sub(distance.max(1))
+        };
+    }
+
     fn move_selection(&mut self, distance: usize, down: bool) {
         self.pending_initial_selection = None;
         let Some(display_selected) = self.selected_history_index() else {
@@ -2471,10 +2643,6 @@ impl App {
             .find(|index| self.change_id(self.rows[*index].id) == change_id)
     }
 
-    fn move_reachable(&mut self, distance: usize, down: bool) {
-        self.move_selection(distance, down);
-    }
-
     fn compute_reachable_rows(&mut self) {
         if self.state != State::Complete {
             self.reachable_rows = None;
@@ -3001,6 +3169,7 @@ impl App {
     }
 
     pub(crate) fn ensure_visible(&mut self) {
+        self.viewport_panned = false;
         let Some(selected) = self.selected_history_index() else {
             return;
         };
@@ -3013,6 +3182,16 @@ impl App {
         self.offset = self.offset.min(self.history_len().saturating_sub(height));
     }
 
+    pub(crate) fn prepare_history_viewport(&mut self) {
+        if self.viewport_panned {
+            self.offset = self
+                .offset
+                .min(self.history_len().saturating_sub(self.viewport_rows.max(1)));
+        } else {
+            self.ensure_visible();
+        }
+    }
+
     pub(crate) fn center_initial_selection(&mut self) {
         let Some(id) = self.pending_initial_selection else {
             return;
@@ -3060,6 +3239,10 @@ impl App {
         self.commit_offset = self.commit_offset.min(max);
     }
 
+    pub(crate) fn commit_paging_active(&self) -> bool {
+        self.show_commit && self.commit_max > 0
+    }
+
     pub(crate) fn reset_commit_view(&mut self) {
         self.commit_offset = 0;
         self.commit_max = 0;
@@ -3333,15 +3516,32 @@ pub(crate) struct Graph {
     offsets: Vec<usize>,
     columns: Vec<ObjectId>,
     visual_counts: Vec<usize>,
+    first_parents: Vec<Option<usize>>,
+    first_parent_children: Vec<Vec<usize>>,
 }
 
 impl Graph {
     fn new(rows: &[SharedCommitRow]) -> Self {
+        let positions: HashMap<_, _> = rows.iter().enumerate().map(|(index, row)| (row.id, index)).collect();
+        let mut first_parent_children = vec![Vec::new(); rows.len()];
+        let first_parents = rows
+            .iter()
+            .enumerate()
+            .map(|(child, row)| {
+                row.parent_ids
+                    .first()
+                    .and_then(|parent| positions.get(parent))
+                    .copied()
+                    .inspect(|parent| first_parent_children[*parent].push(child))
+            })
+            .collect();
         let mut state = LaneState::default();
         let mut graph = Graph {
             offsets: Vec::with_capacity(rows.len().div_ceil(CHECKPOINT_INTERVAL) + 1),
             columns: Vec::new(),
             visual_counts: visual_counts(rows),
+            first_parents,
+            first_parent_children,
         };
         for (index, row) in rows.iter().enumerate() {
             if index % CHECKPOINT_INTERVAL == 0 {
@@ -5012,6 +5212,124 @@ mod tests {
         assert_eq!(app.selected, Some(1));
     }
 
+    #[test]
+    fn topological_navigation_follows_first_parents_and_remembers_children() {
+        let mut app = App::new(5);
+        app.extend_commits(vec![
+            row_with_parents(5, &[3]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2, 1]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+
+        app.update(Action::TopologicalDown);
+        assert_eq!(app.rows[app.selected.expect("the fork is selected")].id, id(3));
+        assert_eq!(app.topological_choice(), Some((1, 2)));
+        app.update(Action::TopologicalUp);
+        assert_eq!(app.rows[app.selected.expect("the first child is selected")].id, id(5));
+        app.update(Action::TopologicalDown);
+
+        app.update(Action::NextChild);
+        app.update(Action::NextChild);
+        assert_eq!(app.topological_choice(), Some((2, 2)), "branch choices saturate");
+        app.update(Action::TopologicalUp);
+        assert_eq!(app.rows[app.selected.expect("the second child is selected")].id, id(4));
+        app.update(Action::TopologicalDown);
+        assert_eq!(
+            app.topological_choice(),
+            Some((2, 2)),
+            "returning to a fork restores its choice"
+        );
+
+        app.update(Action::PreviousChild);
+        app.update(Action::TopologicalDown);
+        assert_eq!(
+            app.rows[app.selected.expect("the first parent is selected")].id,
+            id(2),
+            "secondary merge parents are not topo-walk edges"
+        );
+        app.update(Action::TopologicalDown);
+        app.update(Action::TopologicalDown);
+        assert_eq!(app.rows[app.selected.expect("the root remains selected")].id, id(1));
+
+        app.update(Action::TopologicalUp);
+        app.update(Action::TopologicalUp);
+        assert_eq!(app.rows[app.selected.expect("the fork is selected again")].id, id(3));
+        app.update(Action::MoveUp);
+        assert_eq!(
+            app.rows[app.selected.expect("ordinary navigation is restored")].id,
+            id(4),
+            "ordinary movement remains display ordered after topological movement"
+        );
+    }
+
+    #[test]
+    fn topological_navigation_contracts_unselectable_rows() {
+        let mut app = App::new(4);
+        app.extend_commits(vec![
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        app.reachable_rows = Some(vec![true, false, true, true]);
+
+        app.update(Action::TopologicalDown);
+        assert_eq!(app.rows[app.selected.expect("the ancestor is selected")].id, id(2));
+        app.update(Action::TopologicalUp);
+        assert_eq!(
+            app.rows[app.selected.expect("the descendant is selected")].id,
+            id(4),
+            "the contracted edge works in both directions"
+        );
+
+        app.selected = Some(1);
+        app.update(Action::TopologicalUp);
+        assert_eq!(
+            app.rows[app.selected.expect("the selectable child is selected")].id,
+            id(4),
+            "an ineligible current row still anchors its child walk"
+        );
+    }
+
+    #[test]
+    fn viewport_navigation_pans_without_moving_the_cursor() {
+        let mut app = App::new(2);
+        app.extend_commits(
+            (1..=6)
+                .rev()
+                .map(|commit| numbered_row(commit, (commit > 1).then_some(commit - 1)))
+                .collect::<Vec<_>>(),
+        );
+
+        app.update(Action::PanDownBy(3));
+        app.prepare_history_viewport();
+        assert_eq!((app.selected, app.offset), (Some(0), 3));
+        app.update(Action::PanDownBy(app.viewport_rows));
+        assert_eq!(
+            (app.selected, app.offset),
+            (Some(0), 4),
+            "page movement clamps the viewport"
+        );
+        app.update(Action::TopologicalDown);
+        assert_eq!(
+            (app.selected, app.offset),
+            (Some(1), 1),
+            "a topo step brings its destination back into view"
+        );
+        app.update(Action::PanDownBy(app.viewport_rows));
+        app.update(Action::PanUpBy((app.viewport_rows / 2).max(1)));
+        assert_eq!((app.selected, app.offset), (Some(1), 2));
+        complete(&mut app);
+        assert_eq!(
+            (app.selected, app.offset),
+            (Some(1), 2),
+            "lane completion preserves a detached viewport"
+        );
+    }
+
     #[test]
     fn time_travel_selection_crosses_each_viewport_before_paging() {
         let mut app = App::new(4);
@@ -5127,6 +5445,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn topological_navigation_walks_compressed_segments_as_nodes() {
+        let mut app = App::new(3);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.set_view_tips(&[id(6)]);
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        let compressed_len = app.history_len();
+        assert!(compressed_len < app.rows.len());
+
+        app.update(Action::TopologicalDown);
+        assert!(
+            app.selected_is_segment(),
+            "the compressed quotient edge reaches its summary"
+        );
+        assert_eq!(
+            app.history_len(),
+            compressed_len,
+            "topo movement does not expand a summary"
+        );
+        app.update(Action::TopologicalDown);
+        assert_eq!(
+            app.rows[app.selected.expect("the compressed root is selected")].id,
+            id(1)
+        );
+        app.update(Action::TopologicalUp);
+        assert!(
+            app.selected_is_segment(),
+            "the quotient edge is traversable in both directions"
+        );
+        assert_eq!(app.history_len(), compressed_len);
+    }
+
     #[test]
     fn compressed_mode_transitions_keep_the_selected_viewport_row() {
         let mut app = App::new(4);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index fae60805fa6..6627708cc1f 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -1675,7 +1675,7 @@ fn event_loop(
                     }
                     ref_tree::Input::Quit => return Ok(None),
                 },
-                TerminalEvent::Mouse(mouse) if ref_tree.handle_mouse(mouse.kind, 1) => {
+                TerminalEvent::Mouse(mouse) if ref_tree.handle_mouse(mouse.kind, mouse.modifiers, 1) => {
                     dirty = true;
                     urgent = true;
                     continue;
@@ -1689,26 +1689,22 @@ fn event_loop(
                 let action = if diagnostic_input {
                     diagnostic_action(key, &app)
                 } else {
-                    action_with_shortcut_groups(
-                        key,
-                        app.history_display_expanded,
-                        app.commit_expanded,
-                        app.actions_expanded,
-                        app.enrich_expanded,
-                        app.information_expanded || app.changes_focus.is_some(),
-                    )
+                    app_action(key, &app)
                 };
                 let repeats_history = retains_fill_repository(key.kind, action.as_ref(), app.changes_focus.is_some());
                 (action, repeats_history, key.kind == KeyEventKind::Repeat, false)
             }
             TerminalEvent::Mouse(mouse) => {
                 let kind = mouse.kind;
+                let modifiers = mouse.modifiers;
                 let mut distance = 1;
                 if matches!(kind, MouseEventKind::ScrollUp | MouseEventKind::ScrollDown) {
                     while distance < EVENT_BATCH_SIZE && event::poll(Duration::ZERO)? {
                         let next = event::read()?;
                         match next {
-                            TerminalEvent::Mouse(next) if next.kind == kind => distance += 1,
+                            TerminalEvent::Mouse(next) if next.kind == kind && next.modifiers == modifiers => {
+                                distance += 1;
+                            }
                             next => {
                                 pending_terminal_event = Some(next);
                                 break;
@@ -1716,7 +1712,7 @@ fn event_loop(
                         }
                     }
                 }
-                let Some(action) = mouse_scroll_action(kind, distance) else {
+                let Some(action) = mouse_scroll_action(kind, modifiers, distance, app.changes_focus.is_some()) else {
                     continue;
                 };
                 let repeats_history = app.changes_focus.is_none() && repeats_viewport(&action);
@@ -4035,7 +4031,7 @@ fn draw(
         app.set_worktree_conflicted(changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
     }
     app.viewport_rows = app.viewport_rows.min(render_rows.max(1));
-    app.ensure_visible();
+    app.prepare_history_viewport();
     let start = app.offset.min(app.history_len());
     let end = start.saturating_add(render_rows).min(app.history_len());
     let visible_indices = app.visible_history_indices(start..end);
@@ -6040,15 +6036,7 @@ fn next_diagnostic_input(inputs: &mut VecDeque<KeyEvent>, state: State, lane_com
 }
 
 fn diagnostic_action(key: KeyEvent, app: &App) -> Option<Action> {
-    action_with_shortcut_groups(
-        key,
-        app.history_display_expanded,
-        app.commit_expanded,
-        app.actions_expanded,
-        app.enrich_expanded,
-        app.information_expanded || app.changes_focus.is_some(),
-    )
-    .filter(|action| {
+    app_action(key, app).filter(|action| {
         (action_allowed_during_rebase_continuation(Some(action), app.changes_focus.is_some())
             || matches!(
                 action,
@@ -6061,6 +6049,70 @@ fn diagnostic_action(key: KeyEvent, app: &App) -> Option<Action> {
     })
 }
 
+fn app_action(key: KeyEvent, app: &App) -> Option<Action> {
+    if key.kind != KeyEventKind::Release {
+        let shifted =
+            key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('H' | 'J' | 'K' | 'L'));
+        if shifted {
+            if app.changes_focus.is_none() {
+                match key.code {
+                    KeyCode::Up | KeyCode::Char('k' | 'K') => return Some(Action::TopologicalUp),
+                    KeyCode::Down | KeyCode::Char('j' | 'J') => return Some(Action::TopologicalDown),
+                    KeyCode::Left | KeyCode::Char('h' | 'H') => return Some(Action::PreviousChild),
+                    KeyCode::Right | KeyCode::Char('l' | 'L') => return Some(Action::NextChild),
+                    _ => {}
+                }
+            } else {
+                match key.code {
+                    KeyCode::Up | KeyCode::Char('k' | 'K') => return Some(Action::MoveUp),
+                    KeyCode::Down | KeyCode::Char('j' | 'J') => return Some(Action::MoveDown),
+                    KeyCode::Left | KeyCode::Char('h' | 'H') => return Some(Action::ScrollLeft),
+                    KeyCode::Right | KeyCode::Char('l' | 'L') => return Some(Action::ScrollRight),
+                    _ => {}
+                }
+            }
+        }
+
+        let paging = match key.code {
+            KeyCode::PageUp => Some((Action::PageUp, app.viewport_rows.max(1), false)),
+            KeyCode::PageDown => Some((Action::PageDown, app.viewport_rows.max(1), true)),
+            KeyCode::Char('u' | 'U') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some((Action::HalfPageUp, (app.viewport_rows / 2).max(1), false))
+            }
+            KeyCode::Char('d' | 'D') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some((Action::HalfPageDown, (app.viewport_rows / 2).max(1), true))
+            }
+            KeyCode::Char('b' | 'B') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some((Action::PageUp, app.viewport_rows.max(1), false))
+            }
+            KeyCode::Char('f' | 'F') if key.modifiers.contains(KeyModifiers::CONTROL) => {
+                Some((Action::PageDown, app.viewport_rows.max(1), true))
+            }
+            _ => None,
+        };
+        if let Some((cursor_action, distance, down)) = paging {
+            let shifted =
+                key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('U' | 'D' | 'B' | 'F'));
+            if shifted || app.changes_focus.is_some() || app.commit_paging_active() {
+                return Some(cursor_action);
+            }
+            return Some(if down {
+                Action::PanDownBy(distance)
+            } else {
+                Action::PanUpBy(distance)
+            });
+        }
+    }
+    action_with_shortcut_groups(
+        key,
+        app.history_display_expanded,
+        app.commit_expanded,
+        app.actions_expanded,
+        app.enrich_expanded,
+        app.information_expanded || app.changes_focus.is_some(),
+    )
+}
+
 fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_focused: bool) -> bool {
     matches!(
         action,
@@ -6069,6 +6121,12 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
                 | Action::MoveDown
                 | Action::MoveUpBy(_)
                 | Action::MoveDownBy(_)
+                | Action::PanUpBy(_)
+                | Action::PanDownBy(_)
+                | Action::TopologicalUp
+                | Action::TopologicalDown
+                | Action::PreviousChild
+                | Action::NextChild
                 | Action::CycleDuplicate
                 | Action::ScrollLeft
                 | Action::ScrollRight
@@ -6225,6 +6283,10 @@ fn repeats_viewport(action: &Action) -> bool {
             | Action::MoveDown
             | Action::MoveUpBy(_)
             | Action::MoveDownBy(_)
+            | Action::PanUpBy(_)
+            | Action::PanDownBy(_)
+            | Action::TopologicalUp
+            | Action::TopologicalDown
             | Action::HalfPageUp
             | Action::HalfPageDown
             | Action::PageUp
@@ -6238,10 +6300,20 @@ fn retains_fill_repository(kind: KeyEventKind, action: Option<&Action>, changes_
     !changes_focused && kind == KeyEventKind::Repeat && action.is_some_and(repeats_viewport)
 }
 
-fn mouse_scroll_action(kind: MouseEventKind, distance: usize) -> Option<Action> {
+fn mouse_scroll_action(
+    kind: MouseEventKind,
+    modifiers: KeyModifiers,
+    distance: usize,
+    changes_focused: bool,
+) -> Option<Action> {
+    let shifted = modifiers.contains(KeyModifiers::SHIFT);
     match kind {
-        MouseEventKind::ScrollUp => Some(Action::MoveUpBy(distance.max(1))),
-        MouseEventKind::ScrollDown => Some(Action::MoveDownBy(distance.max(1))),
+        MouseEventKind::ScrollUp if shifted || changes_focused => Some(Action::MoveUpBy(distance.max(1))),
+        MouseEventKind::ScrollDown if shifted || changes_focused => Some(Action::MoveDownBy(distance.max(1))),
+        MouseEventKind::ScrollUp => Some(Action::PanUpBy(distance.max(1))),
+        MouseEventKind::ScrollDown => Some(Action::PanDownBy(distance.max(1))),
+        MouseEventKind::ScrollLeft if shifted => Some(Action::PreviousChild),
+        MouseEventKind::ScrollRight if shifted => Some(Action::NextChild),
         MouseEventKind::ScrollLeft => Some(Action::ScrollLeft),
         MouseEventKind::ScrollRight => Some(Action::ScrollRight),
         _ => None,
@@ -7821,6 +7893,94 @@ mod tests {
         );
     }
 
+    #[test]
+    fn shift_applies_topology_to_directions_and_cursor_movement_to_pages() {
+        let key = |code| KeyEvent::new(code, KeyModifiers::NONE);
+        let shifted = |code| KeyEvent::new(code, KeyModifiers::SHIFT);
+        let mut app = App::new(8);
+        app.information_expanded = true;
+        assert_eq!(
+            app_action(key(KeyCode::Char('o')), &app),
+            None,
+            "the topo toggle is gone"
+        );
+        app.information_expanded = false;
+
+        for (key, expected) in [
+            (shifted(KeyCode::Up), Action::TopologicalUp),
+            (shifted(KeyCode::Char('k')), Action::TopologicalUp),
+            (key(KeyCode::Char('K')), Action::TopologicalUp),
+            (shifted(KeyCode::Down), Action::TopologicalDown),
+            (shifted(KeyCode::Char('j')), Action::TopologicalDown),
+            (key(KeyCode::Char('J')), Action::TopologicalDown),
+            (shifted(KeyCode::Left), Action::PreviousChild),
+            (shifted(KeyCode::Char('h')), Action::PreviousChild),
+            (key(KeyCode::Char('H')), Action::PreviousChild),
+            (shifted(KeyCode::Right), Action::NextChild),
+            (shifted(KeyCode::Char('l')), Action::NextChild),
+            (key(KeyCode::Char('L')), Action::NextChild),
+        ] {
+            assert_eq!(app_action(key, &app), Some(expected));
+        }
+
+        assert_eq!(app_action(key(KeyCode::Up), &app), Some(Action::MoveUp));
+        app.history_display_expanded = true;
+        assert_eq!(app_action(key(KeyCode::Char('h')), &app), Some(Action::ToggleHidden));
+        assert_eq!(
+            app_action(shifted(KeyCode::Char('h')), &app),
+            Some(Action::PreviousChild),
+            "shifted navigation outranks an open shortcut group"
+        );
+        app.history_display_expanded = false;
+
+        let control = |character| KeyEvent::new(KeyCode::Char(character), KeyModifiers::CONTROL);
+        let control_shift =
+            |character| KeyEvent::new(KeyCode::Char(character), KeyModifiers::CONTROL | KeyModifiers::SHIFT);
+        for (key, expected) in [
+            (key(KeyCode::PageUp), Action::PanUpBy(8)),
+            (key(KeyCode::PageDown), Action::PanDownBy(8)),
+            (control('u'), Action::PanUpBy(4)),
+            (control('d'), Action::PanDownBy(4)),
+            (control('b'), Action::PanUpBy(8)),
+            (control('f'), Action::PanDownBy(8)),
+            (shifted(KeyCode::PageUp), Action::PageUp),
+            (shifted(KeyCode::PageDown), Action::PageDown),
+            (control_shift('u'), Action::HalfPageUp),
+            (control_shift('d'), Action::HalfPageDown),
+            (control_shift('b'), Action::PageUp),
+            (control_shift('f'), Action::PageDown),
+        ] {
+            assert_eq!(app_action(key, &app), Some(expected));
+        }
+        assert_eq!(
+            app_action(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::CONTROL), &app),
+            Some(Action::HalfPageUp),
+            "uppercase Ctrl paging retains its Shift meaning instead of invoking redo"
+        );
+
+        app.changes_focus = Some(ChangePane::Tree);
+        app.history_display_expanded = true;
+        assert_eq!(
+            app_action(key(KeyCode::Char('H')), &app),
+            Some(Action::ScrollLeft),
+            "shifted directions remain pane-local while changes are focused"
+        );
+        assert_eq!(
+            app_action(key(KeyCode::PageUp), &app),
+            Some(Action::PageUp),
+            "focused panes retain their own paging"
+        );
+
+        app.changes_focus = None;
+        app.show_commit = true;
+        app.set_commit_bounds(2, 1);
+        assert_eq!(
+            app_action(key(KeyCode::PageUp), &app),
+            Some(Action::PageUp),
+            "overflowing commit messages retain their own paging"
+        );
+    }
+
     #[test]
     fn diagnostic_inputs_wait_for_completed_lanes() {
         let key = diagnostic_key('j');
@@ -7950,29 +8110,39 @@ mod tests {
     }
 
     #[test]
-    fn maps_continuous_mouse_scrolling_to_navigation() {
+    fn shift_switches_mouse_scrolling_from_viewport_to_cursor_navigation() {
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollUp, 4),
-            Some(Action::MoveUpBy(4))
+            mouse_scroll_action(MouseEventKind::ScrollUp, KeyModifiers::NONE, 4, false),
+            Some(Action::PanUpBy(4))
         );
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollDown, 3),
+            mouse_scroll_action(MouseEventKind::ScrollDown, KeyModifiers::SHIFT, 3, false),
             Some(Action::MoveDownBy(3))
         );
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollLeft, 1),
+            mouse_scroll_action(MouseEventKind::ScrollLeft, KeyModifiers::NONE, 1, false),
             Some(Action::ScrollLeft)
         );
         assert_eq!(
-            mouse_scroll_action(MouseEventKind::ScrollRight, 1),
-            Some(Action::ScrollRight)
+            mouse_scroll_action(MouseEventKind::ScrollRight, KeyModifiers::SHIFT, 1, false),
+            Some(Action::NextChild)
+        );
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::ScrollUp, KeyModifiers::NONE, 2, true),
+            Some(Action::MoveUpBy(2)),
+            "focused changes retain cursor navigation"
+        );
+        assert_eq!(
+            mouse_scroll_action(MouseEventKind::Moved, KeyModifiers::NONE, 1, false),
+            None
         );
-        assert_eq!(mouse_scroll_action(MouseEventKind::Moved, 1), None);
         assert!(repeats_viewport(
-            &mouse_scroll_action(MouseEventKind::ScrollDown, 2).expect("vertical scrolling has an action")
+            &mouse_scroll_action(MouseEventKind::ScrollDown, KeyModifiers::NONE, 2, false)
+                .expect("vertical scrolling has an action")
         ));
         assert!(!repeats_viewport(
-            &mouse_scroll_action(MouseEventKind::ScrollRight, 1).expect("horizontal scrolling has an action")
+            &mouse_scroll_action(MouseEventKind::ScrollRight, KeyModifiers::NONE, 1, false)
+                .expect("horizontal scrolling has an action")
         ));
     }
 
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 7b5accb68cf..823524c3cfc 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -21,13 +21,6 @@ use crate::{
     ui::{decoration_style, notice_area, render_notice},
 };
 
-#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
-enum Motion {
-    #[default]
-    Nearest,
-    Topological,
-}
-
 #[derive(Clone, Copy, Debug, Default)]
 struct Offset {
     x: usize,
@@ -151,7 +144,6 @@ pub(crate) struct SelectionFallback {
 #[derive(Default)]
 pub(crate) struct Tree {
     active: bool,
-    motion: Motion,
     overview: Option<Overview>,
     alternate_overview: Option<Overview>,
     overlay: Option<Overlay>,
@@ -353,31 +345,29 @@ impl Tree {
             self.toggle_tags();
             return Input::Handled;
         }
-        if key.code == KeyCode::Tab {
-            self.motion = match self.motion {
-                Motion::Nearest => Motion::Topological,
-                Motion::Topological => Motion::Nearest,
-            };
-            return Input::Handled;
-        }
         if key.modifiers.contains(KeyModifiers::CONTROL) {
             let amount = self.offset().page_height.max(1);
-            match key.code {
-                KeyCode::Char('u') => self.page(Direction::Up, (amount / 2).max(1)),
-                KeyCode::Char('d') => self.page(Direction::Down, (amount / 2).max(1)),
-                KeyCode::Char('b') => self.page(Direction::Up, amount),
-                KeyCode::Char('f') => self.page(Direction::Down, amount),
+            let (direction, amount) = match key.code {
+                KeyCode::Char('u' | 'U') => (Direction::Up, (amount / 2).max(1)),
+                KeyCode::Char('d' | 'D') => (Direction::Down, (amount / 2).max(1)),
+                KeyCode::Char('b' | 'B') => (Direction::Up, amount),
+                KeyCode::Char('f' | 'F') => (Direction::Down, amount),
                 _ => return Input::Handled,
+            };
+            if key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('U' | 'D' | 'B' | 'F')) {
+                self.page(direction, amount);
+            } else {
+                self.pan(direction, amount);
             }
             return Input::Handled;
         }
         match key.code {
             KeyCode::PageUp => {
-                self.page(Direction::Up, self.offset().page_height.max(1));
+                self.page_or_pan(Direction::Up, key.modifiers);
                 return Input::Handled;
             }
             KeyCode::PageDown => {
-                self.page(Direction::Down, self.offset().page_height.max(1));
+                self.page_or_pan(Direction::Down, key.modifiers);
                 return Input::Handled;
             }
             _ => {}
@@ -385,15 +375,13 @@ impl Tree {
         let Some(direction) = direction(key.code) else {
             return Input::Handled;
         };
-        if key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('H' | 'J' | 'K' | 'L')) {
-            self.pan(direction, 1);
-        } else {
-            self.navigate(direction);
-        }
+        let topological =
+            key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('H' | 'J' | 'K' | 'L'));
+        self.navigate(direction, topological);
         Input::Handled
     }
 
-    pub(crate) fn handle_mouse(&mut self, kind: MouseEventKind, distance: usize) -> bool {
+    pub(crate) fn handle_mouse(&mut self, kind: MouseEventKind, modifiers: KeyModifiers, distance: usize) -> bool {
         let direction = match kind {
             MouseEventKind::ScrollUp => Direction::Up,
             MouseEventKind::ScrollDown => Direction::Down,
@@ -401,7 +389,11 @@ impl Tree {
             MouseEventKind::ScrollRight => Direction::Right,
             _ => return false,
         };
-        self.pan(direction, distance.max(1));
+        if modifiers.contains(KeyModifiers::SHIFT) {
+            self.navigate(direction, false);
+        } else {
+            self.pan(direction, distance.max(1));
+        }
         true
     }
 
@@ -484,7 +476,6 @@ impl Tree {
             placed,
             offset,
             selected,
-            self.motion,
             &self.choices,
             &self.history_commits,
         );
@@ -506,17 +497,13 @@ impl Tree {
                 format!("ref-tree · e edit ({})", actions.join(" · "))
             }
         } else {
-            let motion = match self.motion {
-                Motion::Nearest => "nearest",
-                Motion::Topological => "topo ↑ leaves · ↓ roots · ←/→ branch",
-            };
             let tags = if self.hide_tags { "off" } else { "on" };
             let counts = self.count_anchor.map_or_else(
                 || "Space counts:auto".into(),
                 |id| format!("Space counts:{}", self.node_label(id)),
             );
             format!(
-                "ref-tree · {motion} · {counts} · g top · G root · T tags:{tags} · Shift+directions pan · <enter> pin · e edit · t/Esc history"
+                "ref-tree · {counts} · g top · G root · T tags:{tags} · Shift+directions topo · mouse/pages pan · Shift+mouse/pages cursor · <enter> pin · e edit · t/Esc history"
             )
         };
         frame.render_widget(
@@ -642,24 +629,25 @@ impl Tree {
             .unwrap_or_else(|| id.to_hex_with_len(7).to_string())
     }
 
-    fn navigate(&mut self, direction: Direction) {
+    fn navigate(&mut self, direction: Direction, topological: bool) {
         let Some(overview) = self.overview.as_ref() else { return };
         let Some(selected) = self.selected else { return };
-        let next = if self.motion == Motion::Topological {
+        let next = if topological {
             match direction {
                 Direction::Up => overview.nodes[selected]
                     .children
                     .get(self.choices[selected].min(overview.nodes[selected].children.len().saturating_sub(1)))
                     .copied(),
                 Direction::Down => overview.nodes[selected].parent,
-                Direction::Left => {
-                    self.choices[selected] = self.choices[selected].saturating_sub(1);
-                    None
-                }
-                Direction::Right => {
-                    self.choices[selected] = self.choices[selected]
-                        .saturating_add(1)
-                        .min(overview.nodes[selected].children.len().saturating_sub(1));
+                Direction::Left | Direction::Right => {
+                    let last = overview.nodes[selected].children.len().saturating_sub(1);
+                    let choice = self.choices[selected].min(last);
+                    let next = if matches!(direction, Direction::Left) {
+                        choice.saturating_sub(1)
+                    } else {
+                        choice.saturating_add(1).min(last)
+                    };
+                    self.choices[selected] = next;
                     None
                 }
             }
@@ -788,6 +776,15 @@ impl Tree {
         }
     }
 
+    fn page_or_pan(&mut self, direction: Direction, modifiers: KeyModifiers) {
+        let amount = self.offset().page_height.max(1);
+        if modifiers.contains(KeyModifiers::SHIFT) {
+            self.page(direction, amount);
+        } else {
+            self.pan(direction, amount);
+        }
+    }
+
     fn offset(&self) -> &Offset {
         &self.offset
     }
@@ -1298,7 +1295,6 @@ fn draw_nodes(
     placed: &Placed,
     offset: Offset,
     selected: Option<usize>,
-    motion: Motion,
     choices: &[usize],
     history_commits: &HashSet<ObjectId>,
 ) {
@@ -1312,7 +1308,7 @@ fn draw_nodes(
         }
         let count = overlay.and_then(|overlay| overlay.counts[index]);
         let mut text = rail_label(node, count);
-        if selected == Some(index) && motion == Motion::Topological && node.children.len() > 1 {
+        if selected == Some(index) && node.children.len() > 1 {
             write!(
                 text,
                 " {}/{}",
@@ -1346,19 +1342,7 @@ fn draw_nodes(
                 style = style.add_modifier(Modifier::DIM);
             }
         }
-        let marker_style = if selected == Some(index) && node.is_anchor {
-            style.remove_modifier(Modifier::REVERSED)
-        } else {
-            style
-        };
-        put(
-            frame,
-            area,
-            offset,
-            point,
-            if node.is_head { '@' } else { '●' },
-            marker_style,
-        );
+        put(frame, area, offset, point, if node.is_head { '@' } else { '●' }, style);
         draw_text(
             frame,
             area,
@@ -1967,7 +1951,6 @@ mod tests {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        tree.motion = Motion::Topological;
         let mut terminal = Terminal::new(TestBackend::new(100, 18))?;
         terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
         let main = tree
@@ -1978,7 +1961,7 @@ mod tests {
 
         tree.handle_key(KeyEvent::new(KeyCode::Char(' '), KeyModifiers::NONE));
         assert_eq!(tree.count_anchor, Some(main), "Space anchors counts to the cursor");
-        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::SHIFT));
         assert!(tree.overlay.is_some(), "anchored navigation retains reachability");
         assert!(tree.placed.is_some(), "anchored navigation retains tree placement");
         assert_eq!(
@@ -2021,7 +2004,7 @@ mod tests {
             "Space on the anchor restores automatic counts"
         );
         assert!(tree.overlay.is_some(), "clearing at the cursor reuses the same overlay");
-        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));
+        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::SHIFT));
         assert!(
             tree.overlay.is_none(),
             "automatic counts invalidate when the cursor moves"
@@ -2235,21 +2218,49 @@ mod tests {
     }
 
     #[test]
-    fn topological_navigation_and_g_shortcuts_reach_the_top_and_root() {
+    fn shift_navigation_is_topological_without_retaining_a_mode() {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
-        tree.motion = Motion::Topological;
         let overview = tree.overview.as_ref().expect("overview exists");
         let root = overview.by_commit[&graph.index(id(1)).expect("root exists")];
         let fork = overview.by_commit[&graph.index(id(2)).expect("fork exists")];
         let main = overview.by_commit[&graph.index(id(6)).expect("main exists")];
         tree.selected = Some(root);
 
-        tree.navigate(Direction::Up);
-        assert_eq!(tree.selected, Some(fork), "up moves toward a leaf");
-        tree.navigate(Direction::Down);
-        assert_eq!(tree.selected, Some(root), "down moves toward the root");
+        tree.handle_key(KeyEvent::new(KeyCode::Up, KeyModifiers::SHIFT));
+        assert_eq!(tree.selected, Some(fork), "Shift-Up moves toward a leaf");
+        tree.handle_key(KeyEvent::new(KeyCode::Down, KeyModifiers::SHIFT));
+        assert_eq!(tree.selected, Some(root), "Shift-Down moves toward the root");
+
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        let nearest = nearest(
+            &tree.placed.as_ref().expect("the ref-tree is placed").nodes,
+            root,
+            Direction::Up,
+        );
+        tree.handle_key(KeyEvent::new(KeyCode::Up, KeyModifiers::NONE));
+        assert_eq!(tree.selected, nearest, "plain Up immediately returns to nearest motion");
+
+        tree.selected = Some(fork);
+        tree.handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT));
+        assert_eq!(
+            tree.selected,
+            Some(fork),
+            "a usable branch choice does not move the cursor"
+        );
+        tree.handle_key(KeyEvent::new(KeyCode::Right, KeyModifiers::SHIFT));
+        assert_eq!(tree.selected, Some(fork), "a saturated branch choice is a no-op");
+        let chosen = tree.overview.as_ref().expect("overview exists").nodes[fork].children[1];
+        tree.handle_key(KeyEvent::new(KeyCode::Char('K'), KeyModifiers::NONE));
+        assert_eq!(
+            tree.selected,
+            Some(chosen),
+            "uppercase navigation is treated as shifted"
+        );
+
+        tree.handle_key(KeyEvent::new(KeyCode::Tab, KeyModifiers::NONE));
+        assert_eq!(tree.selected, Some(chosen), "Tab no longer toggles a motion mode");
 
         tree.handle_key(KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE));
         assert_eq!(tree.selected, Some(main), "plain g reaches the top selectable node");
@@ -2266,7 +2277,7 @@ mod tests {
     }
 
     #[test]
-    fn page_keys_move_the_cursor_while_mouse_scrolling_only_pans() {
+    fn plain_pages_and_mouse_pan_while_shift_moves_the_cursor() {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
@@ -2282,23 +2293,54 @@ mod tests {
         tree.selected = Some(first);
         let first_y = points[first].y;
 
+        tree.offset.max_y = tree
+            .placed
+            .as_ref()
+            .expect("the ref-tree is placed")
+            .height
+            .saturating_sub(tree.offset.page_height);
         tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE));
+        assert_eq!(tree.selected, Some(first), "plain PageDown leaves the cursor alone");
+        assert!(tree.offset.y > 0, "plain PageDown pans the viewport");
+
+        tree.offset.y = 0;
+        tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::SHIFT));
         let full_page = tree.selected.expect("PageDown retains a selection");
         let full_page_y = points[full_page].y;
-        assert!(full_page_y > first_y, "PageDown advances the ref-tree cursor");
-        assert!(tree.ensure_visible, "page navigation keeps the new cursor visible");
+        assert!(full_page_y > first_y, "Shift-PageDown advances the ref-tree cursor");
+        assert!(
+            tree.ensure_visible,
+            "shifted page navigation keeps the new cursor visible"
+        );
 
         tree.selected = Some(first);
         tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL));
+        assert_eq!(tree.selected, Some(first), "plain Ctrl-d leaves the cursor alone");
+
+        tree.handle_key(KeyEvent::new(
+            KeyCode::Char('d'),
+            KeyModifiers::CONTROL | KeyModifiers::SHIFT,
+        ));
         let half_page_y = points[tree.selected.expect("Ctrl-d retains a selection")].y;
         assert!(
             half_page_y > first_y && half_page_y <= full_page_y,
             "half-page navigation advances no farther than a full page"
         );
 
-        let selected = tree.selected;
-        tree.handle_mouse(MouseEventKind::ScrollDown, 2);
-        assert_eq!(tree.selected, selected, "mouse scrolling remains viewport-only");
+        tree.selected = Some(first);
+        tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));
+        tree.handle_mouse(MouseEventKind::ScrollDown, KeyModifiers::NONE, 2);
+        assert_eq!(
+            tree.selected,
+            Some(first),
+            "plain mouse scrolling remains viewport-only"
+        );
+        tree.handle_mouse(MouseEventKind::ScrollDown, KeyModifiers::SHIFT, 1);
+        assert_ne!(
+            tree.selected,
+            Some(first),
+            "Shift-mouse scrolling moves the nearest cursor"
+        );
     }
 
     #[test]
@@ -2553,10 +2595,10 @@ mod tests {
         let point = placed.nodes[selected];
         let rail_width = placed.rail_width;
         assert!(
-            !terminal.backend().buffer()[(point.x as u16, point.y as u16)]
+            terminal.backend().buffer()[(point.x as u16, point.y as u16)]
                 .modifier
                 .contains(Modifier::REVERSED),
-            "the selected disk is not inverted"
+            "the selected disk is inverted with its label"
         );
         assert!(
             terminal.backend().buffer()[(rail_width as u16, point.y as u16)]
@@ -2592,6 +2634,20 @@ mod tests {
                 .contains(Modifier::REVERSED),
             "a selected synthetic node keeps its disk inverted"
         );
+        assert!(
+            terminal
+                .backend()
+                .buffer()
+                .content
+                .chunks(100)
+                .nth(point.y)
+                .expect("the selected fork has a rendered row")
+                .iter()
+                .map(ratatui::buffer::Cell::symbol)
+                .collect::<String>()
+                .contains("1/2"),
+            "a selected fork always identifies its chosen child"
+        );
         tree.leave_error("remote deletion failed");
         terminal.draw(|frame| tree.draw(frame, Some(&graph)))?;
         assert_eq!(terminal.backend().buffer()[(2, 16)].bg, Color::LightRed);
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 7864cfc8888..853460958f8 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -498,7 +498,7 @@ pub(crate) fn draw_with_worktree(
         .unwrap_or(body.height)
         .max(1) as usize;
     app.center_initial_selection();
-    app.ensure_visible();
+    app.prepare_history_viewport();
     let start = app.offset.min(app.history_len());
     let render_end = start.saturating_add(body.height as usize).min(app.history_len());
     let visible_entries: Vec<_> = (start..render_end)
@@ -688,6 +688,7 @@ pub(crate) fn draw_with_worktree(
         (!time_travel_animation && !selected_segment)
             .then_some(app.selection_relation)
             .flatten(),
+        app.topological_choice(),
     );
     let selection_info_width = selection_info.width();
     let mut selection_info_area = None;
@@ -1354,7 +1355,9 @@ pub(crate) fn draw_with_worktree(
                 });
             }
         }
-        items.push(Span::raw(" · ↑↓/jk move · h/l pan"));
+        items.push(Span::raw(
+            " · ↑↓/jk move · h/l pan · Shift+directions topo · wheel/page pan · Shift+wheel/page move",
+        ));
         if app.changes_focus.is_none() {
             items.push(Span::raw(if selected_segment {
                 " · <enter> expand"
@@ -1536,8 +1539,21 @@ fn render_changes_divider(frame: &mut Frame<'_>, panes: &[ChangesPaneArea], app:
     }
 }
 
-fn selection_info_line(changes: Option<&Changes>, relation: Option<SelectionRelation>) -> Line<'static> {
+fn selection_info_line(
+    changes: Option<&Changes>,
+    relation: Option<SelectionRelation>,
+    topological_choice: Option<(usize, usize)>,
+) -> Line<'static> {
     let mut spans = Vec::new();
+    if let Some((choice, total)) = topological_choice {
+        push_selection_span(
+            &mut spans,
+            Span::styled(
+                format!("{choice}/{total}"),
+                selection_color(Color::Yellow).add_modifier(Modifier::BOLD),
+            ),
+        );
+    }
     if let Some(changes) = changes {
         if changes.lines_added > 0 {
             push_selection_span(
@@ -3471,7 +3487,7 @@ mod tests {
         assert!(buffer[(37, 0)].modifier.contains(Modifier::REVERSED));
 
         let text = |relation| {
-            selection_info_line(None, relation)
+            selection_info_line(None, relation, None)
                 .spans
                 .into_iter()
                 .map(|span| span.content.into_owned())
@@ -3480,12 +3496,56 @@ mod tests {
         assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 2 })), "⇣2");
         assert_eq!(text(Some(SelectionRelation::Tracking { ahead: 0, behind: 0 })), "");
         assert!(
-            selection_info_line(Some(&Changes::default()), None).spans.is_empty(),
+            selection_info_line(Some(&Changes::default()), None, None)
+                .spans
+                .is_empty(),
             "selection information hides empty diff counts"
         );
         Ok(())
     }
 
+    #[test]
+    fn renders_the_topological_child_choice_outside_selection_inversion() -> Result<(), Box<dyn std::error::Error>> {
+        let ids = [1, 2, 3].map(|byte| gix::ObjectId::Sha1([byte; 20]));
+        let commit = |id, parent: Option<gix::ObjectId>, title: &'static str| Commit {
+            id,
+            parent_ids: parent.into_iter().collect(),
+            author_time: gix::date::Time::default(),
+            committer_time: gix::date::Time::default(),
+            author: author(b"author", b"author@example.com"),
+            attributions: 0..0,
+            title: title.into(),
+            metadata_loaded: true,
+            has_agent_marker: false,
+            is_review: false,
+            signature: SignatureState::Unsigned,
+        };
+        let mut app = App::new(3);
+        app.extend_commits(vec![
+            commit(ids[2], Some(ids[0]), "first child"),
+            commit(ids[1], Some(ids[0]), "second child"),
+            commit(ids[0], None, "fork"),
+        ]);
+        complete(&mut app);
+        app.select_commit(ids[0]);
+        app.update(Action::NextChild);
+        let mut terminal = Terminal::new(TestBackend::new(80, 4))?;
+
+        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+
+        let row = rendered_line(&terminal, 2);
+        let choice_byte = row.find("2/2").expect("the selected fork shows its child choice");
+        let choice_x = row[..choice_byte].chars().count() as u16;
+        let cell = &terminal.backend().buffer()[(choice_x, 2)];
+        assert_eq!(cell.fg, Color::Yellow);
+        assert!(cell.modifier.contains(Modifier::BOLD));
+        assert!(
+            !cell.modifier.contains(Modifier::REVERSED),
+            "the choice annotation does not extend row inversion"
+        );
+        Ok(())
+    }
+
     #[test]
     fn renders_a_colored_file_diff_pager() -> Result<(), Box<dyn std::error::Error>> {
         let diff = BuiltInDiff::new(
@@ -4247,7 +4307,7 @@ mod tests {
         app.changes_mode = None;
         app.configure_hidden_filter(true);
         app.history_display_expanded = true;
-        let mut terminal = Terminal::new(TestBackend::new(180, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(240, 2))?;
 
         terminal.draw(|frame| {
             super::draw_with_worktree(
@@ -4311,7 +4371,7 @@ mod tests {
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
-        let information = "[ title · ref-tree · message · changes · ↑↓/jk move · h/l pan · <enter> diff";
+        let information = "[ title · ref-tree · message · changes · ↑↓/jk move · h/l pan · Shift+directions topo · wheel/page pan · Shift+wheel/page move · <enter> diff";
         assert!(rendered_line(&terminal, 0).contains(information));
         assert_reversed_group(&terminal, 1, "?");
         assert_reversed_group(&terminal, 0, &format!(" {information} "));
@@ -5782,7 +5842,7 @@ mod tests {
         })?;
         assert!(
             rendered_line(&footer_terminal, 14).contains(
-                " [ title · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · <enter> diff "
+                " [ title · ref-tree · message · changes · <tab> switch · ↑↓/jk move · h/l pan · Shift+directions topo · wheel/page pan · Shift+wheel/page move · <enter> diff "
             ),
             "the expanded information prefix floats its actions above the footer"
         );

From 5f4d56691dcbd0b404e81cc8e662fd1ccc31a2ed Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 11:10:26 +0200
Subject: [PATCH 269/282] feat(gix-tix): add no-alt-screen diagnostics

Render the interactive UI in a full-height inline viewport when requested so its frame and panic output remain visible. Restore terminal input modes, cursor state, and raw mode on normal, error, and panic paths.
---
 gix-tix/spec.md        | 10 ++++++---
 gix-tix/src/command.rs | 30 ++++++++++++++++++++++++---
 gix-tix/src/lib.rs     | 46 +++++++++++++++++++++++++++++++++---------
 3 files changed, 71 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 08e8143c8f2..94a53618d79 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -106,6 +106,9 @@ without trading responsiveness for metadata that is not visible.
   frame, allowing navigation such as `--quit-on-finish=jjjl`. Inputs that would
   mutate the repository, launch another program, or copy data are ignored. The
   frame is drawn on the normal screen and remains visible after exit.
+- `--no-alt-screen` runs the interactive UI in a full-height inline viewport on
+  the normal screen, retaining its frame and panic output for diagnostics. Input
+  handling otherwise matches the default interactive mode.
 - `tix rebase todo [-x HIDDEN...] [--no-auto-hide]
   [--onto REV | --update-base] [TIP...]`
   writes a self-contained Markdown history-rebase plan to stdout. Visible tips
@@ -140,10 +143,11 @@ without trading responsiveness for metadata that is not visible.
 - Revisions must resolve and peel to commits. Invalid or non-commit visible
   revisions are errors. An unavailable hidden revision emits a warning and is
   ignored when another hidden revision resolves; if none resolve, startup fails.
-- The interactive UI owns the alternate screen. Raw mode, focus reporting, mouse
-  capture, and enhanced keyboard reporting are restored on every exit path.
+- The interactive UI owns the alternate screen by default. `--no-alt-screen`
+  instead draws interactively on the normal screen. Raw mode, focus reporting,
+  mouse capture, and enhanced keyboard reporting are restored on every exit path.
   Shutdown leaves the alternate screen without clearing it or writing afterward.
-  `--quit-on-finish` instead draws without input reporting on the normal screen.
+  `--quit-on-finish` draws without input reporting on the normal screen.
 - `Ctrl-C` exits immediately from any normal tix focus without recovery
   bookkeeping. `q` always quits from history, including while a conflict or
   rebase continuation is suspended. Before that normal exit, tix journals
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 438e4ba9b87..4dca972de03 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -20,6 +20,9 @@ mod travel;
 #[derive(Debug, clap::Args)]
 #[command(args_conflicts_with_subcommands = true)]
 pub struct Platform {
+    /// Draw on the normal screen so panic output remains visible.
+    #[arg(long)]
+    no_alt_screen: bool,
     /// Exit after the final frame, optionally replaying read-only INPUTS first.
     #[arg(
         long,
@@ -175,13 +178,22 @@ impl Platform {
     /// Run this command against `repository`.
     pub fn run(self, repository: gix::ThreadSafeRepository) -> Result<()> {
         let Platform {
+            no_alt_screen,
             quit_on_finish,
             hide,
             command,
             revisions,
         } = self;
         let Some(command) = command else {
-            return crate::run(repository, revisions, crate::Options { quit_on_finish, hide });
+            return crate::run(
+                repository,
+                revisions,
+                crate::Options {
+                    no_alt_screen,
+                    quit_on_finish,
+                    hide,
+                },
+            );
         };
 
         let repository = repository.to_thread_local();
@@ -736,8 +748,18 @@ mod tests {
 
     #[test]
     fn parses_tui_options_and_top_level_commands() {
-        let cli = Cli::try_parse_from(["tix", "--quit-on-finish", "-x", "main", "--hide", "tag", "topic"])
-            .expect("TUI arguments parse");
+        let cli = Cli::try_parse_from([
+            "tix",
+            "--no-alt-screen",
+            "--quit-on-finish",
+            "-x",
+            "main",
+            "--hide",
+            "tag",
+            "topic",
+        ])
+        .expect("TUI arguments parse");
+        assert!(cli.platform.no_alt_screen);
         assert_eq!(cli.platform.quit_on_finish, Some(String::new()));
         assert_eq!(cli.platform.hide, ["main", "tag"], "hide options append");
         assert_eq!(
@@ -1549,6 +1571,7 @@ mod tests {
         let linked_target = linked.find_reference(retained_ref.as_ref())?.id().detach();
 
         Platform {
+            no_alt_screen: false,
             quit_on_finish: None,
             hide: Vec::new(),
             command: Some(Command::Admin(Admin::ClearUndo)),
@@ -1571,6 +1594,7 @@ mod tests {
         );
 
         Platform {
+            no_alt_screen: false,
             quit_on_finish: None,
             hide: Vec::new(),
             command: Some(Command::Admin(Admin::ClearUndo)),
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 6627708cc1f..a7cd5db3688 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -648,6 +648,8 @@ impl BuiltInDiff {
 /// Options for [`run()`].
 #[derive(Clone, Debug, Default)]
 pub struct Options {
+    /// Draw interactively on the normal screen instead of the alternate screen.
+    pub no_alt_screen: bool,
     /// Exit after the final frame, optionally replaying read-only keyboard input first.
     pub quit_on_finish: Option<String>,
     /// Revisions whose reachable commits should initially be hidden.
@@ -708,15 +710,24 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     );
     let commit_pane_background = detect_commit_pane_background();
     let quit_on_finish = options.quit_on_finish.is_some();
-    let mut terminal = if quit_on_finish {
+    let inline = quit_on_finish || options.no_alt_screen;
+    let terminal_result = if inline {
         let (_, height) = terminal::size().context("could not determine terminal size")?;
         ratatui::try_init_with_options(TerminalOptions {
             viewport: Viewport::Inline(height),
         })
     } else {
         ratatui::try_init()
-    }
-    .context("could not initialize terminal")?;
+    };
+    let mut terminal = terminal_result
+        .inspect_err(|_| {
+            if inline {
+                let _ = terminal::disable_raw_mode();
+            } else {
+                ratatui::restore();
+            }
+        })
+        .context("could not initialize terminal")?;
     let enhanced_keyboard = !quit_on_finish && terminal::supports_keyboard_enhancement().unwrap_or(false);
     let keyboard_setup = if quit_on_finish {
         Ok(())
@@ -726,6 +737,15 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
     let result = keyboard_setup
         .context("could not enable enhanced keyboard events")
         .and_then(|()| {
+            if !quit_on_finish {
+                let hook = std::panic::take_hook();
+                std::panic::set_hook(Box::new(move |info| {
+                    let mut backend = CrosstermBackend::new(std::io::stdout());
+                    let _ = disable_input(&mut backend, enhanced_keyboard);
+                    let _ = execute!(backend, cursor::Show);
+                    hook(info);
+                }));
+            }
             event_loop(
                 &mut terminal,
                 repository,
@@ -736,27 +756,33 @@ pub fn run(repository: gix::ThreadSafeRepository, revisions: Vec<OsString>, mut
             )
         });
     let keyboard_restore = if quit_on_finish {
+        Ok(())
+    } else {
+        disable_input(terminal.backend_mut(), enhanced_keyboard)
+    };
+    let cursor_restore = if inline {
         let area = terminal.get_frame().area();
         terminal
             .set_cursor_position(Position::new(area.x, area.bottom().saturating_sub(1)))
             .and_then(|()| terminal.show_cursor())
     } else {
-        disable_input(terminal.backend_mut(), enhanced_keyboard)
+        Ok(())
     };
     drop(terminal);
-    let restore = if quit_on_finish {
+    let restore = if inline {
         terminal::disable_raw_mode()
     } else {
         ratatui::try_restore()
     }
     .context("could not restore terminal");
+    if inline {
+        eprintln!();
+    }
     let lane_time = result?;
     keyboard_restore.context("could not restore keyboard events")?;
+    cursor_restore.context("could not restore terminal cursor")?;
     restore?;
     if let Some(lane_time) = lane_time {
-        if quit_on_finish {
-            eprintln!();
-        }
         eprintln!("lane computation: {:.3}s", lane_time.as_secs_f64());
     }
     Ok(())
@@ -804,7 +830,9 @@ fn event_loop(
     enhanced_keyboard: bool,
     commit_pane_background: Option<(u8, u8, u8)>,
 ) -> Result<Option<Duration>> {
-    let Options { quit_on_finish, hide } = options;
+    let Options {
+        quit_on_finish, hide, ..
+    } = options;
     let mut quit_inputs: VecDeque<_> = quit_on_finish
         .as_deref()
         .unwrap_or_default()

From c96e21d3b8747f37905351769d025c7f4a3a947a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 11:51:30 +0200
Subject: [PATCH 270/282] perf(gix-tix): retire idle line-diff workers

Open one repository per lazily activated worker set and share it among thread-local worker handles. Retain the workers for ten seconds after a completed batch, then wake the event loop to join the pool and release its repository resources. Rebuild diff platforms for each batch so retained repositories do not preserve stale diff state.
---
 gix-tix/AGENTS.md  |   2 +-
 gix-tix/spec.md    |  18 +++--
 gix-tix/src/lib.rs | 176 +++++++++++++++++++++++++++++++++------------
 3 files changed, 146 insertions(+), 50 deletions(-)

diff --git a/gix-tix/AGENTS.md b/gix-tix/AGENTS.md
index 8878716974e..ed189e5847f 100644
--- a/gix-tix/AGENTS.md
+++ b/gix-tix/AGENTS.md
@@ -50,7 +50,7 @@
   the original worktree directory and process CWD may no longer exist; recover
   to the normalized common repository before processing watchers, loading view
   data, or drawing.
-- Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle. The sole exception is an unresolved in-memory rebase result awaiting the user's immediate accept-or-cancel key; dropping it must leave no observable repository state.
+- Do not retain a `gix::Repository`, or a platform/object that owns one, in application or event-loop state while tix is idle. Exceptions are an unresolved in-memory rebase result awaiting the user's immediate accept-or-cancel key, and line-diff worker repositories during their bounded ten-second reuse window. The event loop must wake at the line-diff deadline and join the entire pool; workers must rebuild diff platforms per batch, and dropping either exception must leave no observable repository state.
 - Open a fresh, non-isolated repository for bounded view population so configuration such as mailmap and diff filters is honored, then retain only detached display data.
 - The fill repository may be reused only while continuous navigation is active and must be dropped when its idle timer expires.
 - Filesystem watchers retain paths and native watcher handles, never repositories.
diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 94a53618d79..854a28670f5 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -642,8 +642,12 @@ space first; changes blocks adapt within the remaining history width.
 - Tree diff results, detached diff resources, and line counts use a bounded MRU
   while changes remain enabled. Worktree results are cached separately and
   invalidated by relevant filesystem events.
-- Per-file line information is computed once in an `available_parallelism`
-  worker pool that exists only while changes are enabled.
+- Per-file line information is computed once in a lazily activated
+  `available_parallelism` worker pool. One repository is opened per activation
+  and cheaply cloned into thread-local worker handles; per-batch diff platforms
+  are discarded after use. Ten seconds without a completed line-count batch
+  joins the workers and releases their repositories. The next uncached diff
+  reactivates the pool, while hiding changes drops it immediately.
 
 ### Diffs
 
@@ -1224,7 +1228,9 @@ space first; changes blocks adapt within the remaining history width.
 ## Resource and responsiveness invariants
 
 - No `gix::Repository`, commit-graph, object platform, notes platform, or other
-  repository-owning value may remain in idle application/event-loop state.
+  repository-owning value may remain in idle application/event-loop state,
+  except line-diff worker repositories during their bounded ten-second reuse
+  window.
 - Hidden-revision startup validation returns only detached revision and warning
   data; its temporary repository is dropped before terminal initialization and
   the event loop.
@@ -1236,8 +1242,10 @@ space first; changes blocks adapt within the remaining history width.
   during continuous key-repeat or mouse navigation. It is dropped after the
   75 ms idle boundary.
 - Traversal and incremental refresh workers may use a bounded object cache and
-  must drop their repository when finished. Lane, verification, and line-diff
-  workers exist only for active work and do not form persistent pools.
+  must drop their repository when finished. Lane and verification workers exist
+  only for active work. Line-diff workers may remain for ten seconds after their
+  latest batch, then are joined together and release their shared repository
+  resources.
 - Change IDs are scanned only while configured hidden tips are actively excluded.
   Unrestricted and explicitly expanded views perform no scan. A refresh keeps
   the current projection's IDs until it has synchronously scanned the replacement,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a7cd5db3688..821b72190ce 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -64,6 +64,7 @@ const REF_EVENT_IDLE: Duration = Duration::from_millis(100);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 const WATCH_RETRY_INTERVAL: Duration = Duration::from_secs(5);
+const LINE_DIFF_POOL_IDLE: Duration = Duration::from_secs(10);
 const THEME_QUERY_TIMEOUT: Duration = Duration::from_millis(100);
 
 struct FillRepository {
@@ -355,16 +356,20 @@ enum LineDiffResult {
 }
 
 struct LineDiffPool {
+    repository_path: PathBuf,
+    bare: bool,
+    parallelism: usize,
+    active: Option<LineDiffWorkers>,
+    last_used: Option<Instant>,
+}
+
+struct LineDiffWorkers {
     jobs: Vec<mpsc::Sender<LineDiffMessage>>,
     results: mpsc::Receiver<LineDiffResult>,
     workers: Vec<std::thread::JoinHandle<()>>,
 }
 
-type LineDiffState = (
-    gix::Repository,
-    gix::diff::blob::Platform,
-    Option<gix::diff::blob::Platform>,
-);
+type LineDiffState = (gix::diff::blob::Platform, Option<gix::diff::blob::Platform>);
 
 fn worktree_diff_cache(
     repository: &gix::Repository,
@@ -440,24 +445,65 @@ fn line_counts_for_change(
     Ok(counts.map(|counts| (counts.insertions, counts.removals)))
 }
 
-fn open_line_diff_state(repository_path: &Path, bare: bool) -> Result<LineDiffState> {
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not open repository for parallel line diffs")?;
-    repository.object_cache_size(OBJECT_CACHE_SIZE);
+fn line_diff_state(repository: &gix::Repository) -> Result<LineDiffState> {
     let tree_cache = repository
         .diff_resource_cache_for_tree_diff()
         .context("could not initialize parallel line diffs")?;
-    let worktree_cache = if bare {
-        None
-    } else {
-        worktree_diff_cache(&repository, gix::diff::blob::pipeline::Mode::ToGit)?
-    };
-    Ok((repository, tree_cache, worktree_cache))
+    let worktree_cache = worktree_diff_cache(repository, gix::diff::blob::pipeline::Mode::ToGit)?;
+    Ok((tree_cache, worktree_cache))
 }
 
 impl LineDiffPool {
+    fn new(repository_path: &Path, bare: bool, parallelism: usize) -> Self {
+        LineDiffPool {
+            repository_path: repository_path.to_owned(),
+            bare,
+            parallelism: parallelism.max(1),
+            active: None,
+            last_used: None,
+        }
+    }
+
+    fn line_counts(&mut self, changes: Vec<FileChange>) -> Result<Vec<(FileChange, LineCounts)>> {
+        if self.active.is_none() {
+            self.active = Some(LineDiffWorkers::new(
+                &self.repository_path,
+                self.bare,
+                self.parallelism,
+            )?);
+        }
+        let result = self
+            .active
+            .as_mut()
+            .expect("line diff workers were just initialized")
+            .line_counts(changes);
+        self.last_used = Some(Instant::now());
+        result
+    }
+
+    fn expire(&mut self, now: Instant) -> bool {
+        let expired = self
+            .last_used
+            .is_some_and(|last_used| now.saturating_duration_since(last_used) >= LINE_DIFF_POOL_IDLE);
+        if expired {
+            self.active = None;
+            self.last_used = None;
+        }
+        expired
+    }
+
+    fn idle_timeout(&self, now: Instant) -> Option<Duration> {
+        self.last_used
+            .map(|last_used| LINE_DIFF_POOL_IDLE.saturating_sub(now.saturating_duration_since(last_used)))
+    }
+}
+
+impl LineDiffWorkers {
     fn new(repository_path: &Path, bare: bool, parallelism: usize) -> Result<Self> {
-        drop(open_line_diff_state(repository_path, bare)?);
+        let repository = open_repository(repository_path, bare, false)
+            .context("could not open repository for parallel line diffs")?;
+        drop(line_diff_state(&repository)?);
+        let repository = repository.into_sync();
         let (result_sender, results) = mpsc::channel();
         let mut jobs = Vec::with_capacity(parallelism);
         let workers = (0..parallelism)
@@ -465,20 +511,22 @@ impl LineDiffPool {
                 let (job_sender, job_receiver) = mpsc::channel();
                 jobs.push(job_sender);
                 let result_sender = result_sender.clone();
-                let repository_path = repository_path.to_owned();
+                let repository = repository.clone();
                 std::thread::spawn(move || {
+                    let mut repository = repository.to_thread_local();
+                    repository.object_cache_size(OBJECT_CACHE_SIZE);
                     let mut state: Option<LineDiffState> = None;
                     while let Ok(message) = job_receiver.recv() {
                         match message {
                             LineDiffMessage::Job(job) => {
                                 let result = (|| {
                                     if state.is_none() {
-                                        state = Some(open_line_diff_state(&repository_path, bare)?);
+                                        state = Some(line_diff_state(&repository)?);
                                     }
-                                    let (repository, tree_cache, worktree_cache) =
+                                    let (tree_cache, worktree_cache) =
                                         state.as_mut().expect("line diff state was just initialized");
                                     let result = line_counts_for_change(
-                                        repository,
+                                        &repository,
                                         &job.change,
                                         tree_cache,
                                         worktree_cache.as_mut(),
@@ -507,7 +555,7 @@ impl LineDiffPool {
                 })
             })
             .collect();
-        Ok(LineDiffPool { jobs, results, workers })
+        Ok(LineDiffWorkers { jobs, results, workers })
     }
 
     fn line_counts(&mut self, changes: Vec<FileChange>) -> Result<Vec<(FileChange, LineCounts)>> {
@@ -551,7 +599,7 @@ impl LineDiffPool {
     }
 }
 
-impl Drop for LineDiffPool {
+impl Drop for LineDiffWorkers {
     fn drop(&mut self) {
         self.jobs.clear();
         for worker in self.workers.drain(..) {
@@ -566,13 +614,12 @@ fn sync_line_diff_pool(
     repository_path: &Path,
     bare: bool,
     parallelism: usize,
-) -> Result<()> {
+) {
     if visible && pool.is_none() {
-        *pool = Some(LineDiffPool::new(repository_path, bare, parallelism.max(1))?);
+        *pool = Some(LineDiffPool::new(repository_path, bare, parallelism));
     } else if !visible {
         *pool = None;
     }
-    Ok(())
 }
 
 enum FileDiff {
@@ -916,7 +963,7 @@ fn event_loop(
         &repository_path,
         repository_is_bare,
         line_diff_parallelism,
-    )?;
+    );
     if worktree_watcher_needed(repository_is_bare, app.changes_mode) {
         match start_worktree_watcher(&repository_path, repository_is_bare) {
             Ok(watcher) => worktree_watcher = Some(watcher),
@@ -962,6 +1009,9 @@ fn event_loop(
     let mut pending_todo_ref_changes = Vec::new();
     let mut pending_conflict_resolution: Option<PendingConflictResolution> = None;
     let result: Result<Option<Duration>> = (|| loop {
+        if let Some(pool) = line_diff_pool.as_mut() {
+            pool.expire(Instant::now());
+        }
         if let Some(mut recovered) =
             recover_event_loop_repository(&mut repository_path, &common_dir, &mut repository_is_bare)?
         {
@@ -985,7 +1035,7 @@ fn event_loop(
                 &repository_path,
                 true,
                 line_diff_parallelism,
-            )?;
+            );
             tracing::warn!(common_dir = %repository_path.display(), "worktree disappeared; recovered with common repository");
             ref_watcher = match start_ref_watcher(&repository_path, &repository_path) {
                 Ok(watcher) => Some(watcher),
@@ -1511,6 +1561,9 @@ fn event_loop(
         let retry_timeout = watcher_retry_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
         let history_status_timeout =
             history_status_deadline.map(|deadline| deadline.saturating_duration_since(Instant::now()));
+        let line_diff_timeout = line_diff_pool
+            .as_ref()
+            .and_then(|pool| pool.idle_timeout(Instant::now()));
         let wake_after = [
             repeat_timeout,
             watcher_timeout,
@@ -1518,6 +1571,7 @@ fn event_loop(
             worktree_timeout,
             retry_timeout,
             history_status_timeout,
+            line_diff_timeout,
         ]
         .into_iter()
         .flatten()
@@ -1889,7 +1943,7 @@ fn event_loop(
                     &repository_path,
                     repository_is_bare,
                     line_diff_parallelism,
-                )?;
+                );
                 if worktree_watcher.is_none() {
                     match start_worktree_watcher(&repository_path, repository_is_bare) {
                         Ok(watcher) => worktree_watcher = Some(watcher),
@@ -2155,7 +2209,7 @@ fn event_loop(
                 &repository_path,
                 repository_is_bare,
                 line_diff_parallelism,
-            )?;
+            );
             if app.changes_mode == Some(ChangesMode::Both) {
                 invalidate_worktree_changes(&mut worktree_changes);
                 worktree_watch_set_changed = false;
@@ -6963,19 +7017,13 @@ mod tests {
     fn loads_changes_against_each_merge_parent() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_read_only("history.sh")?;
         let repository = crate::test_repository::open(&fixture)?;
-        let mut line_diff_pool = None;
-        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, false, 2)?;
-        assert_eq!(
-            line_diff_pool.as_ref().map(|pool| pool.workers.len()),
-            Some(2),
-            "showing changes creates the requested worker pool"
+        let mut line_diff_pool_slot = None;
+        sync_line_diff_pool(&mut line_diff_pool_slot, true, &fixture, false, 2);
+        let line_diff_pool = line_diff_pool_slot.as_mut().expect("changes enable the line diff pool");
+        assert!(
+            line_diff_pool.active.is_none(),
+            "workers start only with an uncached diff"
         );
-        sync_line_diff_pool(&mut line_diff_pool, false, &fixture, false, 2)?;
-        assert!(line_diff_pool.is_none(), "hiding changes destroys the worker pool");
-        sync_line_diff_pool(&mut line_diff_pool, true, &fixture, false, 2)?;
-        let line_diff_pool = line_diff_pool
-            .as_mut()
-            .expect("showing changes recreates the worker pool");
 
         let root = load_changes(
             &repository,
@@ -6985,6 +7033,28 @@ mod tests {
             },
             line_diff_pool,
         )?;
+        assert_eq!(
+            line_diff_pool.active.as_ref().map(|active| active.workers.len()),
+            Some(2),
+            "an uncached diff creates the requested workers"
+        );
+        let started = Instant::now();
+        line_diff_pool.last_used = Some(started);
+        let just_before_expiry = started + LINE_DIFF_POOL_IDLE.saturating_sub(Duration::from_nanos(1));
+        assert_eq!(
+            line_diff_pool.idle_timeout(just_before_expiry),
+            Some(Duration::from_nanos(1)),
+            "the event loop can wake exactly when workers expire"
+        );
+        assert!(
+            !line_diff_pool.expire(just_before_expiry),
+            "workers remain available until their idle timeout"
+        );
+        assert!(
+            line_diff_pool.expire(started + LINE_DIFF_POOL_IDLE),
+            "workers expire exactly at their idle timeout"
+        );
+        assert!(line_diff_pool.active.is_none(), "expiry releases every worker");
         assert_eq!(
             root.paths,
             [PathChange {
@@ -7055,6 +7125,10 @@ mod tests {
             parent: 0,
         };
         let topic = load_changes(&repository, topic_target, line_diff_pool)?;
+        assert!(
+            line_diff_pool.active.is_some(),
+            "the next uncached diff recreates workers"
+        );
         assert_eq!(
             topic.paths,
             [
@@ -7255,6 +7329,11 @@ mod tests {
             first_parent.parent,
             "parent selection wraps around"
         );
+        sync_line_diff_pool(&mut line_diff_pool_slot, false, &fixture, false, 2);
+        assert!(
+            line_diff_pool_slot.is_none(),
+            "hiding changes immediately releases the pool"
+        );
         Ok(())
     }
 
@@ -7269,8 +7348,17 @@ mod tests {
             Some(true),
             "repository configuration suppresses worktree operations"
         );
-        assert!(
-            LineDiffPool::new(&git_dir, true, 1).is_ok(),
+        let mut line_diff_pool = LineDiffPool::new(&git_dir, true, 1);
+        let root = repository.rev_parse_single("v1^{}")?.detach();
+        assert_eq!(
+            load_changes(
+                &repository,
+                app::TreeDiffTarget::Commit { id: root, parent: 0 },
+                &mut line_diff_pool,
+            )?
+            .paths
+            .len(),
+            1,
             "tree changes remain available without a worktree"
         );
         Ok(())
@@ -7399,7 +7487,7 @@ mod tests {
         std::fs::write(path.join("ignored"), "ignored\n")?;
 
         let repository = test_repository::open(path)?;
-        let mut line_diff_pool = LineDiffPool::new(path, false, 2)?;
+        let mut line_diff_pool = LineDiffPool::new(path, false, 2);
         let changes = load_worktree_changes(&repository, &mut line_diff_pool)?;
         let rows: Vec<_> = changes
             .paths

From 5daf9446816da9e53661807b6964e5e58c3bf714 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 12:12:42 +0200
Subject: [PATCH 271/282] fix(gix-tix): avoid pins during rebase continuation

Record externally amended conflict resolutions in the rewrite mapping and preserve that mapping across intermediate materialization. Use it for final continuation checkout so superseded resolution commits are recognized as rewritten instead of pinned as departures.
---
 gix-tix/src/command/rebase.rs   | 27 +++++++++++++++++-
 gix-tix/src/edit/rebase.rs      | 17 +++++++++--
 gix-tix/src/edit/time_travel.rs | 50 +++++++++++++--------------------
 gix-tix/src/lib.rs              | 42 ++++++++++++++-------------
 4 files changed, 83 insertions(+), 53 deletions(-)

diff --git a/gix-tix/src/command/rebase.rs b/gix-tix/src/command/rebase.rs
index 0b62d6aff75..6c6599c5792 100644
--- a/gix-tix/src/command/rebase.rs
+++ b/gix-tix/src/command/rebase.rs
@@ -597,7 +597,7 @@ mod tests {
             "the materialized conflict commit records the ours tree"
         );
 
-        std::fs::write(fixture.path().join("file"), b"base\n")?;
+        std::fs::write(fixture.path().join("file"), b"resolved first\n")?;
         assert!(
             Command::new("git")
                 .arg("-C")
@@ -606,10 +606,20 @@ mod tests {
                 .status()?
                 .success()
         );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "--amend", "--no-edit"])
+                .status()?
+                .success(),
+            "resolving through the CLI may amend the materialized conflict before continuing"
+        );
         let repo = crate::test_repository::open_with(
             fixture.path(),
             ["user.name=todo author", "user.email=todo@example.com"],
         )?;
+        let first_resolution = repo.head_id()?.detach();
         let next_output = output_dir.path().join("continue-again.md");
         let err = apply_document(repo, &continuation, Some(&next_output))
             .expect_err("the descendant conflict stops the continuation");
@@ -617,6 +627,12 @@ mod tests {
             format!("{err:#}").contains("materialized conflict"),
             "the second conflict is materialized: {err:#}"
         );
+        assert!(
+            crate::history::all_pins(&crate::test_repository::open(fixture.path())?)?
+                .iter()
+                .all(|pin| pin.id != first_resolution),
+            "continuing does not pin the superseded CLI resolution"
+        );
         std::fs::write(fixture.path().join("file"), b"resolved again\n")?;
         assert!(
             Command::new("git")
@@ -626,6 +642,15 @@ mod tests {
                 .status()?
                 .success()
         );
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["commit", "-q", "--amend", "--no-edit"])
+                .status()?
+                .success(),
+            "the final conflict may also be amended before continuing"
+        );
         let repo = crate::test_repository::open_with(
             fixture.path(),
             ["user.name=todo author", "user.email=todo@example.com"],
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index c70360dce85..da3df8cbda7 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -1585,6 +1585,7 @@ pub(crate) fn perform_plan_with_progress(
     let mut conflict = None;
     let mut marked = false;
     for (index, step) in plan.steps.iter().enumerate() {
+        let mut resolved_head = None;
         let parent = match step.parent {
             PlanParent::Existing(id) => {
                 repo.find_commit(id).context("could not find a fork target")?;
@@ -1602,11 +1603,13 @@ pub(crate) fn perform_plan_with_progress(
                 .context("could not decode a picked commit")?
                 .into_owned()
                 .context("could not own a picked commit")?,
-            PlanCommit::Resolved(_) => {
-                let mut commit = repo
+            PlanCommit::Resolved(planned) => {
+                let head = repo
                     .head()?
                     .peel_to_commit()
-                    .context("could not resolve the conflicted HEAD commit")?
+                    .context("could not resolve the conflicted HEAD commit")?;
+                resolved_head = Some((*planned, head.id));
+                let mut commit = head
                     .decode()
                     .context("could not decode the conflicted HEAD commit")?
                     .into_owned()
@@ -1778,6 +1781,14 @@ pub(crate) fn perform_plan_with_progress(
         {
             note_rewrites.push((old_id, new_id));
         }
+        if let Some((planned, actual)) = resolved_head
+            && actual != planned
+        {
+            rewritten.insert(actual, Some(new_id));
+            if actual != new_id {
+                note_rewrites.push((actual, new_id));
+            }
+        }
         for old_id in step.squash.iter().take(applied_squash) {
             rewritten.insert(*old_id, Some(new_id));
             if *old_id != new_id {
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index 9b649e5f19e..a86928ffd85 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -143,6 +143,12 @@ pub(crate) fn materialize_plan_conflict_reporting(
     Vec<super::undo::RefChange>,
 )> {
     let original = conflict.original();
+    let mapped_head = conflict
+        .repository()
+        .head()?
+        .id()
+        .map(gix::Id::detach)
+        .map(|id| (id, conflict.map(id)));
     let mut conflict = conflict.into_conflict().persist()?;
     let mut ref_changes = std::mem::take(&mut conflict.ref_changes);
     let (notice, mut checkout_changes) = move_head_to_reporting(
@@ -152,7 +158,10 @@ pub(crate) fn materialize_plan_conflict_reporting(
         None,
         revisions,
         include_worktrees,
-        |id| conflict.map(id),
+        |id| match mapped_head {
+            Some((head, mapped)) if head == id => mapped,
+            _ => conflict.map(id),
+        },
     )?;
     ref_changes.append(&mut checkout_changes);
     let mut deletion_changes = delete_deferred_refs(repository_path, bare, &conflict.deferred_ref_deletions)?;
@@ -178,17 +187,16 @@ pub(crate) fn checkout_without_replay(
     revisions: &[OsString],
     include_worktrees: bool,
 ) -> Result<Option<String>> {
-    Ok(checkout_without_replay_reporting(repository_path, bare, selected, revisions, include_worktrees)?.0)
-}
-
-pub(crate) fn checkout_without_replay_reporting(
-    repository_path: &Path,
-    bare: bool,
-    selected: ObjectId,
-    revisions: &[OsString],
-    include_worktrees: bool,
-) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
-    move_head(repository_path, bare, selected, revisions, include_worktrees)
+    Ok(move_head_to_reporting(
+        repository_path,
+        bare,
+        selected,
+        None,
+        revisions,
+        include_worktrees,
+        Some,
+    )?
+    .0)
 }
 
 #[cfg(test)]
@@ -278,24 +286,6 @@ pub(crate) fn checkout_plan_reporting(
     Ok((notice, ref_changes))
 }
 
-fn move_head(
-    repository_path: &Path,
-    bare: bool,
-    selected: ObjectId,
-    revisions: &[OsString],
-    include_worktrees: bool,
-) -> Result<(Option<String>, Vec<super::undo::RefChange>)> {
-    move_head_to_reporting(
-        repository_path,
-        bare,
-        selected,
-        None,
-        revisions,
-        include_worktrees,
-        Some,
-    )
-}
-
 #[cfg(test)]
 fn move_head_to<F>(
     repository_path: &Path,
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 821b72190ce..63db320f523 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2086,30 +2086,30 @@ fn event_loop(
             })();
             match result {
                 Ok(edit::rebase::PlanPerform::Complete(outcome)) => {
-                    let notice = outcome
-                        .selected
-                        .map(|selected| {
-                            edit::time_travel::checkout_without_replay_reporting(
-                                &repository_path,
-                                repository_is_bare,
-                                selected,
-                                &revisions,
-                                false,
-                            )
-                        })
-                        .transpose()
-                        .map(|result| result.map_or((None, Vec::new()), |(notice, changes)| (notice, changes)));
+                    let checkout = if outcome.selected.is_some() {
+                        edit::time_travel::checkout_plan_reporting(
+                            &repository_path,
+                            repository_is_bare,
+                            &outcome,
+                            &revisions,
+                            false,
+                        )
+                    } else {
+                        Ok((None, outcome.ref_changes.clone()))
+                    };
                     app.clear_rebase_conflict();
                     app.clear_rebase_continuation();
                     app.set_worktree_conflicted(false);
                     let mut changes = std::mem::take(&mut pending_todo_ref_changes);
-                    changes.extend(outcome.ref_changes.iter().cloned());
-                    let message = match notice {
-                        Ok((notice, mut checkout_changes)) => {
-                            changes.append(&mut checkout_changes);
+                    let message = match checkout {
+                        Ok((notice, mut outcome_changes)) => {
+                            changes.append(&mut outcome_changes);
                             notice.unwrap_or_else(|| "rebased history".into())
                         }
-                        Err(err) => format!("rebase applied, checkout failed: {err:#}"),
+                        Err(err) => {
+                            changes.extend(outcome.ref_changes.iter().cloned());
+                            format!("rebase applied, checkout failed: {err:#}")
+                        }
                     };
                     leave_recorded_success(
                         &mut app,
@@ -8719,7 +8719,7 @@ mod tests {
         let graph = HistoryGraph::for_commits(&repository, &plan.scope)?;
         let outcome = edit::rebase::perform_plan(&repository, &graph, plan)?.complete()?;
         let resolved = outcome.map(head).context("the conflicted commit is retained")?;
-        edit::time_travel::checkout_without_replay(fixture.path(), false, resolved, &[], false)?;
+        edit::time_travel::checkout_plan(fixture.path(), false, &outcome, &[], false)?;
 
         let repository = test_repository::open(fixture.path())?;
         assert_eq!(
@@ -8755,6 +8755,10 @@ mod tests {
                 .all(|entry| entry.stage() == gix::index::entry::Stage::Unconflicted),
             "the final index has no conflict stages"
         );
+        assert!(
+            history::all_pins(&repository)?.iter().all(history::Pin::is_head),
+            "continuing a resolved plan creates no ordinary pin for its superseded conflict checkout"
+        );
         assert!(
             !git(&["ls-files", "--error-unmatch", "unrelated"])?.status.success(),
             "unrelated unstaged paths remain untouched"

From 21419f7cf8e16baf17d824096c1d1fee535091f0 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 12:37:40 +0200
Subject: [PATCH 272/282] fix(gix-tix): retain history selection after time
 travel

Restore the animation origin and its viewport row, and retain the mapped time-travel destination through refreshes.

When a refresh no longer contains the selected object ID, match the displayed entry number within its visual base, then keep the nearest prior row before falling back to the top. Schedule refreshes when lazy finalization changes refs without producing a checkout notice.
---
 gix-tix/src/app.rs | 164 +++++++++++++++++++++++++++++++++++++++------
 gix-tix/src/lib.rs |  11 +--
 2 files changed, 151 insertions(+), 24 deletions(-)

diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 5cad94c908d..ce672a13924 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -524,7 +524,7 @@ pub(crate) struct App {
     compressed_anchor: Option<ObjectId>,
     compressed_segment: Option<ObjectId>,
     compressed_expanded: HashSet<ObjectId>,
-    time_travel_animation: Option<ObjectId>,
+    time_travel_animation: Option<(ObjectId, usize)>,
     attributions: Vec<Attribution>,
     #[cfg(test)]
     test_lanes: Vec<String>,
@@ -2339,6 +2339,12 @@ impl App {
             return;
         }
         let select_top = std::mem::take(&mut self.select_top_after_refresh);
+        let previous_selection = if select_top { None } else { self.selected };
+        let previous_visual_position = previous_selection.and_then(|index| {
+            let count = self.visual_count(index)?;
+            let base = self.rows.get(index.checked_add(count)?)?.id;
+            Some((base, count, index))
+        });
         let segment = (!select_top && self.selection_after_refresh.is_none())
             .then_some(self.compressed_segment)
             .flatten();
@@ -2395,8 +2401,33 @@ impl App {
         self.graph = Some(graph);
         self.lane_time = Some(lane_time);
         self.update_worktree_head_descendants();
+        let visual_counts = &self
+            .graph
+            .as_ref()
+            .expect("the completed graph was just stored")
+            .visual_counts;
+        let visual_selection = previous_visual_position.and_then(|(base, count, previous)| {
+            self.rows
+                .iter()
+                .enumerate()
+                .filter(|(index, _)| {
+                    visual_counts.get(*index) == Some(&count)
+                        && index
+                            .checked_add(count)
+                            .and_then(|base_index| self.rows.get(base_index))
+                            .is_some_and(|row| row.id == base)
+                })
+                .min_by_key(|(index, _)| index.abs_diff(previous))
+                .map(|(index, _)| index)
+        });
         self.selected = selected
             .and_then(|id| self.rows.iter().position(|row| row.id == id))
+            .or(visual_selection)
+            .or_else(|| {
+                previous_selection
+                    .filter(|_| !self.rows.is_empty())
+                    .map(|index| index.min(self.rows.len() - 1))
+            })
             .or_else(|| (!self.rows.is_empty()).then_some(0));
         self.compressed_segment = segment;
         if self.compressed_segment.is_some() {
@@ -3094,13 +3125,13 @@ impl App {
     }
 
     pub(crate) fn begin_time_travel_animation(&mut self) {
-        let viewport_row = if self.alignment == Alignment::Compressed {
-            self.selected_history_index()
-                .map(|selected| selected.saturating_sub(self.offset))
-        } else {
-            None
-        };
-        self.time_travel_animation = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+        let viewport_row = self
+            .selected_history_index()
+            .map(|selected| selected.saturating_sub(self.offset));
+        self.time_travel_animation = self
+            .selected
+            .and_then(|index| self.rows.get(index))
+            .map(|row| (row.id, viewport_row.unwrap_or_default()));
         if let (Some(selected), Some(viewport_row)) = (self.selected_history_index(), viewport_row) {
             self.offset = selected.saturating_sub(viewport_row);
         }
@@ -3108,25 +3139,23 @@ impl App {
     }
 
     pub(crate) fn finish_time_travel_animation(&mut self) {
-        let viewport_row = if self.alignment == Alignment::Compressed {
-            self.selected_history_index()
-                .map(|selected| selected.saturating_sub(self.offset))
-        } else {
-            None
-        };
-        if self.time_travel_animation.take().is_none() || self.alignment != Alignment::Compressed {
+        let Some((origin, viewport_row)) = self.time_travel_animation else {
             return;
+        };
+        self.select_commit(origin);
+        self.time_travel_animation = None;
+        if self.alignment == Alignment::Compressed {
+            self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
+            self.rebuild_compressed_history();
         }
-        self.compressed_anchor = self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id);
-        self.rebuild_compressed_history();
-        if let (Some(selected), Some(viewport_row)) = (self.selected_history_index(), viewport_row) {
+        if let Some(selected) = self.selected_history_index() {
             self.offset = selected.saturating_sub(viewport_row);
         }
         self.ensure_visible();
     }
 
     pub(crate) fn time_travel_animation_origin(&self) -> Option<ObjectId> {
-        self.time_travel_animation
+        self.time_travel_animation.map(|(origin, _)| origin)
     }
 
     pub(crate) fn select_commit_after_refresh(&mut self, id: ObjectId) {
@@ -4245,6 +4274,60 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_restores_a_rewritten_selection_by_its_visual_position() {
+        let mut app = App::new(3);
+        app.extend_commits(vec![
+            row_with_parents(6, &[5]),
+            row_with_parents(5, &[4]),
+            row_with_parents(4, &[3]),
+            row_with_parents(3, &[2]),
+            row_with_parents(2, &[1]),
+            row(1),
+        ]);
+        complete(&mut app);
+        app.select_commit(id(4));
+        assert_eq!(app.visual_count(app.selected.expect("commit 4 is selected")), Some(3));
+        assert_eq!(app.offset, 0, "the original selection is at the bottom of the viewport");
+
+        let rows = app.store_commits(
+            vec![
+                numbered_row(17, Some(16)),
+                numbered_row(16, Some(15)),
+                numbered_row(15, Some(14)),
+                numbered_row(14, Some(13)),
+                numbered_row(13, Some(2)),
+                numbered_row(2, Some(1)),
+                numbered_row(1, None),
+            ]
+            .into(),
+        );
+        app.state = State::Computing;
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(14)),
+            "the same base and displayed entry number identify the rewritten commit"
+        );
+        assert_eq!(
+            app.offset, 1,
+            "the restored selection stays at the bottom of the viewport"
+        );
+
+        let rows = app.store_commits(vec![numbered_row(9, Some(8)), numbered_row(8, None)].into());
+        app.state = State::Computing;
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+
+        assert_eq!(
+            app.selected.map(|index| app.rows[index].id),
+            Some(id(8)),
+            "a missing visual position clamps the previous row before falling back to the top"
+        );
+    }
+
     #[test]
     fn selected_head_follows_an_external_rewrite() {
         let mut app = App::new(10);
@@ -5360,6 +5443,49 @@ mod tests {
         );
     }
 
+    #[test]
+    fn time_travel_animation_returns_to_its_origin() {
+        let mut app = App::new(4);
+        app.extend_commits(
+            (1u16..=10)
+                .rev()
+                .map(|commit| numbered_row(commit, (commit > 1).then_some(commit - 1)))
+                .collect::<Vec<_>>(),
+        );
+        complete(&mut app);
+        app.select_commit(id(6));
+        assert_eq!((app.selected, app.offset), (Some(4), 1));
+
+        app.begin_time_travel_animation();
+        app.select_commit_for_time_travel(id(10));
+        app.finish_time_travel_animation();
+
+        assert_eq!(
+            (app.selected.map(|index| app.rows[index].id), app.offset),
+            (Some(id(6)), 1),
+            "the animated cursor returns to the requested entry and viewport row"
+        );
+
+        app.alignment = Alignment::None;
+        app.update(Action::ToggleAlign);
+        let viewport_row = app
+            .selected_history_index()
+            .expect("the origin is displayed in compressed history")
+            .saturating_sub(app.offset);
+        app.begin_time_travel_animation();
+        app.select_commit_for_time_travel(id(10));
+        app.finish_time_travel_animation();
+
+        assert_eq!(app.selected.map(|index| app.rows[index].id), Some(id(6)));
+        assert_eq!(
+            app.selected_history_index()
+                .expect("the origin remains displayed")
+                .saturating_sub(app.offset),
+            viewport_row,
+            "compressed history restores the origin to its former viewport row"
+        );
+    }
+
     #[test]
     fn time_travel_animation_temporarily_expands_compressed_history() {
         let mut app = App::new(4);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 63db320f523..14235adcb8a 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -3265,6 +3265,7 @@ fn event_loop(
                     match result {
                         Ok(edit::time_travel::Perform::Complete {
                             notice: Some(notice),
+                            selected,
                             ref_changes,
                             ..
                         }) => {
@@ -3277,20 +3278,18 @@ fn event_loop(
                                 &ref_changes,
                                 notice,
                             );
-                            if let Ok(head) = open_repository(&repository_path, repository_is_bare, false)
-                                .and_then(|repo| Ok(repo.head_id()?.detach()))
-                            {
-                                app.select_commit_after_refresh(head);
-                            }
+                            app.select_commit_after_refresh(selected);
                             invalidate_worktree_changes(&mut worktree_changes);
                             refresh_pending = true;
                         }
                         Ok(edit::time_travel::Perform::Complete {
                             notice: None,
+                            selected,
                             ref_changes,
                             ..
                         }) => {
                             if !ref_changes.is_empty() {
+                                app.select_commit_after_refresh(selected);
                                 leave_recorded_success(
                                     &mut app,
                                     &repository_path,
@@ -3299,6 +3298,8 @@ fn event_loop(
                                     &ref_changes,
                                     "time-travelled",
                                 );
+                                invalidate_worktree_changes(&mut worktree_changes);
+                                refresh_pending = true;
                             }
                         }
                         Ok(edit::time_travel::Perform::Conflict(conflict)) => {

From 008b910eb77bfdfb20a8440b39123a5568a86ae9 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 14:54:58 +0200
Subject: [PATCH 273/282] fix(gix-tix): make ref-tree paging move the cursor

Make unshifted Page and Ctrl-page input move the ref-tree selection, while Shift variants pan the viewport without moving it. Keep mouse and history navigation unchanged, and update the ref-tree hints and specification.
---
 gix-tix/spec.md         |  8 ++++----
 gix-tix/src/ref_tree.rs | 43 +++++++++++++++++++++++------------------
 2 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 854a28670f5..6d1feea95a3 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -362,10 +362,10 @@ without trading responsiveness for metadata that is not visible.
   toward roots, and Left/Right chooses a remembered child; `i/n` and an
   emphasized edge always show the choice.
 - `g` selects the top ref-tree node, and `Shift-G` selects the root of the current
-  component. Unshifted mouse and full- or half-page Ctrl/Page input pan the
-  viewport without moving the cursor. Shift-mouse moves to the nearest node;
-  shifted Ctrl/Page input moves the cursor by the corresponding viewport
-  distance and keeps it visible, matching history navigation.
+  component. Unshifted mouse pans the viewport, while Shift-mouse moves to the
+  nearest node. Unshifted full- or half-page Ctrl/Page input moves the cursor by
+  the corresponding viewport distance and keeps it visible; shifted Ctrl/Page
+  input pans the viewport without moving the cursor.
 - `e` opens node-level reference editing. `d` deletes every eligible local branch
   immediately. `e r` is offered only when selected remote-tracking references
   map uniquely through a named remote's fetch refspecs; it deletes every resolved
diff --git a/gix-tix/src/ref_tree.rs b/gix-tix/src/ref_tree.rs
index 823524c3cfc..c6c2a3e56b8 100644
--- a/gix-tix/src/ref_tree.rs
+++ b/gix-tix/src/ref_tree.rs
@@ -355,9 +355,9 @@ impl Tree {
                 _ => return Input::Handled,
             };
             if key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('U' | 'D' | 'B' | 'F')) {
-                self.page(direction, amount);
-            } else {
                 self.pan(direction, amount);
+            } else {
+                self.page(direction, amount);
             }
             return Input::Handled;
         }
@@ -503,7 +503,7 @@ impl Tree {
                 |id| format!("Space counts:{}", self.node_label(id)),
             );
             format!(
-                "ref-tree · {counts} · g top · G root · T tags:{tags} · Shift+directions topo · mouse/pages pan · Shift+mouse/pages cursor · <enter> pin · e edit · t/Esc history"
+                "ref-tree · {counts} · g top · G root · T tags:{tags} · Shift+directions topo · mouse pan · Shift+mouse cursor · pages cursor · Shift+pages pan · <enter> pin · e edit · t/Esc history"
             )
         };
         frame.render_widget(
@@ -779,9 +779,9 @@ impl Tree {
     fn page_or_pan(&mut self, direction: Direction, modifiers: KeyModifiers) {
         let amount = self.offset().page_height.max(1);
         if modifiers.contains(KeyModifiers::SHIFT) {
-            self.page(direction, amount);
-        } else {
             self.pan(direction, amount);
+        } else {
+            self.page(direction, amount);
         }
     }
 
@@ -2277,7 +2277,7 @@ mod tests {
     }
 
     #[test]
-    fn plain_pages_and_mouse_pan_while_shift_moves_the_cursor() {
+    fn plain_pages_move_the_cursor_while_shift_pages_and_plain_mouse_pan() {
         let (graph, refs, decorations) = fixture();
         let mut tree = Tree::default();
         tree.rebuild(&graph, &refs, &decorations);
@@ -2300,32 +2300,37 @@ mod tests {
             .height
             .saturating_sub(tree.offset.page_height);
         tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::NONE));
-        assert_eq!(tree.selected, Some(first), "plain PageDown leaves the cursor alone");
-        assert!(tree.offset.y > 0, "plain PageDown pans the viewport");
-
-        tree.offset.y = 0;
-        tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::SHIFT));
         let full_page = tree.selected.expect("PageDown retains a selection");
         let full_page_y = points[full_page].y;
-        assert!(full_page_y > first_y, "Shift-PageDown advances the ref-tree cursor");
+        assert!(full_page_y > first_y, "plain PageDown advances the ref-tree cursor");
         assert!(
             tree.ensure_visible,
-            "shifted page navigation keeps the new cursor visible"
+            "plain page navigation keeps the new cursor visible"
         );
 
         tree.selected = Some(first);
+        tree.offset.y = 0;
+        tree.handle_key(KeyEvent::new(KeyCode::PageDown, KeyModifiers::SHIFT));
+        assert_eq!(tree.selected, Some(first), "Shift-PageDown leaves the cursor alone");
+        assert!(tree.offset.y > 0, "Shift-PageDown pans the viewport");
+
+        tree.selected = Some(first);
+        tree.offset.y = 0;
         tree.handle_key(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::CONTROL));
-        assert_eq!(tree.selected, Some(first), "plain Ctrl-d leaves the cursor alone");
+        let half_page_y = points[tree.selected.expect("Ctrl-d retains a selection")].y;
+        assert!(
+            half_page_y > first_y && half_page_y <= full_page_y,
+            "plain half-page navigation advances no farther than a full page"
+        );
 
+        tree.selected = Some(first);
+        tree.offset.y = 0;
         tree.handle_key(KeyEvent::new(
             KeyCode::Char('d'),
             KeyModifiers::CONTROL | KeyModifiers::SHIFT,
         ));
-        let half_page_y = points[tree.selected.expect("Ctrl-d retains a selection")].y;
-        assert!(
-            half_page_y > first_y && half_page_y <= full_page_y,
-            "half-page navigation advances no farther than a full page"
-        );
+        assert_eq!(tree.selected, Some(first), "Shift-Ctrl-d leaves the cursor alone");
+        assert!(tree.offset.y > 0, "Shift-Ctrl-d pans by half a viewport");
 
         tree.selected = Some(first);
         tree.placed = tree.overview.as_ref().map(|overview| place_rail(overview, None));

From 878ce4ba57b3025e7fe7d244a632c6261acd4d03 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 18:48:57 +0200
Subject: [PATCH 274/282] fix(gix-tix): keep time-travel animation on its path

Animate only commits on the completed destination ancestry while still rewriting lazy sibling stacks. Defer time travel during lane computation so stale refresh results cannot displace the selection.
---
 gix-tix/spec.md                 | 12 ++---
 gix-tix/src/app.rs              | 18 +++++++-
 gix-tix/src/edit/time_travel.rs | 82 ++++++++++++++++++++++++++++++++-
 3 files changed, 104 insertions(+), 8 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 6d1feea95a3..5a27c30ada8 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1089,12 +1089,12 @@ space first; changes blocks adapt within the remaining history width.
   There is no hidden sequencer state or separate continue/abort command.
 - Interactive todo application runs on a scoped worker and shows its modal gauge
   after 300 ms. TUI time travel also runs on a scoped worker and follows completed
-  pending rebases with the history selection. The selection traverses each fixed
-  viewport from bottom to top; crossing its top jumps the viewport by one page and
-  places the selection at the bottom again. Compressed history temporarily uses
-  its canonical rows for these frames and is restored afterward. The first and
-  latest rows are drawn even for fast operations, with intermediate rows
-  coalesced to at most 60 fps. Command-line time travel does not animate.
+  pending rebases on the destination ancestry. The history selection traverses
+  each fixed viewport from bottom to top; crossing its top jumps the viewport
+  by one page and places the selection at the bottom again. Compressed history
+  temporarily uses its canonical rows for these frames and is restored afterward.
+  The first and latest rows are drawn even for fast operations, with intermediate
+  rows coalesced to at most 60 fps. Command-line time travel does not animate.
 - Displayed mutable refs follow their explicit locations in the edited todo;
   omission deletes them and newly named refs require nonexistence. Refs checked
   out by linked worktrees are displayed normally and may move, with their index
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index ce672a13924..abf351cc730 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2009,7 +2009,7 @@ impl App {
                 )];
             }
             Action::Attach if self.can_attach() => return vec![Effect::Attach],
-            Action::TimeTravel if self.time_travel_shortcut_visible() => {
+            Action::TimeTravel if self.can_time_travel() => {
                 return vec![Effect::TimeTravel(
                     self.rows[self.selected.expect("time-travel requires a selection")].id,
                 )];
@@ -3171,6 +3171,10 @@ impl App {
             && self.selected.and_then(|index| self.rows.get(index)).is_some()
     }
 
+    fn can_time_travel(&self) -> bool {
+        self.state == State::Complete && self.time_travel_shortcut_visible()
+    }
+
     fn last_selectable(&self) -> Option<usize> {
         (0..self.history_len())
             .rev()
@@ -4618,6 +4622,18 @@ mod tests {
         assert!(app.update(Action::TimeTravel).is_empty());
         complete(&mut app);
         assert_eq!(app.update(Action::TimeTravel), vec![Effect::TimeTravel(id(1))]);
+        app.deferred_history_state = Some(State::Complete);
+        app.state = State::Computing;
+        assert!(
+            app.time_travel_shortcut_visible(),
+            "the shortcut remains stable during deferred lane computation"
+        );
+        assert!(
+            app.update(Action::TimeTravel).is_empty(),
+            "time travel waits for the current lane generation"
+        );
+        app.deferred_history_state = None;
+        app.state = State::Complete;
         app.set_worktree_branch(Some((id(1), true)));
         app.set_worktree_head(Some(id(1)), false);
         assert!(app.can_attach());
diff --git a/gix-tix/src/edit/time_travel.rs b/gix-tix/src/edit/time_travel.rs
index a86928ffd85..257aa718a04 100644
--- a/gix-tix/src/edit/time_travel.rs
+++ b/gix-tix/src/edit/time_travel.rs
@@ -797,7 +797,9 @@ pub(crate) fn perform_reporting_rebased(
             |id| {
                 let original = original_ids.get(&id).copied().unwrap_or(id);
                 rebased.push((id, original));
-                report(original);
+                if graph.is_ancestor(id, selected) {
+                    report(original);
+                }
             },
         )?;
         let outcome = match outcome {
@@ -2443,6 +2445,84 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn time_travel_reports_only_the_completed_destination_path() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let repository_path = repository.git_dir().to_owned();
+        let root = repository.rev_parse_single("HEAD~2")?.detach();
+        let middle = repository.rev_parse_single("HEAD~1")?.detach();
+        let common = repository.head_id()?.detach();
+        drop(repository);
+
+        git(fixture.path(), &["checkout", "-q", "-b", "sibling"])?;
+        std::fs::write(fixture.path().join("sibling"), "sibling\n")?;
+        git(fixture.path(), &["add", "sibling"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "sibling"])?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let destination = repository.head_id()?.detach();
+        drop(repository);
+
+        git(fixture.path(), &["checkout", "-q", "main"])?;
+        std::fs::write(fixture.path().join("main"), "main\n")?;
+        git(fixture.path(), &["add", "main"])?;
+        git(fixture.path(), &["commit", "-q", "-m", "main"])?;
+        let repository = crate::test_repository::open(fixture.path())?;
+        let other_tip = repository.head_id()?.detach();
+        let graph = super::super::loaded_graph(&repository)?;
+        let mut replacement = repository.find_commit(middle)?.decode()?.into_owned()?;
+        replacement.message = "rewritten middle".into();
+        git(fixture.path(), &["checkout", "-q", "--detach", &root.to_string()])?;
+        let marked = super::super::rebase::perform(
+            &repository,
+            &graph,
+            super::super::rebase::Edit::Replace {
+                target: middle,
+                commit: replacement,
+            },
+            super::super::rebase::Signature::InvalidateExisting,
+            super::super::rebase::Tree::LeaveAsIsAndMark,
+        )?
+        .complete()?;
+        let pending_common = marked.map(common).context("the shared commit is retained")?;
+        let pending_destination = marked.map(destination).context("the destination is retained")?;
+        let pending_other_tip = marked.map(other_tip).context("the sibling tip is retained")?;
+        drop(repository);
+
+        let repository = crate::test_repository::open(fixture.path())?;
+        let graph = super::super::loaded_graph(&repository)?;
+        drop(repository);
+        let mut reported = Vec::new();
+        perform_reporting_rebased(
+            &repository_path,
+            false,
+            pending_destination,
+            &graph,
+            &[],
+            &[],
+            false,
+            |id| reported.push(id),
+        )?
+        .complete()?;
+
+        assert_eq!(
+            reported,
+            [pending_common, pending_destination],
+            "animation follows the completed path and omits lazy sibling rewrites"
+        );
+        let repository = crate::test_repository::open(fixture.path())?;
+        let rewritten_other_tip = repository.find_reference("refs/heads/main")?.id().detach();
+        assert_ne!(
+            rewritten_other_tip, pending_other_tip,
+            "the omitted sibling is still rewritten when its parent changes"
+        );
+        assert!(
+            super::super::rebase::is_pending(&repository.find_commit(rewritten_other_tip)?.decode()?.into_owned()?),
+            "the sibling remains lazy"
+        );
+        Ok(())
+    }
+
     #[test]
     fn time_travel_materializes_only_the_pending_path_to_the_destination() -> gix_testtools::Result {
         if !gix_testtools::signature::program_available("ssh-keygen") {

From 21f642d346495278876172014297e68214afcb12 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 21:06:13 +0200
Subject: [PATCH 275/282] fix(gix-tix): keep first travel inside visible
 history

Infer the default hidden base for relative travel targets and exclude its boundary ancestry from navigation. This makes --to first select the oldest displayed commit above the base.
---
 gix-tix/src/command/travel.rs | 41 ++++++++++++++++++++++++++++++++---
 1 file changed, 38 insertions(+), 3 deletions(-)

diff --git a/gix-tix/src/command/travel.rs b/gix-tix/src/command/travel.rs
index b6d7c4080c8..3b296c484b3 100644
--- a/gix-tix/src/command/travel.rs
+++ b/gix-tix/src/command/travel.rs
@@ -58,8 +58,10 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
     let (selected, resolved_graph) = match (&args.revision, args.to) {
         (Some(revision), None) => super::resolve_commit(&repository, revision, "time-travel destination")?,
         (None, Some(to)) => {
-            let graph = crate::edit::loaded_view_graph(&repository)?;
-            let selected = relative_destination(&repository, &graph, head_id, to)?;
+            let hidden = crate::history::available_hidden_revisions(&repository, &[], true)?.0;
+            let hidden_tips = crate::history::snapshot(&repository, &[], &hidden, false)?.hidden_tips;
+            let graph = crate::edit::loaded_view_graph_with_hidden(&repository, &[], &hidden)?;
+            let selected = relative_destination(&repository, &graph, &hidden_tips, head_id, to)?;
             (selected, Some(graph))
         }
         _ => anyhow::bail!("exactly one time-travel destination is required"),
@@ -131,10 +133,14 @@ pub(super) fn run(repository: gix::Repository, args: Args) -> Result<()> {
 fn relative_destination(
     repository: &gix::Repository,
     graph: &crate::history::HistoryGraph,
+    hidden_tips: &[gix::ObjectId],
     head: gix::ObjectId,
     to: To,
 ) -> Result<gix::ObjectId> {
-    let order = graph.stored_commit_ids().collect::<Vec<_>>();
+    let order = graph
+        .stored_commit_ids()
+        .filter(|id| !hidden_tips.iter().any(|hidden| graph.is_ancestor(*id, *hidden)))
+        .collect::<Vec<_>>();
     let stored = order.iter().copied().collect::<HashSet<_>>();
     if !stored.contains(&head) {
         anyhow::bail!("HEAD is not present in the default Tix view");
@@ -487,6 +493,35 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn first_stops_above_the_inferred_hidden_base() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;
+        let path = fixture.path();
+        git(path, &["config", "remote.origin.url", "."])?;
+        git(
+            path,
+            &["config", "remote.origin.fetch", "+refs/heads/*:refs/remotes/origin/*"],
+        )?;
+        git(path, &["update-ref", "refs/remotes/origin/main", "main"])?;
+        git(
+            path,
+            &["symbolic-ref", "refs/remotes/origin/HEAD", "refs/remotes/origin/main"],
+        )?;
+        git(path, &["checkout", "-q", "-b", "topic"])?;
+        git(path, &["commit", "-q", "--allow-empty", "-m", "first topic commit"])?;
+        let first = crate::test_repository::open(path)?.head_id()?.detach();
+        git(path, &["commit", "-q", "--allow-empty", "-m", "topic tip"])?;
+
+        run(crate::test_repository::open(path)?, relative_args(To::First))?;
+
+        assert_eq!(
+            crate::test_repository::open(path)?.head_id()?.detach(),
+            first,
+            "first selects the oldest commit displayed above the inferred base"
+        );
+        Ok(())
+    }
+
     #[test]
     fn relative_target_ambiguity_lists_every_candidate() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("rebase_edit.sh")?;

From cf43997df678139e7548c326badea7c3fe538c73 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Fri, 21 Aug 2026 22:01:34 +0200
Subject: [PATCH 276/282] fix(gix-tix): keep history paging on the cursor

Restore cursor movement for plain page and Ctrl-page navigation in the history view. Reserve the Shift variants for panning the viewport without changing the selection.
---
 gix-tix/spec.md    |  4 ++--
 gix-tix/src/lib.rs | 30 +++++++++++++++---------------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 5a27c30ada8..d10b6572360 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -408,8 +408,8 @@ without trading responsiveness for metadata that is not visible.
 | `j`/Down, `k`/Up | Move one selectable row or changed path. Shift follows the first parent or chosen child. |
 | Mouse/trackpad vertical scroll | Pan history by the coalesced scroll distance without moving its cursor; Shift moves the cursor instead. Mouse input continues to move paths when a changes block is focused. |
 | `h`/`l` | Pan history or the focused changes block horizontally. Shift chooses a remembered topological child. Shift-horizontal mouse input does the same. |
-| `Ctrl-u`/`Ctrl-d` | Pan half a page; Shift moves the cursor half a page. |
-| `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Pan a page; Shift moves the cursor a page. Both forms scroll an overflowing commit message when applicable. |
+| `Ctrl-u`/`Ctrl-d` | Move the cursor half a page; Shift pans the viewport half a page. |
+| `Ctrl-b`/`Ctrl-f`, `PageUp`/`PageDown` | Move the cursor a page; Shift pans the viewport a page. Both forms scroll an overflowing commit message when applicable. |
 | `g`/Home, `G`/End | Select the newest/top or oldest/bottom selectable item. |
 | `?` | Toggle the information key group. |
 | `t` | Toggle the rounded ref-tree overview. |
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 14235adcb8a..1d133d35734 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -6176,7 +6176,7 @@ fn app_action(key: KeyEvent, app: &App) -> Option<Action> {
         if let Some((cursor_action, distance, down)) = paging {
             let shifted =
                 key.modifiers.contains(KeyModifiers::SHIFT) || matches!(key.code, KeyCode::Char('U' | 'D' | 'B' | 'F'));
-            if shifted || app.changes_focus.is_some() || app.commit_paging_active() {
+            if !shifted || app.changes_focus.is_some() || app.commit_paging_active() {
                 return Some(cursor_action);
             }
             return Some(if down {
@@ -8011,7 +8011,7 @@ mod tests {
     }
 
     #[test]
-    fn shift_applies_topology_to_directions_and_cursor_movement_to_pages() {
+    fn shift_applies_topology_to_directions_and_viewport_movement_to_pages() {
         let key = |code| KeyEvent::new(code, KeyModifiers::NONE);
         let shifted = |code| KeyEvent::new(code, KeyModifiers::SHIFT);
         let mut app = App::new(8);
@@ -8054,24 +8054,24 @@ mod tests {
         let control_shift =
             |character| KeyEvent::new(KeyCode::Char(character), KeyModifiers::CONTROL | KeyModifiers::SHIFT);
         for (key, expected) in [
-            (key(KeyCode::PageUp), Action::PanUpBy(8)),
-            (key(KeyCode::PageDown), Action::PanDownBy(8)),
-            (control('u'), Action::PanUpBy(4)),
-            (control('d'), Action::PanDownBy(4)),
-            (control('b'), Action::PanUpBy(8)),
-            (control('f'), Action::PanDownBy(8)),
-            (shifted(KeyCode::PageUp), Action::PageUp),
-            (shifted(KeyCode::PageDown), Action::PageDown),
-            (control_shift('u'), Action::HalfPageUp),
-            (control_shift('d'), Action::HalfPageDown),
-            (control_shift('b'), Action::PageUp),
-            (control_shift('f'), Action::PageDown),
+            (key(KeyCode::PageUp), Action::PageUp),
+            (key(KeyCode::PageDown), Action::PageDown),
+            (control('u'), Action::HalfPageUp),
+            (control('d'), Action::HalfPageDown),
+            (control('b'), Action::PageUp),
+            (control('f'), Action::PageDown),
+            (shifted(KeyCode::PageUp), Action::PanUpBy(8)),
+            (shifted(KeyCode::PageDown), Action::PanDownBy(8)),
+            (control_shift('u'), Action::PanUpBy(4)),
+            (control_shift('d'), Action::PanDownBy(4)),
+            (control_shift('b'), Action::PanUpBy(8)),
+            (control_shift('f'), Action::PanDownBy(8)),
         ] {
             assert_eq!(app_action(key, &app), Some(expected));
         }
         assert_eq!(
             app_action(KeyEvent::new(KeyCode::Char('U'), KeyModifiers::CONTROL), &app),
-            Some(Action::HalfPageUp),
+            Some(Action::PanUpBy(4)),
             "uppercase Ctrl paging retains its Shift meaning instead of invoking redo"
         );
 

From ba42a0b0b0a1392419da5bc5c89e6f80de9623f5 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 06:20:38 +0200
Subject: [PATCH 277/282] feat(gix-tix): show progress during stack edits

Stack edits below HEAD now eagerly replay the checked-out path, so operations such as rewording can spend noticeable time cherry-picking and signing descendants.

Run every interactive stack rewrite through the existing delayed rebase-progress modal, and extend ordinary edit rebases to report commit, cherry-pick, and signature progress.
---
 gix-tix/spec.md            |   5 +-
 gix-tix/src/command.rs     |   2 +-
 gix-tix/src/edit/create.rs |  11 ++-
 gix-tix/src/edit/forget.rs |   9 +-
 gix-tix/src/edit/head.rs   |  45 +++++++---
 gix-tix/src/edit/rebase.rs | 171 ++++++++++++++++++++++++++++++-------
 gix-tix/src/edit/review.rs |  22 ++++-
 gix-tix/src/edit/reword.rs |   9 +-
 gix-tix/src/edit/split.rs  |   6 +-
 gix-tix/src/lib.rs         |  94 ++++++++++++--------
 10 files changed, 277 insertions(+), 97 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index d10b6572360..1cf51dc5ab7 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1087,8 +1087,9 @@ space first; changes blocks adapt within the remaining history width.
   requires only that `HEAD` names a commit and the index has no unresolved stages;
   the index tree, including additional staged changes, becomes the resolved tree.
   There is no hidden sequencer state or separate continue/abort command.
-- Interactive todo application runs on a scoped worker and shows its modal gauge
-  after 300 ms. TUI time travel also runs on a scoped worker and follows completed
+- Every interactive operation that rewrites the stack below `HEAD`, including
+  todo application, runs on a scoped worker and shows its modal gauge after
+  300 ms. TUI time travel also runs on a scoped worker and follows completed
   pending rebases on the destination ancestry. The history selection traverses
   each fixed viewport from bottom to top; crossing its top jumps the viewport
   by one page and places the selection at the bottom again. Compressed history
diff --git a/gix-tix/src/command.rs b/gix-tix/src/command.rs
index 4dca972de03..6363c2e4949 100644
--- a/gix-tix/src/command.rs
+++ b/gix-tix/src/command.rs
@@ -624,7 +624,7 @@ fn split(repository: gix::Repository, graph: &crate::history::HistoryGraph, args
     let mut repository = crate::open_repository(&repository_path, bare, false)
         .context("could not reopen repository after editing split")?;
     repository.object_cache_size(None);
-    let outcome = crate::edit::split::apply_reporting(repository, graph, prepared, &edited)?;
+    let outcome = crate::edit::split::apply_reporting(repository, graph, prepared, &edited, |_| {})?;
     let output_repository =
         crate::open_repository(&repository_path, bare, false).context("could not reopen repository after splitting")?;
     let selected = outcome.selected.context("splitting did not produce a selection")?;
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index 916e3b82549..b6b1890e122 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -291,7 +291,7 @@ pub(crate) fn apply_reporting(
     prepared: Prepared,
     edited: &[u8],
 ) -> Result<rebase::Outcome> {
-    apply_conflict_reporting(repo, graph, prepared, edited)?.complete()
+    apply_conflict_reporting(repo, graph, prepared, edited, |_| {})?.complete()
 }
 
 pub(crate) fn apply_conflict_reporting(
@@ -299,9 +299,10 @@ pub(crate) fn apply_conflict_reporting(
     graph: &crate::history::HistoryGraph,
     prepared: Prepared,
     edited: &[u8],
+    report: impl FnMut(rebase::Progress),
 ) -> Result<rebase::Perform> {
     let edit = commit_from_edit(&prepared, edited)?;
-    apply_commit_conflict(repo, graph, prepared, edit)
+    apply_commit_conflict(repo, graph, prepared, edit, report)
 }
 
 pub(crate) fn apply_message_reporting(
@@ -322,7 +323,7 @@ fn apply_commit(
     prepared: Prepared,
     edit: (gix::objs::Commit, crate::enrich::Headers),
 ) -> Result<rebase::Outcome> {
-    apply_commit_conflict(repo, graph, prepared, edit)?.complete()
+    apply_commit_conflict(repo, graph, prepared, edit, |_| {})?.complete()
 }
 
 fn apply_commit_conflict(
@@ -330,9 +331,10 @@ fn apply_commit_conflict(
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     (commit, enrichment): (gix::objs::Commit, crate::enrich::Headers),
+    report: impl FnMut(rebase::Progress),
 ) -> Result<rebase::Perform> {
     repo.objects.set_object_memory(std::mem::take(&mut prepared.objects));
-    let (performed, _) = rebase::perform_with_enrichment(
+    let (performed, _) = rebase::perform_with_enrichment_and_progress(
         &repo,
         graph,
         rebase::Edit::Insert {
@@ -343,6 +345,7 @@ fn apply_commit_conflict(
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
         &enrichment,
+        report,
     )?;
     Ok(performed)
 }
diff --git a/gix-tix/src/edit/forget.rs b/gix-tix/src/edit/forget.rs
index f5b8aec1a7d..9e914fb25b6 100644
--- a/gix-tix/src/edit/forget.rs
+++ b/gix-tix/src/edit/forget.rs
@@ -39,7 +39,7 @@ impl Conflict {
 #[cfg(test)]
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 pub(crate) fn perform(repo: gix::Repository, graph: &crate::history::HistoryGraph, id: ObjectId) -> Result<Outcome> {
-    perform_conflict(repo, graph, id)?.complete()
+    perform_conflict(repo, graph, id, |_| {})?.complete()
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
@@ -47,6 +47,7 @@ pub(crate) fn perform_conflict(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
     id: ObjectId,
+    report: impl FnMut(rebase::Progress),
 ) -> Result<Perform> {
     let commit = repo
         .find_commit(id)
@@ -69,21 +70,23 @@ pub(crate) fn perform_conflict(
         None
     };
     let result = if deletions.is_empty() {
-        rebase::perform(
+        rebase::perform_with_progress(
             &repo,
             graph,
             rebase::Edit::Remove { target: id },
             rebase::Signature::RedoIfNeeded,
             rebase::Tree::LeaveAsIsAndMark,
+            report,
         )
     } else {
-        rebase::perform_deleting_refs(
+        rebase::perform_deleting_refs_with_progress(
             &repo,
             graph,
             rebase::Edit::Remove { target: id },
             rebase::Signature::RedoIfNeeded,
             rebase::Tree::LeaveAsIsAndMark,
             deletions,
+            report,
         )
     }?;
     Ok(match result {
diff --git a/gix-tix/src/edit/head.rs b/gix-tix/src/edit/head.rs
index c8aa3784749..39c199e1987 100644
--- a/gix-tix/src/edit/head.rs
+++ b/gix-tix/src/edit/head.rs
@@ -18,7 +18,7 @@ pub fn perform(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
 ) -> Result<Option<ObjectId>> {
-    Ok(perform_inner(repo, graph, kind, selected_path, false, false)?.and_then(|outcome| outcome.selected))
+    Ok(perform_inner(repo, graph, kind, selected_path, false, false, |_| {})?.and_then(|outcome| outcome.selected))
 }
 
 pub(crate) fn perform_with_changes(
@@ -27,8 +27,9 @@ pub(crate) fn perform_with_changes(
     kind: Kind,
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
     resolve_pending: bool,
+    report: impl FnMut(rebase::Progress),
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, kind, selected_path, false, resolve_pending)
+    perform_inner(repo, graph, kind, selected_path, false, resolve_pending, report)
 }
 
 pub(crate) fn perform_reporting(
@@ -36,20 +37,20 @@ pub(crate) fn perform_reporting(
     graph: &crate::history::HistoryGraph,
     kind: Kind,
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, kind, None, false, false)
+    perform_inner(repo, graph, kind, None, false, false, |_| {})
 }
 
 #[tracing::instrument(skip_all)]
 #[cfg(test)]
 pub fn amend_index(repo: gix::Repository, graph: &crate::history::HistoryGraph) -> Result<Option<ObjectId>> {
-    Ok(perform_inner(repo, graph, Kind::Amend, None, true, true)?.and_then(|outcome| outcome.selected))
+    Ok(perform_inner(repo, graph, Kind::Amend, None, true, true, |_| {})?.and_then(|outcome| outcome.selected))
 }
 
 pub(crate) fn amend_index_reporting(
     repo: gix::Repository,
     graph: &crate::history::HistoryGraph,
 ) -> Result<Option<rebase::Outcome>> {
-    perform_inner(repo, graph, Kind::Amend, None, true, true)
+    perform_inner(repo, graph, Kind::Amend, None, true, true, |_| {})
 }
 
 fn perform_inner(
@@ -59,6 +60,7 @@ fn perform_inner(
     selected_path: Option<(&PathChange, Option<ObjectId>)>,
     index_only: bool,
     resolve_pending: bool,
+    mut report: impl FnMut(rebase::Progress),
 ) -> Result<Option<rebase::Outcome>> {
     let head = repo
         .head_id()
@@ -145,8 +147,14 @@ fn perform_inner(
             {
                 paths.push(source.clone());
             }
-            rebase::perform_resetting_index_paths_allowing_pending_checkout(
-                &repo, graph, edit, signature, tree_mode, paths,
+            rebase::perform_resetting_index_paths_allowing_pending_checkout_with_progress(
+                &repo,
+                graph,
+                edit,
+                signature,
+                tree_mode,
+                paths,
+                &mut report,
             )?
         }
         Some((path, _)) if kind == Kind::Amend => {
@@ -156,12 +164,25 @@ fn perform_inner(
             {
                 paths.push(source.clone());
             }
-            rebase::perform_resetting_index_paths(&repo, graph, edit, signature, tree_mode, paths)?
-        }
-        _ if kind == Kind::Amend && resolve_pending => {
-            rebase::perform_allowing_pending_checkout(&repo, graph, edit, signature, tree_mode)?
+            rebase::perform_resetting_index_paths_with_progress(
+                &repo,
+                graph,
+                edit,
+                signature,
+                tree_mode,
+                paths,
+                &mut report,
+            )?
         }
-        _ => rebase::perform(&repo, graph, edit, signature, tree_mode)?,
+        _ if kind == Kind::Amend && resolve_pending => rebase::perform_allowing_pending_checkout_with_progress(
+            &repo,
+            graph,
+            edit,
+            signature,
+            tree_mode,
+            &mut report,
+        )?,
+        _ => rebase::perform_with_progress(&repo, graph, edit, signature, tree_mode, &mut report)?,
     };
     Ok(Some(performed.complete()?))
 }
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index da3df8cbda7..5066579e217 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -812,11 +812,35 @@ pub(crate) fn perform(
         None,
         false,
         None,
-        |_| {},
+        |_, _| {},
     )
     .map(|(perform, _)| perform)
 }
 
+pub(crate) fn perform_with_progress(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    mut report: impl FnMut(Progress),
+) -> Result<Perform> {
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        false,
+        None,
+        |_, progress| report(progress),
+    )
+    .map(|(perform, _)| perform)
+}
+
+#[cfg(test)]
 pub(crate) fn perform_with_enrichment(
     repo: &gix::Repository,
     graph: &HistoryGraph,
@@ -835,16 +859,40 @@ pub(crate) fn perform_with_enrichment(
         None,
         false,
         Some(headers),
-        |_| {},
+        |_, _| {},
     )
 }
 
-pub(super) fn perform_allowing_pending_checkout(
+pub(crate) fn perform_with_enrichment_and_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
+    headers: &crate::enrich::Headers,
+    mut report: impl FnMut(Progress),
+) -> Result<(Perform, Option<crate::enrich::Enrichment>)> {
+    perform_inner(
+        repo,
+        graph,
+        edit,
+        signature,
+        tree_mode,
+        Vec::new(),
+        None,
+        false,
+        Some(headers),
+        |_, progress| report(progress),
+    )
+}
+
+pub(super) fn perform_allowing_pending_checkout_with_progress(
+    repo: &gix::Repository,
+    graph: &HistoryGraph,
+    edit: Edit,
+    signature: Signature,
+    tree_mode: Tree,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     perform_inner(
         repo,
@@ -856,7 +904,7 @@ pub(super) fn perform_allowing_pending_checkout(
         None,
         true,
         None,
-        |_| {},
+        |_, progress| report(progress),
     )
     .map(|(perform, _)| perform)
 }
@@ -867,7 +915,7 @@ pub(crate) fn perform_reporting_rebased(
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
-    report: impl FnMut(ObjectId),
+    mut report: impl FnMut(ObjectId),
 ) -> Result<Perform> {
     perform_inner(
         repo,
@@ -879,18 +927,23 @@ pub(crate) fn perform_reporting_rebased(
         None,
         false,
         None,
-        report,
+        |id, _| {
+            if let Some(id) = id {
+                report(id);
+            }
+        },
     )
     .map(|(perform, _)| perform)
 }
 
-pub(super) fn perform_resetting_index_paths(
+pub(super) fn perform_resetting_index_paths_with_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
     paths: Vec<BString>,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     perform_inner(
         repo,
@@ -902,18 +955,19 @@ pub(super) fn perform_resetting_index_paths(
         Some(paths),
         false,
         None,
-        |_| {},
+        |_, progress| report(progress),
     )
     .map(|(perform, _)| perform)
 }
 
-pub(super) fn perform_resetting_index_paths_allowing_pending_checkout(
+pub(super) fn perform_resetting_index_paths_allowing_pending_checkout_with_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
     paths: Vec<BString>,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     perform_inner(
         repo,
@@ -925,18 +979,19 @@ pub(super) fn perform_resetting_index_paths_allowing_pending_checkout(
         Some(paths),
         true,
         None,
-        |_| {},
+        |_, progress| report(progress),
     )
     .map(|(perform, _)| perform)
 }
 
-pub(super) fn perform_deleting_refs(
+pub(super) fn perform_deleting_refs_with_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     edit: Edit,
     signature: Signature,
     tree_mode: Tree,
     deletions: Vec<(gix::refs::FullName, Target)>,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     perform_inner(
         repo,
@@ -948,7 +1003,7 @@ pub(super) fn perform_deleting_refs(
         None,
         false,
         None,
-        |_| {},
+        |_, progress| report(progress),
     )
     .map(|(perform, _)| perform)
 }
@@ -967,7 +1022,7 @@ fn perform_inner(
     reset_index_paths: Option<Vec<BString>>,
     allow_pending_checkout: bool,
     enrichment_headers: Option<&crate::enrich::Headers>,
-    mut report: impl FnMut(ObjectId),
+    mut report: impl FnMut(Option<ObjectId>, Progress),
 ) -> Result<(Perform, Option<crate::enrich::Enrichment>)> {
     let mut repo = repo.clone();
     let repeat_checkout = match &edit {
@@ -1002,6 +1057,13 @@ fn perform_inner(
             .context("the edited commit is not in the loaded history")?,
         None => Vec::new(),
     };
+    let mut progress = Progress {
+        total: affected.len()
+            + usize::from(split_upper.is_some())
+            + usize::from((inserted || forked) && affected.is_empty()),
+        ..Progress::default()
+    };
+    report(None, progress);
     let checkout = if repo.workdir().is_some() {
         repo.head()?.id().map(gix::Id::detach)
     } else {
@@ -1054,7 +1116,7 @@ fn perform_inner(
     if inserted || forked {
         let mut commit = replacement.clone().context("an inserted commit is required")?;
         commit.parents = root.into_iter().collect();
-        let id = write_commit(
+        let (id, signing_time) = write_commit_timed(
             &repo,
             commit,
             None,
@@ -1062,6 +1124,12 @@ fn perform_inner(
             CommitState::Unmarked(signature),
             signing.clone(),
         )?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        progress.processed += 1;
+        report(None, progress);
         selected = Some(id);
         if inserted {
             if let Some(root) = root {
@@ -1079,6 +1147,8 @@ fn perform_inner(
             .copied();
         rewritten.insert(root, parent);
         selected = parent;
+        progress.processed += 1;
+        report(None, progress);
     }
 
     let mut pending = affected;
@@ -1111,6 +1181,8 @@ fn perform_inner(
             .filter_map(|parent| rewritten.get(parent).copied().unwrap_or(Some(*parent)))
             .collect();
         if Some(old_id) != root && old_parents == new_parents && !is_pending(&commit) {
+            progress.processed += 1;
+            report(None, progress);
             continue;
         }
         let recorded_parent = has_marker(&commit).then(|| marked_parent(&commit)).transpose()?;
@@ -1145,6 +1217,7 @@ fn perform_inner(
             commit_tree_mode = Tree::CherryPick;
             finalized_empty.insert(old_id);
         }
+        let cherry_pick_started = eager.then(Instant::now);
         let rewritten_tree = rewritten_tree(
             &repo,
             &commit,
@@ -1168,6 +1241,10 @@ fn perform_inner(
                 ours
             }
         };
+        if let Some(started) = cherry_pick_started.filter(|_| new_conflict.is_none()) {
+            progress.cherry_picked += 1;
+            progress.cherry_pick_time += started.elapsed();
+        }
         commit.parents = new_parents.into_iter().collect();
         let pending = commit_tree_mode == Tree::LeaveAsIsAndMark
             || (commit_tree_mode == Tree::LeaveAsIsAndMarkDescendants && Some(old_id) != root)
@@ -1188,8 +1265,14 @@ fn perform_inner(
         } else {
             CommitState::Unmarked(signature)
         };
-        let new_id = write_commit(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
-        report(old_id);
+        let (new_id, signing_time) =
+            write_commit_timed(&repo, commit, Some(old_id), &committer, state, signing.clone())?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        progress.processed += 1;
+        report(Some(old_id), progress);
         if new_id != old_id {
             note_rewrites.push((old_id, new_id));
         }
@@ -1200,7 +1283,7 @@ fn perform_inner(
         if Some(old_id) == root {
             if let Some(mut upper) = split_upper.take() {
                 upper.parents = [new_id].into_iter().collect();
-                let upper_id = write_commit(
+                let (upper_id, signing_time) = write_commit_timed(
                     &repo,
                     upper,
                     None,
@@ -1208,6 +1291,12 @@ fn perform_inner(
                     CommitState::Unmarked(Signature::RedoIfNeeded),
                     signing.clone(),
                 )?;
+                if let Some(elapsed) = signing_time {
+                    progress.signed += 1;
+                    progress.signing_time += elapsed;
+                }
+                progress.processed += 1;
+                report(None, progress);
                 rewritten.insert(old_id, Some(upper_id));
                 selected = Some(upper_id);
             } else {
@@ -1273,7 +1362,7 @@ fn perform_inner(
 }
 
 #[tracing::instrument(skip_all, fields(%review, %tip))]
-pub(super) fn finish_review(
+pub(super) fn finish_review_with_progress(
     repo: &gix::Repository,
     graph: &HistoryGraph,
     review: ObjectId,
@@ -1281,6 +1370,7 @@ pub(super) fn finish_review(
     review_ref: gix::refs::FullName,
     delete_refs: Vec<(gix::refs::FullName, Target)>,
     checkout: Option<(ObjectId, Option<gix::refs::FullName>)>,
+    mut report: impl FnMut(Progress),
 ) -> Result<Perform> {
     let mut repo = repo.clone();
     let signing = repo
@@ -1303,6 +1393,11 @@ pub(super) fn finish_review(
         .into_iter()
         .filter(|id| *id != tip && !review_set.contains(id))
         .collect();
+    let mut progress = Progress {
+        total: review_ids.len() + natural_ids.len(),
+        ..Progress::default()
+    };
+    report(progress);
     let checkout_path: HashSet<_> = if repo.workdir().is_some() {
         checkout
             .as_ref()
@@ -1357,7 +1452,7 @@ pub(super) fn finish_review(
                     && name.as_slice() != super::review::RETURN_TO
             });
         }
-        let new = write_commit(
+        let (new, signing_time) = write_commit_timed(
             &repo,
             commit,
             Some(*old),
@@ -1365,6 +1460,12 @@ pub(super) fn finish_review(
             CommitState::Unmarked(Signature::RedoIfNeeded),
             signing.clone(),
         )?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        progress.processed += 1;
+        report(progress);
         if new != *old {
             note_rewrites.push((*old, new));
         }
@@ -1423,6 +1524,7 @@ pub(super) fn finish_review(
         if finalize_empty {
             mode = Tree::CherryPick;
         }
+        let cherry_pick_started = eager.then(Instant::now);
         let mut new_conflict = None;
         commit.tree = match rewritten_tree(&repo, &commit, &original_parents, &new_parents, mode)? {
             TreeRewrite::Complete(tree) => tree,
@@ -1435,9 +1537,13 @@ pub(super) fn finish_review(
                 ours
             }
         };
+        if let Some(started) = cherry_pick_started.filter(|_| new_conflict.is_none()) {
+            progress.cherry_picked += 1;
+            progress.cherry_pick_time += started.elapsed();
+        }
         commit.parents = new_parents.into_iter().collect();
         let pending = !(eager || finalize_empty) || conflict.is_some() || new_conflict.is_some();
-        let new = write_commit(
+        let (new, signing_time) = write_commit_timed(
             &repo,
             commit,
             Some(old),
@@ -1451,6 +1557,12 @@ pub(super) fn finish_review(
             },
             signing.clone(),
         )?;
+        if let Some(elapsed) = signing_time {
+            progress.signed += 1;
+            progress.signing_time += elapsed;
+        }
+        progress.processed += 1;
+        report(progress);
         if new != old {
             note_rewrites.push((old, new));
         }
@@ -2690,17 +2802,6 @@ pub(crate) fn is_pending(commit: &gix::objs::Commit) -> bool {
             .any(|(name, value)| is_signature(name) && value.is_empty())
 }
 
-fn write_commit(
-    repo: &gix::Repository,
-    commit: gix::objs::Commit,
-    predecessor: Option<ObjectId>,
-    committer: &gix::actor::Signature,
-    state: CommitState,
-    signing: Option<gix::commit::sign::Options>,
-) -> Result<ObjectId> {
-    Ok(write_commit_timed(repo, commit, predecessor, committer, state, signing)?.0)
-}
-
 fn write_commit_timed(
     repo: &gix::Repository,
     mut commit: gix::objs::Commit,
@@ -3151,14 +3252,20 @@ mod tests {
         let mut commit = repo.find_commit(middle)?.decode()?.into_owned()?;
         commit.message = "rewritten middle".into();
 
-        let outcome = perform(
+        let mut progress = Vec::new();
+        let outcome = perform_with_progress(
             &repo,
             &graph,
             Edit::Replace { target: middle, commit },
             Signature::RedoIfNeeded,
             Tree::LeaveAsIs,
+            |update| progress.push(update),
         )?
         .complete()?;
+        let progress = progress.last().context("stack-edit progress is reported")?;
+        assert_eq!(progress.total, 2, "the edited commit and its descendant are counted");
+        assert_eq!(progress.processed, 2, "the completed edit reports every commit");
+        assert_eq!(progress.cherry_picked, 1, "only the checked-out descendant is replayed");
         let new_middle = outcome.selected.expect("replacement selects the rewritten commit");
         let new_tip = repo.head_id()?.detach();
         assert_ne!(new_tip, old_tip, "the descendant is rewritten");
diff --git a/gix-tix/src/edit/review.rs b/gix-tix/src/edit/review.rs
index e3ce28840b3..5d0ff5bae53 100644
--- a/gix-tix/src/edit/review.rs
+++ b/gix-tix/src/edit/review.rs
@@ -211,11 +211,22 @@ pub(crate) fn start(
 }
 
 #[tracing::instrument(skip_all, fields(%review))]
+#[cfg(test)]
 pub(crate) fn finish(
     repo: gix::Repository,
     graph: &history::HistoryGraph,
     review: ObjectId,
     fallback: Option<ObjectId>,
+) -> Result<Finish> {
+    finish_with_progress(repo, graph, review, fallback, |_| {})
+}
+
+pub(crate) fn finish_with_progress(
+    repo: gix::Repository,
+    graph: &history::HistoryGraph,
+    review: ObjectId,
+    fallback: Option<ObjectId>,
+    report: impl FnMut(super::rebase::Progress),
 ) -> Result<Finish> {
     let workdir = repo
         .workdir()
@@ -281,7 +292,16 @@ pub(crate) fn finish(
             anyhow::bail!("{label} has a pending rebase");
         }
     }
-    match super::rebase::finish_review(&repo, graph, review, tip, review_ref, delete_refs, checkout)? {
+    match super::rebase::finish_review_with_progress(
+        &repo,
+        graph,
+        review,
+        tip,
+        review_ref,
+        delete_refs,
+        checkout,
+        report,
+    )? {
         super::rebase::Perform::Complete(outcome) => {
             let finished = outcome
                 .map(review)
diff --git a/gix-tix/src/edit/reword.rs b/gix-tix/src/edit/reword.rs
index 9fbf12bd41a..46dc47667bd 100644
--- a/gix-tix/src/edit/reword.rs
+++ b/gix-tix/src/edit/reword.rs
@@ -144,7 +144,7 @@ pub(crate) fn apply(
     old_id: gix::ObjectId,
     edited: &[u8],
 ) -> Result<Outcome> {
-    apply_conflict_reporting(repo, graph, old_id, edited)?.complete()
+    apply_conflict_reporting(repo, graph, old_id, edited, |_| {})?.complete()
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %old_id))]
@@ -153,6 +153,7 @@ pub(crate) fn apply_conflict_reporting(
     graph: &crate::history::HistoryGraph,
     old_id: gix::ObjectId,
     edited: &[u8],
+    mut report: impl FnMut(rebase::Progress),
 ) -> Result<Perform> {
     let edit = parse(edited)?;
     if edit.message.is_empty() {
@@ -173,7 +174,7 @@ pub(crate) fn apply_conflict_reporting(
         commit.committer = actor(edit.committer, edit.committer_time, "committer")?;
         commit.message = edit.message;
         let (performed, enrichment) =
-            apply_commit_conflict_with_enrichment(&repo, graph, old_id, commit, &edit.enrichment)?;
+            apply_commit_conflict_with_enrichment(&repo, graph, old_id, commit, &edit.enrichment, &mut report)?;
         let outcome = match performed {
             rebase::Perform::Complete(outcome) => outcome,
             rebase::Perform::Conflict(conflict) => return Ok(Perform::Conflict(conflict)),
@@ -282,14 +283,16 @@ fn apply_commit_conflict_with_enrichment(
     old_id: gix::ObjectId,
     commit: gix::objs::Commit,
     headers: &crate::enrich::Headers,
+    report: impl FnMut(rebase::Progress),
 ) -> Result<(rebase::Perform, Option<crate::enrich::Enrichment>)> {
-    rebase::perform_with_enrichment(
+    rebase::perform_with_enrichment_and_progress(
         repo,
         graph,
         rebase::Edit::Replace { target: old_id, commit },
         rebase::Signature::RedoIfNeeded,
         rebase::Tree::LeaveAsIsAndMark,
         headers,
+        report,
     )
 }
 
diff --git a/gix-tix/src/edit/split.rs b/gix-tix/src/edit/split.rs
index 81701ac22e3..4d537e3c33d 100644
--- a/gix-tix/src/edit/split.rs
+++ b/gix-tix/src/edit/split.rs
@@ -74,7 +74,7 @@ pub(crate) fn apply(
     prepared: Prepared,
     edited: &[u8],
 ) -> Result<ObjectId> {
-    apply_reporting(repo, graph, prepared, edited)?
+    apply_reporting(repo, graph, prepared, edited, |_| {})?
         .selected
         .context("splitting HEAD did not produce a selection")
 }
@@ -84,6 +84,7 @@ pub(crate) fn apply_reporting(
     graph: &crate::history::HistoryGraph,
     mut prepared: Prepared,
     edited: &[u8],
+    report: impl FnMut(rebase::Progress),
 ) -> Result<rebase::Outcome> {
     let repository_path = repo.git_dir().to_owned();
     let bare = repo.is_bare();
@@ -91,7 +92,7 @@ pub(crate) fn apply_reporting(
         .set_object_memory(std::mem::take(&mut prepared.create.objects));
     let (mut upper, enrichment) = create::commit_from_edit(&prepared.create, edited)?;
     upper.tree = prepared.tree;
-    let mut outcome = rebase::perform(
+    let mut outcome = rebase::perform_with_progress(
         &repo,
         graph,
         rebase::Edit::Split {
@@ -101,6 +102,7 @@ pub(crate) fn apply_reporting(
         },
         rebase::Signature::InvalidateExisting,
         rebase::Tree::LeaveAsIsAndMark,
+        report,
     )?
     .complete()?;
     let id = outcome.selected.context("splitting HEAD did not produce a selection")?;
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 1d133d35734..a73333d9dd4 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -2665,23 +2665,27 @@ fn event_loop(
                         _ => None,
                     }
                     .transpose();
+                    let resolving_conflict = pending_conflict_resolution.is_some();
                     let result = history_graph
                         .as_ref()
                         .context("editing HEAD requires a completed history graph")
                         .and_then(|graph| {
                             path.and_then(|path| {
-                                let repository = open_repository(&repository_path, repository_is_bare, false)
-                                    .context("could not open repository for HEAD edit")?;
-                                if kind == edit::head::Kind::Amend && pending_conflict_resolution.is_some() {
-                                    stage_resolved_conflict_paths(&repository)?;
-                                }
-                                edit::head::perform_with_changes(
-                                    repository,
-                                    graph,
-                                    kind,
-                                    path.as_ref().map(|(path, parent)| (path, *parent)),
-                                    pending_conflict_resolution.is_some(),
-                                )
+                                run_with_todo_progress(terminal, |report| {
+                                    let repository = open_repository(&repository_path, repository_is_bare, false)
+                                        .context("could not open repository for HEAD edit")?;
+                                    if kind == edit::head::Kind::Amend && resolving_conflict {
+                                        stage_resolved_conflict_paths(&repository)?;
+                                    }
+                                    edit::head::perform_with_changes(
+                                        repository,
+                                        graph,
+                                        kind,
+                                        path.as_ref().map(|(path, parent)| (path, *parent)),
+                                        resolving_conflict,
+                                        report,
+                                    )
+                                })
                             })
                         });
                     match result {
@@ -2763,7 +2767,7 @@ fn event_loop(
                                 clear_undo_history(&repository_path, repository_is_bare)
                                     .context("could not clear undo history before cancelling review")?;
                             }
-                            forget_commit(&repository_path, repository_is_bare, graph, id)
+                            forget_commit(terminal, &repository_path, repository_is_bare, graph, id)
                         });
                     match result {
                         Ok(edit::forget::Perform::Complete(outcome)) => {
@@ -3140,10 +3144,12 @@ fn event_loop(
                         .as_ref()
                         .context("finishing review requires a completed history graph")
                         .and_then(|graph| {
-                            let mut repo = open_repository(&repository_path, repository_is_bare, false)
-                                .context("could not open repository to finish review")?;
-                            repo.object_cache_size(None);
-                            edit::review::finish(repo, graph, id, return_to)
+                            run_with_todo_progress(terminal, |report| {
+                                let mut repo = open_repository(&repository_path, repository_is_bare, false)
+                                    .context("could not open repository to finish review")?;
+                                repo.object_cache_size(None);
+                                edit::review::finish_with_progress(repo, graph, id, return_to, report)
+                            })
                         });
                     match result {
                         Ok(edit::review::Finish::Complete(finished)) => {
@@ -4888,11 +4894,14 @@ fn reword_commit(
         return Ok(None);
     };
 
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
-    repository.object_cache_size(None);
-    let (graph, id) = edit::reword::relocate_after_editor(&repository, revisions, hidden_revisions, change_id)?;
-    edit::reword::apply_conflict_reporting(repository, &graph, id, &edited).map(Some)
+    run_with_todo_progress(terminal, move |report| {
+        let mut repository = open_repository(repository_path, bare, false)
+            .context("could not reopen repository after editing commit")?;
+        repository.object_cache_size(None);
+        let (graph, id) = edit::reword::relocate_after_editor(&repository, revisions, hidden_revisions, change_id)?;
+        edit::reword::apply_conflict_reporting(repository, &graph, id, &edited, report)
+    })
+    .map(Some)
 }
 
 pub(crate) fn load_rebase_todo_commits(
@@ -5309,15 +5318,20 @@ fn create_commit(
     else {
         return Ok(None);
     };
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not reopen repository after editing commit")?;
-    repository.object_cache_size(None);
     let outcome = match mode {
-        CreateMode::Insert | CreateMode::InsertEmpty => {
-            edit::create::apply_conflict_reporting(repository, graph, prepared, &edited)
+        CreateMode::Insert | CreateMode::InsertEmpty => run_with_todo_progress(terminal, move |report| {
+            let mut repository = open_repository(repository_path, bare, false)
+                .context("could not reopen repository after editing commit")?;
+            repository.object_cache_size(None);
+            edit::create::apply_conflict_reporting(repository, graph, prepared, &edited, report)
+        }),
+        CreateMode::Fork => {
+            let mut repository = open_repository(repository_path, bare, false)
+                .context("could not reopen repository after editing commit")?;
+            repository.object_cache_size(None);
+            edit::create::apply_fork_reporting(repository, graph, prepared, &edited)
+                .map(edit::rebase::Perform::Complete)
         }
-        CreateMode::Fork => edit::create::apply_fork_reporting(repository, graph, prepared, &edited)
-            .map(edit::rebase::Perform::Complete),
     }?;
     Ok(Some(outcome))
 }
@@ -5344,23 +5358,29 @@ fn split_commit(
     else {
         return Ok(None);
     };
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not reopen repository after editing split")?;
-    repository.object_cache_size(None);
-    edit::split::apply_reporting(repository, graph, prepared, &edited).map(Some)
+    run_with_todo_progress(terminal, move |report| {
+        let mut repository =
+            open_repository(repository_path, bare, false).context("could not reopen repository after editing split")?;
+        repository.object_cache_size(None);
+        edit::split::apply_reporting(repository, graph, prepared, &edited, report)
+    })
+    .map(Some)
 }
 
 #[tracing::instrument(skip_all, fields(commit_id = %id))]
 fn forget_commit(
+    terminal: &mut ratatui::DefaultTerminal,
     repository_path: &Path,
     bare: bool,
     graph: &HistoryGraph,
     id: gix::ObjectId,
 ) -> Result<edit::forget::Perform> {
-    let mut repository =
-        open_repository(repository_path, bare, false).context("could not open repository before forgetting commit")?;
-    repository.object_cache_size(None);
-    edit::forget::perform_conflict(repository, graph, id)
+    run_with_todo_progress(terminal, move |report| {
+        let mut repository = open_repository(repository_path, bare, false)
+            .context("could not open repository before forgetting commit")?;
+        repository.object_cache_size(None);
+        edit::forget::perform_conflict(repository, graph, id, report)
+    })
 }
 
 fn run_external_diff(

From df8f8d7ae73c3038196d40c72204605730fa2468 Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 06:33:57 +0200
Subject: [PATCH 278/282] change(gix-tix)!: merge commit shortcuts into actions

Replace the separate commit prefix with a two-line actions menu. Keep general action keys stable and move new-empty and spill to a n and a l.
---
 gix-tix/spec.md    |  57 ++++++------
 gix-tix/src/app.rs |  68 +++++---------
 gix-tix/src/lib.rs | 122 ++++++++++---------------
 gix-tix/src/ui.rs  | 221 ++++++++++++++++++++-------------------------
 4 files changed, 197 insertions(+), 271 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 1cf51dc5ab7..86dfe845d38 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -62,7 +62,7 @@ without trading responsiveness for metadata that is not visible.
 - `tix new [--index | --worktree | --worktree-untracked] [--allow-empty] [--todo]
   [--author "Name <email>"] [-m MESSAGE ... | -f FILE]` creates a child of `HEAD`, or a root commit for
   unborn `HEAD`, with the same signing, editor, enrichment, lazy-rebase, and
-  worktree-safety rules as `c w`. By default a changed index wins and tracked
+  worktree-safety rules as `a w`. By default a changed index wins and tracked
   worktree changes are used only when the index is unchanged. `--index` uses
   only the index delta; `--worktree` applies only unstaged tracked-worktree
   changes to the `HEAD` tree and omits staged-only changes. `--worktree-untracked`
@@ -465,8 +465,9 @@ The display group remains open for consecutive display changes and closes on
 navigation or another recognized command. The `?` group similarly remains open
 for signature verification, alignment, message, and changes actions. The
 footer keeps every prefix compact. Opening one reverses its label and shows its available
-items in a reversed, single-row popout immediately above and connected to that
-label; the `?` popout also contains its pane-switching and navigation hints through
+items in a reversed popout immediately above and connected to that label. The
+actions popout has commit operations on its first row and general actions on its
+second; other groups use one row. The `?` popout also contains its pane-switching and navigation hints through
 `<enter> diff`. The popout has horizontal padding, shifts left or clips at the
 terminal edge without wrapping, and is omitted when its label, the row above the
 footer, or space needed to preserve a protected message is not visible. It does
@@ -475,7 +476,7 @@ but message and changes panes, their status lines, and transient notices shift
 upward to reserve its line and are never occluded. Closing behavior and shortcut
 availability are unchanged, and direct status actions and quit remain in the
 footer. The history status starts with the history position, then the
-`v`, `c`, and `a` prefixes when they are addressable. Remaining history-level
+`v` and `a` prefixes when they are addressable. Remaining history-level
 actions end at the information prefix while it is closed. An available direct
 time-travel action follows the shortcut groups, and duplicate cycling follows it when
 the selected commit has duplicates, and copy follows these actions; the reference toggle immediately precedes
@@ -535,7 +536,7 @@ The Enter key is written as `<enter>` throughout.
   style. It has no `📌`, is never selected as a return destination, and does not
   offer `unpin`; its branch keeps normal tracking-relation behavior.
 - The edit menu offers `pin` on an unpinned row and `unpin` on a pinned row,
-  both on `c i`. Pin creates or reuses a direct current-worktree pin for the
+  both on `a i`. Pin creates or reuses a direct current-worktree pin for the
   selected commit. Unpin atomically removes every non-HEAD pin for that commit;
   both operations retain that row's selection.
 - `tix pin <REVSPEC>...` resolves every argument before writing and deduplicates
@@ -611,7 +612,7 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Tree and worktree changes
 
-- Changes start enabled as `Tree + Worktree`. `c` cycles `Tree + Worktree` →
+- Changes start enabled as `Tree + Worktree`. `? e` cycles `Tree + Worktree` →
   `Tree` → hidden. Bare repositories omit the worktree mode.
 - Each block has a top border carrying its compact summary. Tree summaries show
   the selected short hash; worktree summaries distinguish staged and unstaged
@@ -716,12 +717,12 @@ space first; changes blocks adapt within the remaining history width.
 
 ### New commits
 
-- `c w` creates a child of the selected commit from tracked changes, or a root
+- `a w` creates a child of the selected commit from tracked changes, or a root
   commit for an unborn `HEAD`. A changed index wins; otherwise, tracked worktree
   changes are used. Untracked files never enter an implicit new commit and remain
   untracked. It is available only with a live worktree, after history completion,
   and when the selected parent has no known merge descendant.
-- `c m` creates an explicit empty commit which reuses the selected parent's tree,
+- `a n` creates an explicit empty commit which reuses the selected parent's tree,
   or the empty tree for an unborn history. Existing index and worktree state is
   preserved exactly. Both forms reject unresolved index conflicts.
 - A current worktree-changes cache controls which actions are advertised without
@@ -752,7 +753,7 @@ space first; changes blocks adapt within the remaining history width.
 
 - `a f` creates an independent child of any selected commit, including a hidden
   boundary or merge commit. It requires completed history and a live,
-  conflict-free worktree, but unlike `c w` it is not restricted by descendants
+  conflict-free worktree, but unlike `a w` it is not restricted by descendants
   because it rewrites none of them. It is unavailable for unborn history.
 - Fork preparation reuses the new-commit editor, candidate-tree, identity,
   enrichment, and signing rules. Empty-delta children are allowed so historical
@@ -766,8 +767,8 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Amend, spill, and split
 
-- `c e` amends the current worktree's `@` commit with the changed index, or
-  worktree changes when the index already matches `HEAD`. `c s` spills that
+- `a e` amends the current worktree's `@` commit with the changed index, or
+  worktree changes when the index already matches `HEAD`. `a l` spills that
   commit's tree delta into the worktree by replacing its tree with its first
   parent's tree, or the empty tree for a root commit. Clean operations are
   unavailable and report a no-op through `tix amend|spill`.
@@ -784,17 +785,17 @@ space first; changes blocks adapt within the remaining history width.
   IDs use the same seven-character display as other command results. Ref
   creations, deletions, unchanged refs, and unreferenced replayed commits add no
   mapping line.
-- With a path selected in the focused tree-changes block, the main `c` prefix
-  offers `spill` and `c s` spills only that path against the displayed parent.
+- With a path selected in the focused tree-changes block, the main `a` prefix
+  offers `spill` and `a l` spills only that path against the displayed parent.
   The CLI intentionally supports only whole-commit spilling.
-- With a path selected in the focused worktree-changes block, the main `c`
-  prefix offers `amend` and `c e` amends only that path. A staged row uses its
+- With a path selected in the focused worktree-changes block, the main `a`
+  prefix offers `amend` and `a e` amends only that path. A staged row uses its
   index version; an unstaged row uses its filtered worktree version. If both
   rows exist for one path, the selected row determines the version. Review
   commits accept only staged rows, and unresolved indexes cannot be amended.
   Unrelated staged entries retain their index state. The CLI intentionally
   supports only whole-commit amending.
-- `c p` is offered at `@` only when both staged and unstaged changes exist. It
+- `a p` is offered at `@` only when both staged and unstaged changes exist. It
   amends the unstaged changes into the source commit, then creates a new upper
   commit from the staged delta using the standard Markdown editor buffer. Both
   deltas are three-way applied in memory before the editor opens, so overlapping
@@ -1119,11 +1120,11 @@ space first; changes blocks adapt within the remaining history width.
 
 ### Commit and action shortcuts
 
-- `c` toggles the commit shortcut group. `c o` rewords, `c w` creates a rebased
-  child, `c m` creates an empty child, `c e` amends `@`, `c s` spills `@`, `c p`
-  splits staged from unstaged changes, and `c d d` confirms forgetting a top
-  commit when each action is available.
-- `a` toggles the actions shortcut group. `a b` rebases an eligible hidden base,
+- `a` toggles a two-line shortcut group with commit operations above general
+  actions. `a o` rewords, `a w` creates a rebased child, `a n` creates an empty
+  child, `a e` amends `@`, `a l` spills `@`, `a p` splits staged from unstaged
+  changes, and `a d d` confirms forgetting a top commit when each action is
+  available. `a b` rebases an eligible hidden base,
   `a u` rebases it onto the newer hidden branch tip when available, `a r` starts
   or finishes a review, `a s` squashes the selected commit, `a z` stashes or
   restores changes at `@`, `a y` copy-inserts
@@ -1159,15 +1160,15 @@ space first; changes blocks adapt within the remaining history width.
   `<enter>` moves the complete inclusive base-through-`HEAD` stack as a unit above the selected
   target, and Escape cancels. The stack follows the same eligibility, rewrite,
   no-op, metadata, checkout, and conflict rules as move-insert.
-- `@` invokes time travel directly, outside both groups. Invoking it leaves an
-  already expanded commit group open.
-- Commit and action shortcuts keep their respective group open. Navigation or
+- `@` invokes time travel directly, outside the group. Invoking it leaves an
+  already expanded actions group open.
+- Commit and action shortcuts keep the actions group open. Navigation or
   another recognized command closes it, matching the `v` display shortcut group.
   Plain `r` does not mutate the repository, and plain `t` has no action.
-- The footer underlines `c` in `commit` and `a` in `actions`; an expanded group
-  contains only the operations available for the current selection. An empty
-  group says `no actions`.
-- The top-level `v`, `c`, `a`, `n`, and `?` keys are reserved for their groups.
+- The footer underlines `a` in `actions`; its expanded commit and action lines
+  contain only the operations available for the current selection. An empty
+  line says `no actions`.
+- The top-level `v`, `a`, `n`, and `?` keys are reserved for their groups.
   Pressing one while another group is open switches directly to that group;
   `? e` cycles the changes panes.
 - While the `v` group is open, `d`, `i`, `s`, `e`, `m`, `t`, `r`, and `h` control
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index abf351cc730..99750135889 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -367,7 +367,6 @@ pub(crate) enum Action {
     ToggleHidden,
     ToggleHistoryDisplay,
     ToggleRefTree,
-    ToggleCommitGroup,
     ToggleActions,
     ToggleEnrich,
     ToggleTodo,
@@ -573,7 +572,6 @@ pub(crate) struct App {
     undo_position: Option<UndoPosition>,
     pub(crate) unseen_filesystem_redraw: bool,
     pub(crate) history_display_expanded: bool,
-    pub(crate) commit_expanded: bool,
     pub(crate) actions_expanded: bool,
     pub(crate) enrich_expanded: bool,
     pub(crate) information_expanded: bool,
@@ -683,7 +681,6 @@ impl App {
             undo_position: None,
             unseen_filesystem_redraw: false,
             history_display_expanded: false,
-            commit_expanded: false,
             actions_expanded: false,
             enrich_expanded: false,
             information_expanded: false,
@@ -1414,7 +1411,6 @@ impl App {
                 self.selected = None;
                 self.compressed_segment = Some(id);
                 self.pending_initial_selection = None;
-                self.commit_expanded = false;
                 self.actions_expanded = false;
                 self.enrich_expanded = false;
                 if changed {
@@ -1524,7 +1520,7 @@ impl App {
         }
         if !matches!(
             &action,
-            Action::ToggleCommitGroup
+            Action::ToggleActions
                 | Action::Reword
                 | Action::NewCommit
                 | Action::NewEmptyCommit
@@ -1534,12 +1530,6 @@ impl App {
                 | Action::Forget
                 | Action::TimeTravel
                 | Action::TogglePin
-        ) {
-            self.commit_expanded = false;
-        }
-        if !matches!(
-            &action,
-            Action::ToggleActions
                 | Action::Rebase
                 | Action::RebaseUpdate
                 | Action::Squash
@@ -1691,7 +1681,6 @@ impl App {
             Action::ToggleTrailers => self.show_trailers = !self.show_trailers,
             Action::ToggleMailmap => self.use_mailmap = !self.use_mailmap,
             Action::ToggleHistoryDisplay => self.history_display_expanded = !self.history_display_expanded,
-            Action::ToggleCommitGroup if !self.selected_is_segment() => self.commit_expanded = !self.commit_expanded,
             Action::ToggleActions if !self.selected_is_segment() => self.actions_expanded = !self.actions_expanded,
             Action::ToggleEnrich if !self.selected_is_segment() => self.enrich_expanded = !self.enrich_expanded,
             Action::ToggleInformation => self.information_expanded = !self.information_expanded,
@@ -5859,10 +5848,10 @@ mod tests {
         assert!(app.selected_is_segment(), "navigation stops on the upper summary");
         assert_eq!(app.selected_history_index(), Some(1));
         app.set_worktree_head_unborn(true);
-        for action in [Action::ToggleCommitGroup, Action::ToggleActions, Action::ToggleEnrich] {
+        for action in [Action::ToggleActions, Action::ToggleEnrich] {
             app.update(action);
         }
-        assert!(!app.commit_expanded && !app.actions_expanded && !app.enrich_expanded);
+        assert!(!app.actions_expanded && !app.enrich_expanded);
         assert!(
             app.update(Action::NewEmptyCommit).is_empty(),
             "a synthetic selection is not mistaken for an unborn HEAD"
@@ -6408,38 +6397,15 @@ mod tests {
     }
 
     #[test]
-    fn commit_and_actions_groups_stay_open_only_for_their_actions() {
+    fn actions_group_stays_open_only_for_its_actions() {
         let mut app = App::new(1);
 
-        app.update(Action::ToggleCommitGroup);
-        assert!(app.commit_expanded);
+        app.update(Action::ToggleActions);
+        assert!(app.actions_expanded);
         app.update(Action::Reword);
         app.update(Action::NewCommit);
         app.update(Action::Forget);
         app.update(Action::TimeTravel);
-        assert!(app.commit_expanded, "grouped commit commands keep the group open");
-
-        app.update(Action::Rebase);
-        assert!(!app.commit_expanded, "rebase now belongs to the actions group");
-
-        app.update(Action::ToggleCommitGroup);
-        app.update(Action::MoveDown);
-        assert!(!app.commit_expanded, "navigation collapses the group");
-
-        app.update(Action::ToggleCommitGroup);
-        app.update(Action::ToggleHistoryDisplay);
-        assert!(!app.commit_expanded, "opening the view group closes the commit group");
-        assert!(app.history_display_expanded);
-
-        app.update(Action::ToggleCommitGroup);
-        assert!(app.commit_expanded);
-        assert!(
-            !app.history_display_expanded,
-            "opening the commit group closes the view group"
-        );
-        app.update(Action::ToggleActions);
-        assert!(!app.commit_expanded, "opening actions closes commit");
-        assert!(app.actions_expanded);
         app.update(Action::Rebase);
         app.update(Action::RebaseUpdate);
         app.update(Action::Review);
@@ -6450,7 +6416,19 @@ mod tests {
         app.update(Action::Stash);
         app.update(Action::ForkCommit);
         app.update(Action::Attach);
-        assert!(app.actions_expanded, "grouped actions keep the group open");
+        assert!(app.actions_expanded, "all grouped actions keep the group open");
+
+        app.update(Action::MoveDown);
+        assert!(!app.actions_expanded, "navigation collapses the group");
+
+        app.update(Action::ToggleActions);
+        app.update(Action::ToggleHistoryDisplay);
+        assert!(!app.actions_expanded, "opening the view group closes actions");
+        assert!(app.history_display_expanded);
+
+        app.update(Action::ToggleActions);
+        assert!(app.actions_expanded);
+        assert!(!app.history_display_expanded, "opening actions closes the view group");
         app.update(Action::ToggleActions);
         assert!(!app.actions_expanded, "the prefix key toggles the group");
     }
@@ -6488,8 +6466,8 @@ mod tests {
         app.update(Action::MoveDown);
         assert!(!app.enrich_expanded, "navigation closes enrich");
         app.update(Action::ToggleEnrich);
-        app.update(Action::ToggleCommitGroup);
-        assert!(!app.enrich_expanded, "opening commit closes enrich");
+        app.update(Action::ToggleActions);
+        assert!(!app.enrich_expanded, "opening actions closes enrich");
 
         app.hidden_rows.insert(id(1));
         app.update(Action::ToggleEnrich);
@@ -6535,8 +6513,8 @@ mod tests {
         assert!(!app.information_expanded, "opening view closes information");
         app.update(Action::ToggleInformation);
         assert!(!app.history_display_expanded, "opening information closes view");
-        app.update(Action::ToggleCommitGroup);
-        assert!(!app.information_expanded, "opening commit closes information");
+        app.update(Action::ToggleActions);
+        assert!(!app.information_expanded, "opening actions closes information");
     }
 
     #[test]
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index a73333d9dd4..689180b4fe5 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -6114,7 +6114,7 @@ fn poll_timeout(
 }
 
 fn action(key: KeyEvent) -> Option<Action> {
-    action_with_shortcut_groups(key, false, false, false, false, false)
+    action_with_shortcut_groups(key, false, false, false, false)
 }
 
 fn diagnostic_key(character: char) -> KeyEvent {
@@ -6141,10 +6141,7 @@ fn next_diagnostic_input(inputs: &mut VecDeque<KeyEvent>, state: State, lane_com
 fn diagnostic_action(key: KeyEvent, app: &App) -> Option<Action> {
     app_action(key, app).filter(|action| {
         (action_allowed_during_rebase_continuation(Some(action), app.changes_focus.is_some())
-            || matches!(
-                action,
-                Action::ToggleCommitGroup | Action::ToggleActions | Action::ToggleEnrich
-            ))
+            || matches!(action, Action::ToggleActions | Action::ToggleEnrich))
             && !matches!(
                 action,
                 Action::Copy | Action::CopyPath(_) | Action::CopyAuthor | Action::ForceQuit | Action::Quit
@@ -6209,7 +6206,6 @@ fn app_action(key: KeyEvent, app: &App) -> Option<Action> {
     action_with_shortcut_groups(
         key,
         app.history_display_expanded,
-        app.commit_expanded,
         app.actions_expanded,
         app.enrich_expanded,
         app.information_expanded || app.changes_focus.is_some(),
@@ -6266,7 +6262,6 @@ fn action_allowed_during_rebase_continuation(action: Option<&Action>, changes_fo
 fn action_with_shortcut_groups(
     key: KeyEvent,
     history_display_expanded: bool,
-    commit_expanded: bool,
     actions_expanded: bool,
     enrich_expanded: bool,
     information_expanded: bool,
@@ -6279,12 +6274,9 @@ fn action_with_shortcut_groups(
         KeyCode::Enter => Some(Action::OpenDiff),
         KeyCode::Char('c') if key.modifiers.contains(KeyModifiers::CONTROL) => Some(Action::ForceQuit),
         KeyCode::Char('v') => Some(Action::ToggleHistoryDisplay),
-        KeyCode::Char('c') => Some(Action::ToggleCommitGroup),
         KeyCode::Char('a') => Some(Action::ToggleActions),
-        KeyCode::Char('n') => Some(Action::ToggleEnrich),
         KeyCode::Char('?') => Some(Action::ToggleInformation),
         KeyCode::Char('/') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::ToggleInformation),
-        KeyCode::Char('p') if commit_expanded => Some(Action::Split),
         KeyCode::Char('b') if actions_expanded && !key.modifiers.contains(KeyModifiers::CONTROL) => {
             Some(Action::Rebase)
         }
@@ -6306,6 +6298,15 @@ fn action_with_shortcut_groups(
         }
         KeyCode::Char('h') if actions_expanded => Some(Action::Attach),
         KeyCode::Char('z') if actions_expanded => Some(Action::Stash),
+        KeyCode::Char('o') if actions_expanded => Some(Action::Reword),
+        KeyCode::Char('w') if actions_expanded => Some(Action::NewCommit),
+        KeyCode::Char('n') if actions_expanded => Some(Action::NewEmptyCommit),
+        KeyCode::Char('e') if actions_expanded => Some(Action::Amend),
+        KeyCode::Char('l') if actions_expanded => Some(Action::Spill),
+        KeyCode::Char('p') if actions_expanded => Some(Action::Split),
+        KeyCode::Char('d') if actions_expanded => Some(Action::Forget),
+        KeyCode::Char('i') if actions_expanded => Some(Action::TogglePin),
+        KeyCode::Char('n') => Some(Action::ToggleEnrich),
         KeyCode::Char('p') => Some(Action::CycleChangesParent),
         KeyCode::Char('q') => Some(Action::Quit),
         KeyCode::Esc => Some(Action::Cancel),
@@ -6334,13 +6335,6 @@ fn action_with_shortcut_groups(
         KeyCode::Char('R') => Some(Action::Refresh),
         KeyCode::Char('r') if key.modifiers.contains(KeyModifiers::SHIFT) => Some(Action::Refresh),
         KeyCode::Char('r') if history_display_expanded => Some(Action::CycleRefs),
-        KeyCode::Char('o') if commit_expanded => Some(Action::Reword),
-        KeyCode::Char('w') if commit_expanded => Some(Action::NewCommit),
-        KeyCode::Char('m') if commit_expanded => Some(Action::NewEmptyCommit),
-        KeyCode::Char('e') if commit_expanded => Some(Action::Amend),
-        KeyCode::Char('s') if commit_expanded => Some(Action::Spill),
-        KeyCode::Char('d') if commit_expanded => Some(Action::Forget),
-        KeyCode::Char('i') if commit_expanded => Some(Action::TogglePin),
         KeyCode::Char('e') if enrich_expanded => Some(Action::ToggleChecksPass),
         KeyCode::Char('t') if enrich_expanded => Some(Action::ToggleTodo),
         KeyCode::Char('o') if enrich_expanded => Some(Action::EditNote),
@@ -7648,10 +7642,7 @@ mod tests {
         );
         assert_eq!(action(KeyEvent::new(KeyCode::Char('d'), KeyModifiers::NONE)), None);
         assert_eq!(action(KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE)), None);
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)),
-            Some(Action::ToggleCommitGroup)
-        );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)), None);
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('a'), KeyModifiers::NONE)),
             Some(Action::ToggleActions)
@@ -7665,7 +7656,6 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
                 false,
                 false,
-                false,
                 true,
                 false
             ),
@@ -7676,7 +7666,6 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE),
                 false,
                 false,
-                false,
                 true,
                 false
             ),
@@ -7687,7 +7676,6 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('o'), KeyModifiers::NONE),
                 false,
                 false,
-                false,
                 true,
                 false
             ),
@@ -7698,7 +7686,6 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('g'), KeyModifiers::NONE),
                 false,
                 false,
-                false,
                 true,
                 false
             ),
@@ -7709,7 +7696,6 @@ mod tests {
                 KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
                 false,
                 false,
-                false,
                 true,
                 false
             ),
@@ -7789,32 +7775,27 @@ mod tests {
                     true,
                     false,
                     false,
-                    false,
                     false
                 ),
                 Some(expected),
                 "{key} is available after the view prefix"
             );
         }
-        for (history, commit, actions, enrich, information) in [
-            (true, false, false, false, false),
-            (false, true, false, false, false),
-            (false, false, true, false, false),
-            (false, false, false, true, false),
-            (false, false, false, false, true),
+        for (history, actions, enrich, information) in [
+            (true, false, false, false),
+            (false, true, false, false),
+            (false, false, true, false),
+            (false, false, false, true),
         ] {
             for (key, expected) in [
                 ('v', Action::ToggleHistoryDisplay),
-                ('c', Action::ToggleCommitGroup),
                 ('a', Action::ToggleActions),
-                ('n', Action::ToggleEnrich),
                 ('?', Action::ToggleInformation),
             ] {
                 assert_eq!(
                     action_with_shortcut_groups(
                         KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
                         history,
-                        commit,
                         actions,
                         enrich,
                         information,
@@ -7823,6 +7804,21 @@ mod tests {
                     "{key} switches prefix menus regardless of the active menu"
                 );
             }
+            assert_eq!(
+                action_with_shortcut_groups(
+                    KeyEvent::new(KeyCode::Char('n'), KeyModifiers::NONE),
+                    history,
+                    actions,
+                    enrich,
+                    information,
+                ),
+                Some(if actions {
+                    Action::NewEmptyCommit
+                } else {
+                    Action::ToggleEnrich
+                }),
+                "the actions shortcut takes priority over the enrich prefix"
+            );
         }
         assert_eq!(
             action_with_shortcut_groups(
@@ -7830,7 +7826,6 @@ mod tests {
                 true,
                 false,
                 false,
-                false,
                 false
             ),
             Some(Action::ToggleHistoryDisplay),
@@ -7839,9 +7834,9 @@ mod tests {
         for (key, expected) in [
             ('o', Action::Reword),
             ('w', Action::NewCommit),
-            ('m', Action::NewEmptyCommit),
+            ('n', Action::NewEmptyCommit),
             ('e', Action::Amend),
-            ('s', Action::Spill),
+            ('l', Action::Spill),
             ('p', Action::Split),
             ('d', Action::Forget),
             ('i', Action::TogglePin),
@@ -7852,11 +7847,10 @@ mod tests {
                     false,
                     true,
                     false,
-                    false,
                     false
                 ),
                 Some(expected),
-                "{key} is available after the commit prefix"
+                "{key} is available on the commit line after the actions prefix"
             );
         }
         for (key, expected) in [
@@ -7875,7 +7869,6 @@ mod tests {
                 action_with_shortcut_groups(
                     KeyEvent::new(KeyCode::Char(key), KeyModifiers::NONE),
                     false,
-                    false,
                     true,
                     false,
                     false
@@ -7884,7 +7877,7 @@ mod tests {
                 "{key} is available after the actions prefix"
             );
         }
-        for (history, commit, enrich, expected) in [
+        for (history, actions, enrich, expected) in [
             (true, false, false, Action::ToggleName),
             (false, true, false, Action::Amend),
             (false, false, true, Action::ToggleChecksPass),
@@ -7893,8 +7886,7 @@ mod tests {
                 action_with_shortcut_groups(
                     KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
                     history,
-                    commit,
-                    false,
+                    actions,
                     enrich,
                     true,
                 ),
@@ -7908,11 +7900,10 @@ mod tests {
                 false,
                 true,
                 false,
-                false,
                 false
             ),
-            Some(Action::ToggleRefTree),
-            "the direct ref-tree key remains available while commit is expanded"
+            Some(Action::StackInsert),
+            "the actions shortcut takes priority over the direct ref-tree key"
         );
         assert_eq!(
             action_with_shortcut_groups(
@@ -7920,11 +7911,10 @@ mod tests {
                 false,
                 true,
                 false,
-                false,
                 false
             ),
             Some(Action::TimeTravel),
-            "the direct time-travel key remains available while commit is expanded"
+            "the direct time-travel key remains available while actions are expanded"
         );
         assert_eq!(
             action_with_shortcut_groups(
@@ -7932,23 +7922,10 @@ mod tests {
                 false,
                 true,
                 false,
-                false,
                 false
             ),
             Some(Action::PageUp),
-            "navigation keeps priority over the commit shortcut"
-        );
-        assert_eq!(
-            action_with_shortcut_groups(
-                KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE),
-                false,
-                true,
-                false,
-                false,
-                false
-            ),
-            Some(Action::ToggleCommitGroup),
-            "c closes the commit shortcut group"
+            "navigation keeps priority over the actions shortcut"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('s'), KeyModifiers::NONE)),
@@ -7970,27 +7947,22 @@ mod tests {
                 false,
                 true,
                 false,
-                false,
                 false
             ),
-            Some(Action::ToggleRefs),
-            "plain r retains its direct reference-toggle behavior"
+            Some(Action::Review),
+            "the actions shortcut takes priority over the direct reference toggle"
         );
         assert_eq!(
             action(KeyEvent::new(KeyCode::Char('p'), KeyModifiers::NONE)),
             Some(Action::CycleChangesParent)
         );
-        assert_eq!(
-            action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)),
-            Some(Action::ToggleCommitGroup)
-        );
+        assert_eq!(action(KeyEvent::new(KeyCode::Char('c'), KeyModifiers::NONE)), None);
         assert_eq!(
             action_with_shortcut_groups(
                 KeyEvent::new(KeyCode::Char('e'), KeyModifiers::NONE),
                 false,
                 false,
                 false,
-                false,
                 true
             ),
             Some(Action::ToggleChanges),
@@ -8132,12 +8104,12 @@ mod tests {
     fn tree_is_direct_while_trailers_remain_scoped_to_the_view_prefix() {
         let key = KeyEvent::new(KeyCode::Char('t'), KeyModifiers::NONE);
         assert_eq!(
-            action_with_shortcut_groups(key, true, false, false, false, false),
+            action_with_shortcut_groups(key, true, false, false, false),
             Some(Action::ToggleTrailers),
             "v t retains its trailer action"
         );
         assert_eq!(
-            action_with_shortcut_groups(key, false, false, false, false, false),
+            action_with_shortcut_groups(key, false, false, false, false),
             Some(Action::ToggleRefTree),
             "plain t toggles the ref-tree"
         );
@@ -8214,7 +8186,7 @@ mod tests {
             Action::Refresh,
             Action::ToggleHidden,
             Action::ToggleRefTree,
-            Action::ToggleCommitGroup,
+            Action::ToggleActions,
             Action::Amend,
             Action::Spill,
             Action::Rebase,
diff --git a/gix-tix/src/ui.rs b/gix-tix/src/ui.rs
index 853460958f8..2c8250c56ef 100644
--- a/gix-tix/src/ui.rs
+++ b/gix-tix/src/ui.rs
@@ -435,11 +435,12 @@ pub(crate) fn draw_with_worktree(
                     && !changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged)
             }),
     );
+    let popup_rows = usize::from(app.actions_expanded) + 1;
     let mut prefix_popup_allowed = active_prefix_popup_anchor(app, decorations)
-        .is_some_and(|anchor| prefix_popup_can_render(frame.area(), footer, anchor));
+        .is_some_and(|anchor| prefix_popup_can_render(frame.area(), footer, anchor, popup_rows));
     if prefix_popup_allowed {
-        let popup_y = footer.y - 1;
-        let shifted_y = |area: Rect| area.y.saturating_sub(1).max(full_body.y);
+        let popup_y = footer.y - popup_rows as u16;
+        let shifted_y = |area: Rect| area.y.saturating_sub(popup_rows as u16).max(full_body.y);
         prefix_popup_allowed = changes_panes.iter().all(|pane| popup_y > shifted_y(pane.outer))
             && commit_pane.as_ref().is_none_or(|(outer, _)| popup_y > outer.y)
             && notice_area.is_none_or(|area| popup_y.saturating_sub(shifted_y(area)) >= area.height);
@@ -1075,13 +1076,14 @@ pub(crate) fn draw_with_worktree(
     };
     let mut footer_spans = vec![Span::raw(status)];
     let mut time_travel = None;
-    let mut commit_prefix_spans = Vec::new();
-    let mut commit_popup = None;
     let mut actions_prefix_spans = Vec::new();
     let mut actions_popup = None;
     if !selected_segment && (app.changes_focus != Some(ChangePane::Worktree) || app.can_amend()) {
         time_travel = time_travel_label(app, decorations);
-        if app.commit_expanded {
+        actions_prefix_spans.push(Span::raw(" · "));
+        actions_prefix_spans.push(Span::styled("a", Style::default().add_modifier(Modifier::UNDERLINED)));
+        actions_prefix_spans.push(Span::raw("ctions"));
+        if app.actions_expanded {
             let mut options = Vec::new();
             if app.changes_focus.is_none() && app.reword_shortcut_visible() {
                 options.push(("reword", 'o'));
@@ -1090,13 +1092,13 @@ pub(crate) fn draw_with_worktree(
                 options.push(("new", 'w'));
             }
             if app.changes_focus.is_none() && app.can_create_empty_commit() {
-                options.push(("new-empty", 'm'));
+                options.push(("new-empty", 'n'));
             }
             if app.can_amend() {
                 options.push(("amend", 'e'));
             }
             if app.can_spill() {
-                options.push(("spill", 's'));
+                options.push(("spill", 'l'));
             }
             if app.can_split() {
                 options.push(("split", 'p'));
@@ -1125,44 +1127,31 @@ pub(crate) fn draw_with_worktree(
                     items.extend(shortcut(label, key, true));
                 }
             }
-            commit_popup = Some(items);
-        }
-        commit_prefix_spans.push(Span::raw(" · "));
-        commit_prefix_spans.push(Span::styled("c", Style::default().add_modifier(Modifier::UNDERLINED)));
-        commit_prefix_spans.push(Span::raw("ommit"));
-        if app.commit_expanded {
-            emphasize_prefix(&mut commit_prefix_spans[1..]);
-        }
-    }
-    if !selected_segment && app.changes_focus.is_none() {
-        actions_prefix_spans.push(Span::raw(" · "));
-        actions_prefix_spans.push(Span::styled("a", Style::default().add_modifier(Modifier::UNDERLINED)));
-        actions_prefix_spans.push(Span::raw("ctions"));
-        if app.actions_expanded {
+            let commit_items = items;
             let mut options = Vec::new();
-            if app.can_stash() {
+            if app.changes_focus.is_none() && app.can_stash() {
                 options.push(("z stash", 'z'));
-            } else if app.can_unstash() {
+            } else if app.changes_focus.is_none() && app.can_unstash() {
                 options.push(("z unstash", 'z'));
             }
-            if app.can_rebase() {
+            if app.changes_focus.is_none() && app.can_rebase() {
                 options.push(("rebase", 'b'));
             }
-            if app.can_rebase_update() {
+            if app.changes_focus.is_none() && app.can_rebase_update() {
                 options.push(("rebase-update", 'u'));
             }
-            if app.can_finish_review() {
+            if app.changes_focus.is_none() && app.can_finish_review() {
                 options.push(("finish-review", 'r'));
-            } else if app.can_review() {
+            } else if app.changes_focus.is_none() && app.can_review() {
                 options.push(("review", 'r'));
             }
-            if app.can_squash() {
+            if app.changes_focus.is_none() && app.can_squash() {
                 options.push(("squash", 's'));
             }
-            if app.can_copy_insert() {
+            if app.changes_focus.is_none() && app.can_copy_insert() {
                 options.push(("copy-insert", 'y'));
             }
-            if app.can_move_insert() {
+            if app.changes_focus.is_none() && app.can_move_insert() {
                 options.push(("move-insert", 'm'));
             }
             let mut items = Vec::new();
@@ -1172,20 +1161,20 @@ pub(crate) fn draw_with_worktree(
                 }
                 items.extend(shortcut(label, key, true));
             }
-            if app.can_stack_insert() {
+            if app.changes_focus.is_none() && app.can_stack_insert() {
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
                 items.push(Span::raw("stack-inser"));
                 items.push(Span::styled("t", Style::default().add_modifier(Modifier::UNDERLINED)));
             }
-            if app.can_fork_commit() {
+            if app.changes_focus.is_none() && app.can_fork_commit() {
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
                 items.extend(shortcut("fork", 'f', true));
             }
-            if app.can_attach() {
+            if app.changes_focus.is_none() && app.can_attach() {
                 if !items.is_empty() {
                     items.push(Span::raw(" · "));
                 }
@@ -1194,7 +1183,7 @@ pub(crate) fn draw_with_worktree(
             if items.is_empty() {
                 items.push(Span::raw("no actions"));
             }
-            actions_popup = Some(items);
+            actions_popup = Some(vec![commit_items, items]);
             emphasize_prefix(&mut actions_prefix_spans[1..]);
         }
     }
@@ -1258,16 +1247,11 @@ pub(crate) fn draw_with_worktree(
     if selected_segment {
         ordered.push(Span::raw(" · <enter> expand"));
     }
-    let mut prefix_popup = None;
+    let mut prefix_popup: Option<(usize, Vec<Vec<Span<'static>>>)> = None;
     let view_anchor = spans_width(&ordered).saturating_add(view_prefix_spans[0].width());
     ordered.append(&mut view_prefix_spans);
     if let Some(items) = view_popup {
-        prefix_popup = Some((view_anchor, items));
-    }
-    let commit_anchor = spans_width(&ordered).saturating_add(commit_prefix_spans.first().map_or(0, Span::width));
-    ordered.append(&mut commit_prefix_spans);
-    if let Some(items) = commit_popup {
-        prefix_popup = Some((commit_anchor, items));
+        prefix_popup = Some((view_anchor, vec![items]));
     }
     let actions_anchor = spans_width(&ordered).saturating_add(actions_prefix_spans.first().map_or(0, Span::width));
     ordered.append(&mut actions_prefix_spans);
@@ -1295,7 +1279,7 @@ pub(crate) fn draw_with_worktree(
                 items.push(Span::raw("no actions"));
             }
             emphasize_prefix(&mut ordered[enrich_prefix_start..]);
-            prefix_popup = Some((enrich_anchor, items));
+            prefix_popup = Some((enrich_anchor, vec![items]));
         }
     }
     if let Some(label) = time_travel {
@@ -1366,7 +1350,7 @@ pub(crate) fn draw_with_worktree(
             }));
         }
         emphasize_prefix(&mut ordered[information_prefix_start..]);
-        prefix_popup = Some((information_anchor, items));
+        prefix_popup = Some((information_anchor, vec![items]));
     }
     ordered.append(&mut footer_spans);
     footer_spans = ordered;
@@ -1379,8 +1363,10 @@ pub(crate) fn draw_with_worktree(
     }
     if app.unseen_filesystem_redraw {
         footer_spans = notification_discs(footer_spans);
-        if let Some((_, items)) = prefix_popup.as_mut() {
-            *items = notification_discs(std::mem::take(items));
+        if let Some((_, rows)) = prefix_popup.as_mut() {
+            for items in rows {
+                *items = notification_discs(std::mem::take(items));
+            }
         }
     }
     frame.render_widget(Paragraph::new(Line::from(footer_spans)), footer);
@@ -1468,16 +1454,8 @@ fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<us
     width += "view".len();
     let mut active = app.history_display_expanded.then_some(view);
 
-    let commit_visible = !selected_segment && (app.changes_focus != Some(ChangePane::Worktree) || app.can_amend());
-    if commit_visible {
-        width += 3;
-        let commit = width;
-        width += "commit".len();
-        if app.commit_expanded {
-            active = Some(commit);
-        }
-    }
-    if !selected_segment && app.changes_focus.is_none() {
+    let actions_visible = !selected_segment && (app.changes_focus != Some(ChangePane::Worktree) || app.can_amend());
+    if actions_visible {
         width += 3;
         let actions = width;
         width += "actions".len();
@@ -1493,7 +1471,7 @@ fn active_prefix_popup_anchor(app: &App, decorations: &Decorations) -> Option<us
             active = Some(enrich);
         }
     }
-    if commit_visible && let Some(label) = time_travel_label(app, decorations) {
+    if actions_visible && let Some(label) = time_travel_label(app, decorations) {
         width += 3 + label.len();
     }
     if app.can_cycle_duplicate() {
@@ -2244,26 +2222,37 @@ fn render_prefix_popup(
     frame: &mut Frame<'_>,
     footer: Rect,
     anchor: usize,
-    mut items: Vec<Span<'static>>,
+    mut rows: Vec<Vec<Span<'static>>>,
 ) -> Option<Rect> {
-    if !prefix_popup_can_render(frame.area(), footer, anchor) {
+    let height = u16::try_from(rows.len()).unwrap_or(u16::MAX);
+    if !prefix_popup_can_render(frame.area(), footer, anchor, rows.len()) {
         return None;
     }
-    items.insert(0, Span::raw(" "));
-    items.push(Span::raw(" "));
-    let width = u16::try_from(spans_width(&items)).unwrap_or(u16::MAX).min(footer.width);
+    let mut width = 0;
+    for items in &mut rows {
+        items.insert(0, Span::raw(" "));
+        items.push(Span::raw(" "));
+        width = width.max(spans_width(items));
+    }
+    let width = u16::try_from(width).unwrap_or(u16::MAX).min(footer.width);
     let anchor = footer.x.saturating_add(u16::try_from(anchor).unwrap_or(u16::MAX));
-    let area = Rect::new(anchor.min(footer.right().saturating_sub(width)), footer.y - 1, width, 1);
+    let area = Rect::new(
+        anchor.min(footer.right().saturating_sub(width)),
+        footer.y - height,
+        width,
+        height,
+    );
     frame.render_widget(Clear, area);
     frame.render_widget(
-        Paragraph::new(Line::from(items)).style(Style::default().add_modifier(Modifier::REVERSED)),
+        Paragraph::new(rows.into_iter().map(Line::from).collect::<Vec<_>>())
+            .style(Style::default().add_modifier(Modifier::REVERSED)),
         area,
     );
     Some(area)
 }
 
-fn prefix_popup_can_render(frame: Rect, footer: Rect, anchor: usize) -> bool {
-    footer.width > 0 && footer.y > frame.y && anchor < usize::from(footer.width)
+fn prefix_popup_can_render(frame: Rect, footer: Rect, anchor: usize, rows: usize) -> bool {
+    footer.width > 0 && usize::from(footer.y.saturating_sub(frame.y)) >= rows && anchor < usize::from(footer.width)
 }
 
 fn notification_discs(spans: Vec<Span<'_>>) -> Vec<Span<'_>> {
@@ -2873,7 +2862,7 @@ mod tests {
                 frame,
                 Rect::new(0, 1, 20, 1),
                 12,
-                vec![Span::raw("abcdefghijklmnopqrstuvwxyz")],
+                vec![vec![Span::raw("abcdefghijklmnopqrstuvwxyz")]],
             );
         })?;
 
@@ -3290,8 +3279,7 @@ mod tests {
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
         let computing = rendered_line(&terminal, 1);
         assert!(
-            computing.contains("1 commits · view · commit · actions · enrich · copy")
-                && computing.contains("computing"),
+            computing.contains("1 commits · view · actions · enrich · copy") && computing.contains("computing"),
             "expired deferral reveals computation progress"
         );
         assert_ne!(computing, completed, "visible progress changes the footer");
@@ -3747,7 +3735,7 @@ mod tests {
         terminal.draw(|frame| super::draw(frame, &mut app, &Decorations::new(), &mailmap, None, None))?;
 
         assert!(
-            rendered_line(&terminal, 2).contains(" · commit · actions ·"),
+            rendered_line(&terminal, 2).contains(" · actions ·"),
             "the commit and actions prefixes remain available beside the view group"
         );
 
@@ -3932,7 +3920,7 @@ mod tests {
             "todo commit metadata uses the author date and excludes separately represented refs"
         );
 
-        let footer_text = "#0 · view · commit · actions · enrich · copy · refs · ? · quit";
+        let footer_text = "#0 · view · actions · enrich · copy · refs · ? · quit";
         let selected_line = "      > @ 0101010 1970-01-01 mapped author subject";
         let mut expected = Buffer::with_lines([format!("{selected_line:<180}"), format!("{footer_text:<180}")]);
         for x in 0..selected_line.chars().count() as u16 {
@@ -3958,7 +3946,6 @@ mod tests {
             .set_style(Style::default().fg(Color::Blue).add_modifier(Modifier::REVERSED));
         for (label, key) in [
             ("view", 'v'),
-            ("commit", 'c'),
             ("actions", 'a'),
             ("enrich", 'n'),
             ("copy", 'y'),
@@ -4209,8 +4196,7 @@ mod tests {
                 }],
             ),
         ]);
-        let mut terminal = Terminal::new(TestBackend::new(140, 3))?;
-        app.commit_expanded = true;
+        let mut terminal = Terminal::new(TestBackend::new(140, 4))?;
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         let row = rendered_row(&terminal);
         assert!(row.contains("📌"), "a pinned commit has an obvious pin marker: {row:?}");
@@ -4246,18 +4232,20 @@ mod tests {
             row.contains("📌") && row.contains("🎁"),
             "hiding refs retains resource markers: {row:?}"
         );
+        app.actions_expanded = true;
+        terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
         assert!(
             rendered_line(&terminal, 1).contains(" reword · new · new-empty · d forget · unpin "),
             "the commit actions float above their prefix"
         );
         assert!(
-            rendered_line(&terminal, 2).contains("commit · actions · enrich · @ return · copy"),
-            "time travel stays outside the active commit prefix"
+            rendered_line(&terminal, 3).contains("actions · enrich · @ return · copy"),
+            "time travel stays outside the active actions prefix"
         );
 
         decorations.remove(&selected);
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        assert!(rendered_line(&terminal, 2).contains(" · @ travel · copy"));
+        assert!(rendered_line(&terminal, 3).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         app.ref_mode = RefMode::Default;
@@ -4275,7 +4263,7 @@ mod tests {
             "the remembered branch has its dedicated marker: {row:?}"
         );
         assert!(!row.contains("📌"), "the HEAD pin is not an ordinary pin: {row:?}");
-        assert!(rendered_line(&terminal, 2).contains(" · @ travel · copy"));
+        assert!(rendered_line(&terminal, 3).contains(" · @ travel · copy"));
         assert!(!rendered_line(&terminal, 1).contains("unpin"));
 
         decorations.remove(&head);
@@ -4293,7 +4281,7 @@ mod tests {
             ],
         );
         terminal.draw(|frame| draw(frame, &mut app, &decorations))?;
-        let footer = rendered_line(&terminal, 2);
+        let footer = rendered_line(&terminal, 3);
         assert!(
             !footer.contains("@ travel") && !footer.contains("@ return"),
             "time travel is hidden at HEAD: {footer}"
@@ -4307,7 +4295,7 @@ mod tests {
         app.changes_mode = None;
         app.configure_hidden_filter(true);
         app.history_display_expanded = true;
-        let mut terminal = Terminal::new(TestBackend::new(240, 2))?;
+        let mut terminal = Terminal::new(TestBackend::new(240, 3))?;
 
         terminal.draw(|frame| {
             super::draw_with_worktree(
@@ -4321,11 +4309,11 @@ mod tests {
             );
         })?;
 
-        let footer = rendered_line(&terminal, 1);
-        let compact = "0 commits · view · commit · actions · enrich · copy · refs · ? · Esc cancel · quit";
+        let footer = rendered_line(&terminal, 2);
+        let compact = "0 commits · view · actions · enrich · copy · refs · ? · Esc cancel · quit";
         assert_eq!(footer.trim_end(), compact, "the footer keeps every prefix compact");
         let view = "author date · ids · emails · names · mailmap · trailers · refs · show hidden";
-        let popup = rendered_line(&terminal, 0);
+        let popup = rendered_line(&terminal, 1);
         let view_x = footer[..footer.find("view").expect("the view prefix is visible")]
             .chars()
             .count() as u16;
@@ -4335,46 +4323,40 @@ mod tests {
             - 1;
         assert_eq!(popup_x, view_x, "the popout is connected to its footer prefix");
         assert!(
-            terminal.backend().buffer()[(view_x, 1)]
+            terminal.backend().buffer()[(view_x, 2)]
                 .modifier
                 .contains(Modifier::UNDERLINED),
             "the prefix key is underlined in its verb"
         );
-        assert_reversed_group(&terminal, 1, "view");
-        assert_reversed_group(&terminal, 0, &format!(" {view} "));
+        assert_reversed_group(&terminal, 2, "view");
+        assert_reversed_group(&terminal, 1, &format!(" {view} "));
 
         app.history_display_expanded = false;
-        app.commit_expanded = true;
-        terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
-        assert!(rendered_line(&terminal, 0).contains(" no actions "));
-        assert_reversed_group(&terminal, 1, "commit");
-        assert_reversed_group(&terminal, 0, " no actions ");
-
-        app.commit_expanded = false;
         app.actions_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        assert_eq!(rendered_line(&terminal, 2).trim_end(), compact);
         assert!(rendered_line(&terminal, 0).contains(" no actions "));
-        assert_reversed_group(&terminal, 1, "actions");
+        assert!(rendered_line(&terminal, 1).contains(" no actions "));
+        assert_reversed_group(&terminal, 2, "actions");
         assert_reversed_group(&terminal, 0, " no actions ");
+        assert_reversed_group(&terminal, 1, " no actions ");
 
         app.actions_expanded = false;
         app.enrich_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
-        assert!(rendered_line(&terminal, 0).contains(" no actions "));
-        assert_reversed_group(&terminal, 1, "enrich");
-        assert_reversed_group(&terminal, 0, " no actions ");
+        assert_eq!(rendered_line(&terminal, 2).trim_end(), compact);
+        assert!(rendered_line(&terminal, 1).contains(" no actions "));
+        assert_reversed_group(&terminal, 2, "enrich");
+        assert_reversed_group(&terminal, 1, " no actions ");
 
         app.enrich_expanded = false;
         app.information_expanded = true;
         terminal.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert_eq!(rendered_line(&terminal, 1).trim_end(), compact);
+        assert_eq!(rendered_line(&terminal, 2).trim_end(), compact);
         let information = "[ title · ref-tree · message · changes · ↑↓/jk move · h/l pan · Shift+directions topo · wheel/page pan · Shift+wheel/page move · <enter> diff";
-        assert!(rendered_line(&terminal, 0).contains(information));
-        assert_reversed_group(&terminal, 1, "?");
-        assert_reversed_group(&terminal, 0, &format!(" {information} "));
+        assert!(rendered_line(&terminal, 1).contains(information));
+        assert_reversed_group(&terminal, 2, "?");
+        assert_reversed_group(&terminal, 1, &format!(" {information} "));
         Ok(())
     }
 
@@ -4460,7 +4442,7 @@ mod tests {
         app.set_worktree_head(Some(id), false);
         complete(&mut app);
         app.changes_focus = Some(ChangePane::Tree);
-        app.commit_expanded = true;
+        app.actions_expanded = true;
         let changes = Changes {
             paths: vec![crate::app::PathChange {
                 kind: ChangeKind::Added,
@@ -4489,7 +4471,7 @@ mod tests {
                 Some(&changes),
             );
         })?;
-        let popup = rendered_line(&terminal, 6);
+        let popup = rendered_line(&terminal, 5);
         assert!(
             popup.contains(" spill "),
             "tree focus keeps the scoped edit visible: {popup}"
@@ -4509,7 +4491,7 @@ mod tests {
         };
         app.set_head_edit_availability(true, false, false, true, false, false, false);
         assert!(app.can_amend(), "the focused worktree path is amendable");
-        assert!(app.commit_expanded, "the commit prefix remains expanded");
+        assert!(app.actions_expanded, "the actions prefix remains expanded");
         terminal.draw(|frame| {
             super::draw_with_worktree(
                 frame,
@@ -4522,8 +4504,8 @@ mod tests {
             );
         })?;
         assert!(app.can_amend(), "drawing retains scoped amend availability");
-        assert!(app.commit_expanded, "drawing retains the expanded commit prefix");
-        let popup = rendered_line(&terminal, 6);
+        assert!(app.actions_expanded, "drawing retains the expanded actions prefix");
+        let popup = rendered_line(&terminal, 5);
         assert!(
             popup.contains(" amend "),
             "worktree focus keeps the scoped edit visible: {popup}"
@@ -4531,7 +4513,6 @@ mod tests {
         assert!(!popup.contains("spill"), "worktree paths cannot be spilled");
 
         app.changes_focus = None;
-        app.update(Action::ToggleActions);
         terminal.draw(|frame| {
             super::draw_with_worktree(
                 frame,
@@ -4574,7 +4555,6 @@ mod tests {
             .expect("HEAD has decorations")
             .retain(|decoration| decoration.kind != DecorationKind::Stash);
         app.changes_focus = Some(ChangePane::Worktree);
-        app.update(Action::ToggleCommitGroup);
 
         std::sync::Arc::make_mut(&mut app.rows[0]).is_review = true;
         terminal.draw(|frame| {
@@ -4589,7 +4569,7 @@ mod tests {
             );
         })?;
         assert!(
-            !rendered_line(&terminal, 6).contains("amend"),
+            !rendered_line(&terminal, 5).contains("amend"),
             "a review cannot amend an unstaged selected path"
         );
         worktree.paths[0].group = ChangeGroup::Staged;
@@ -4605,7 +4585,7 @@ mod tests {
             );
         })?;
         assert!(
-            rendered_line(&terminal, 6).contains(" amend "),
+            rendered_line(&terminal, 5).contains(" amend "),
             "a review may amend its selected staged path"
         );
         Ok(())
@@ -6917,20 +6897,15 @@ mod tests {
             rendered_line(&narrow, 1).ends_with(" ⇣2 "),
             "the terminal edge pushes the marker over clipped title text"
         );
-        app.commit_expanded = true;
+        app.actions_expanded = true;
         let mut commit = Terminal::new(TestBackend::new(120, 3))?;
         commit.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
-        assert!(rendered_line(&commit, 1).contains(" pin "));
-        assert!(!rendered_line(&commit, 1).contains("rebase"));
-        app.commit_expanded = false;
-        app.actions_expanded = true;
-        let mut actions = Terminal::new(TestBackend::new(120, 3))?;
-        actions.draw(|frame| draw(frame, &mut app, &Decorations::new()))?;
+        assert!(rendered_line(&commit, 0).contains(" pin "));
         assert!(
-            rendered_line(&actions, 1).contains(" rebase · rebase-update ")
-                && rendered_line(&actions, 2).contains("commit · actions"),
+            rendered_line(&commit, 1).contains(" rebase · rebase-update ")
+                && rendered_line(&commit, 2).contains("actions"),
             "the selected hidden base offers rebasing from actions: {:?}",
-            rendered_line(&actions, 1)
+            rendered_line(&commit, 1)
         );
         Ok(())
     }

From 511093fb0ec4003e1dca8cc53e57d8bc8008004a Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 06:43:35 +0200
Subject: [PATCH 279/282] feat(gix-tix): copy-insert pasted commits

---
 gix-tix/spec.md    |   6 +++
 gix-tix/src/app.rs |  34 +++++++++++++
 gix-tix/src/lib.rs | 118 +++++++++++++++++++++++++++++++++++++++------
 3 files changed, 143 insertions(+), 15 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index 86dfe845d38..a2eb3185f9f 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -1146,6 +1146,12 @@ space first; changes blocks adapt within the remaining history width.
   retained in its original logical position while its branch follows the
   necessary rewrite. Git notes are copied to the new occurrence. Copy-insert
   uses the history-todo conflict and continuation rules.
+- Bracketed paste in the history view trims surrounding whitespace and accepts
+  one uniquely resolvable hexadecimal object-ID prefix. If that object is a
+  commit, its change is copy-inserted above the commit at the cursor using the
+  same progress, conflict, checkout, and undo behavior as `a y`. Other text,
+  ambiguous or missing IDs, non-commit objects, and unavailable targets produce
+  an attention message without changing the repository.
 - Move-insert requires a non-root, single-parent `HEAD`. It removes `HEAD` from
   its old position, reconnects its former children to its parent, inserts its
   rewritten change above the selected target, and reparents every former direct
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 99750135889..7bb9ea8973d 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -392,6 +392,7 @@ pub(crate) enum Action {
     RebaseUpdate,
     Squash,
     CopyInsert,
+    PasteInsert { source: ObjectId, target: ObjectId },
     MoveInsert,
     StackInsert,
     Review,
@@ -445,6 +446,10 @@ pub(crate) enum Effect {
         target: ObjectId,
         copy: bool,
     },
+    PasteInsert {
+        source: ObjectId,
+        target: ObjectId,
+    },
     StartReview {
         tip: ObjectId,
         base: ObjectId,
@@ -1943,6 +1948,9 @@ impl App {
                     copy: true,
                 }];
             }
+            Action::PasteInsert { source, target } => {
+                return vec![Effect::PasteInsert { source, target }];
+            }
             Action::MoveInsert if self.can_move_insert() => {
                 let source = self.worktree_head.expect("move-insert availability requires HEAD");
                 return vec![Effect::Insert {
@@ -2864,6 +2872,21 @@ impl App {
         self.can_insert(true)
     }
 
+    pub(crate) fn paste_insert_target(&self) -> Option<ObjectId> {
+        if self.state != State::Complete
+            || self.deferred_history_state.unwrap_or(self.state) != State::Complete
+            || self.changes_focus.is_some()
+            || self.has_conflict_marker()
+        {
+            return None;
+        }
+        self.selected
+            .filter(|index| !self.is_row_hidden(*index))
+            .and_then(|index| self.rows.get(index))
+            .filter(|row| !self.known_merge_descendants.contains(&row.id))
+            .map(|row| row.id)
+    }
+
     pub(crate) fn can_move_insert(&self) -> bool {
         self.can_insert(false)
     }
@@ -5042,6 +5065,17 @@ mod tests {
         assert!(merge_target.can_move_insert(), "an unchanged merge target is allowed");
     }
 
+    #[test]
+    fn paste_insert_uses_only_an_editable_history_selection() {
+        let mut app = App::new(10);
+        app.extend_commits(vec![row_with_parents(2, &[1]), row(1)]);
+        complete(&mut app);
+
+        assert_eq!(app.paste_insert_target(), Some(id(2)));
+        app.hidden_rows.insert(id(2));
+        assert_eq!(app.paste_insert_target(), None, "a hidden boundary is not editable");
+    }
+
     #[test]
     fn stack_insert_selects_only_valid_insertion_targets() {
         let mut app = App::new(10);
diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 689180b4fe5..37eb9088b05 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -37,9 +37,9 @@ use crossterm::{
     clipboard::CopyToClipboard,
     cursor,
     event::{
-        self, DisableFocusChange, DisableMouseCapture, EnableFocusChange, EnableMouseCapture, Event as TerminalEvent,
-        KeyCode, KeyEvent, KeyEventKind, KeyModifiers, KeyboardEnhancementFlags, MouseEventKind,
-        PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
+        self, DisableBracketedPaste, DisableFocusChange, DisableMouseCapture, EnableBracketedPaste, EnableFocusChange,
+        EnableMouseCapture, Event as TerminalEvent, KeyCode, KeyEvent, KeyEventKind, KeyModifiers,
+        KeyboardEnhancementFlags, MouseEventKind, PopKeyboardEnhancementFlags, PushKeyboardEnhancementFlags,
     },
     execute,
     style::ResetColor,
@@ -845,7 +845,7 @@ fn validate_hidden_revisions(
 }
 
 fn enable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keyboard: bool) -> std::io::Result<()> {
-    execute!(backend, EnableFocusChange, EnableMouseCapture)?;
+    execute!(backend, EnableFocusChange, EnableMouseCapture, EnableBracketedPaste)?;
     if enhanced_keyboard {
         execute!(backend, PushKeyboardEnhancementFlags(keyboard_enhancement_flags()))?;
     }
@@ -862,7 +862,7 @@ fn disable_input(backend: &mut CrosstermBackend<std::io::Stdout>, enhanced_keybo
     if enhanced_keyboard {
         execute!(backend, PopKeyboardEnhancementFlags)?;
     }
-    execute!(backend, DisableMouseCapture, DisableFocusChange)
+    execute!(backend, DisableBracketedPaste, DisableMouseCapture, DisableFocusChange)
 }
 
 fn is_key_press(event: &TerminalEvent) -> bool {
@@ -1762,6 +1762,12 @@ fn event_loop(
                     urgent = true;
                     continue;
                 }
+                TerminalEvent::Paste(_) => {
+                    ref_tree.leave_attention("commit paste is available only in history");
+                    dirty = true;
+                    urgent = true;
+                    continue;
+                }
                 _ => {}
             }
         }
@@ -1800,6 +1806,27 @@ fn event_loop(
                 let repeats_history = app.changes_focus.is_none() && repeats_viewport(&action);
                 (Some(action), repeats_history, true, true)
             }
+            TerminalEvent::Paste(pasted) => {
+                let action = (|| {
+                    anyhow::ensure!(!repository_is_bare, "copy-insert requires a worktree");
+                    let target = app
+                        .paste_insert_target()
+                        .context("copy-insert paste requires an editable history selection")?;
+                    let repository = open_repository(&repository_path, repository_is_bare, false)
+                        .context("could not open repository for pasted commit")?;
+                    let source = resolve_pasted_commit(&repository, &pasted)?;
+                    Ok::<_, anyhow::Error>(Action::PasteInsert { source, target })
+                })();
+                match action {
+                    Ok(action) => (Some(action), false, false, false),
+                    Err(err) => {
+                        app.leave_attention(format!("paste: {err:#}"));
+                        dirty = true;
+                        urgent = true;
+                        continue;
+                    }
+                }
+            }
             TerminalEvent::FocusLost => {
                 focused = false;
                 app.changes_suppressed = false;
@@ -1821,7 +1848,6 @@ fn event_loop(
                 urgent = true;
                 continue;
             }
-            _ => continue,
         };
         if !focused {
             continue;
@@ -3010,21 +3036,37 @@ fn event_loop(
                         Err(err) => app.leave_error(format!("squash: {err:#}")),
                     }
                 }
-                Effect::Insert {
-                    source,
-                    base,
-                    target,
-                    copy,
-                } => {
+                effect @ (Effect::Insert { .. } | Effect::PasteInsert { .. }) => {
+                    let (source, base, target, copy, pasted) = match effect {
+                        Effect::Insert {
+                            source,
+                            base,
+                            target,
+                            copy,
+                        } => (source, base, target, copy, false),
+                        Effect::PasteInsert { source, target } => (source, source, target, true, true),
+                        _ => unreachable!("the match arm accepts only insertion effects"),
+                    };
                     fill_repository.retain = false;
                     fill_repository.retained = None;
                     let result = (|| {
-                        let graph = history_graph
-                            .as_ref()
-                            .context("inserting commits requires a completed history graph")?;
                         let mut repository = open_repository(&repository_path, repository_is_bare, false)
                             .context("could not open repository to insert commits")?;
                         repository.object_cache_size(None);
+                        let loaded_graph;
+                        let graph = if pasted {
+                            let graph_revisions = [
+                                OsString::from("HEAD"),
+                                OsString::from(source.to_string()),
+                                OsString::from(target.to_string()),
+                            ];
+                            loaded_graph = edit::loaded_view_graph_with(&repository, &graph_revisions)?;
+                            &loaded_graph
+                        } else {
+                            history_graph
+                                .as_ref()
+                                .context("inserting commits requires a completed history graph")?
+                        };
                         let plan = if copy {
                             edit::rebase::copy_insert_plan(&repository, graph, source, target)?
                         } else if base == source {
@@ -6117,6 +6159,26 @@ fn action(key: KeyEvent) -> Option<Action> {
     action_with_shortcut_groups(key, false, false, false, false)
 }
 
+fn resolve_pasted_commit(repository: &gix::Repository, pasted: &str) -> Result<gix::ObjectId> {
+    let hash = pasted.trim();
+    anyhow::ensure!(
+        !hash.is_empty() && hash.bytes().all(|byte| byte.is_ascii_hexdigit()),
+        "expected exactly one hexadecimal commit ID"
+    );
+    let object = repository
+        .rev_parse(hash.as_bytes().as_bstr())
+        .context("could not resolve pasted commit ID")?
+        .single()
+        .context("pasted commit ID is ambiguous")?
+        .object()
+        .context("could not read pasted object")?;
+    anyhow::ensure!(
+        object.kind == gix::object::Kind::Commit,
+        "pasted object is not a commit"
+    );
+    Ok(object.id)
+}
+
 fn diagnostic_key(character: char) -> KeyEvent {
     let code = match character {
         '\t' => KeyCode::Tab,
@@ -6421,6 +6483,32 @@ fn mouse_scroll_action(
 mod tests {
     use super::*;
 
+    #[test]
+    fn pasted_commit_ids_are_hex_only_and_must_name_commit_objects() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let commit = repository.rev_parse_single("topic")?.detach();
+        let abbreviated = commit.to_hex_with_len(8).to_string();
+
+        assert_eq!(
+            resolve_pasted_commit(&repository, &format!("\n{abbreviated}\n"))?,
+            commit
+        );
+        assert_eq!(resolve_pasted_commit(&repository, &commit.to_string())?, commit);
+        for invalid in ["topic", "dead beef", ""] {
+            assert!(
+                resolve_pasted_commit(&repository, invalid).is_err(),
+                "{invalid:?} is not exactly one hexadecimal object ID"
+            );
+        }
+        let blob = repository.write_blob(b"not a commit")?.detach();
+        assert!(
+            resolve_pasted_commit(&repository, &blob.to_string()).is_err(),
+            "an existing non-commit object is rejected"
+        );
+        Ok(())
+    }
+
     #[test]
     fn shades_terminal_background_by_one_sixteenth() {
         assert_eq!(shade_terminal_background((0, 0, 0), true), (15, 15, 15));

From d70daf1771608dc1821d77db0ef2dccf07c444ea Mon Sep 17 00:00:00 2001
From: Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 06:50:56 +0200
Subject: [PATCH 280/282] fix(gix-tix): show hidden bases for unborn branches

---
 gix-tix/spec.md            |   4 +
 gix-tix/src/app.rs         |  45 +++++++-
 gix-tix/src/edit/create.rs |  31 ++++++
 gix-tix/src/edit/rebase.rs |  12 +--
 gix-tix/src/history.rs     | 214 +++++++++++++++++++++++++++++++------
 5 files changed, 263 insertions(+), 43 deletions(-)

diff --git a/gix-tix/spec.md b/gix-tix/spec.md
index a2eb3185f9f..97fba0ce936 100644
--- a/gix-tix/spec.md
+++ b/gix-tix/spec.md
@@ -717,6 +717,10 @@ space first; changes blocks adapt within the remaining history width.
 
 ### New commits
 
+- If an unborn `HEAD` leaves the ordinary history empty, each configured hidden
+  branch tip is shown as a selectable boundary without exposing its ancestry.
+  Creating a commit there creates the unborn branch above that base and leaves
+  the hidden branch unchanged.
 - `a w` creates a child of the selected commit from tracked changes, or a root
   commit for an unborn `HEAD`. A changed index wins; otherwise, tracked worktree
   changes are used. Untracked files never enter an implicit new commit and remain
diff --git a/gix-tix/src/app.rs b/gix-tix/src/app.rs
index 7bb9ea8973d..9feec33a278 100644
--- a/gix-tix/src/app.rs
+++ b/gix-tix/src/app.rs
@@ -2252,7 +2252,9 @@ impl App {
         let visible = self.reachable_from(view_tips);
         let hidden = self.reachable_from(hidden_tips);
         let visible: HashSet<_> = visible.difference(&hidden).copied().collect();
-        let boundary: HashSet<_> = if hidden_tips.is_empty() {
+        let boundary: HashSet<_> = if view_tips.is_empty() {
+            hidden_tips.iter().copied().collect()
+        } else if hidden_tips.is_empty() {
             HashSet::new()
         } else {
             visible
@@ -2794,7 +2796,10 @@ impl App {
             && !self.selected_is_segment()
             && self.deferred_history_state.unwrap_or(self.state) == State::Complete
             && match self.selected.and_then(|index| self.rows.get(index)) {
-                Some(row) => !self.hidden_rows.contains(&row.id) && !self.known_merge_descendants.contains(&row.id),
+                Some(row) => {
+                    (self.worktree_head_unborn || !self.hidden_rows.contains(&row.id))
+                        && !self.known_merge_descendants.contains(&row.id)
+                }
                 None => self.worktree_head_unborn,
             }
     }
@@ -2802,7 +2807,8 @@ impl App {
     pub(crate) fn set_new_commit_availability(&mut self, changes: Option<&Changes>) {
         let selected_is_head =
             self.selected.and_then(|index| self.rows.get(index)).map(|row| row.id) == self.worktree_head;
-        let selected_is_head = selected_is_head || (self.selected.is_none() && self.worktree_head_unborn);
+        let selected_is_head = selected_is_head
+            || self.worktree_head_unborn && self.selected.is_none_or(|index| self.is_row_hidden(index));
         match changes {
             Some(changes) if changes.paths.iter().any(|change| change.kind == ChangeKind::Unmerged) => {
                 self.new_commit_available = false;
@@ -4100,6 +4106,25 @@ mod tests {
         );
     }
 
+    #[test]
+    fn refresh_keeps_hidden_tips_as_the_unborn_view() {
+        let mut app = App::new(10);
+        app.extend_hidden_commits(vec![row(1)]);
+        complete(&mut app);
+
+        let rows = app
+            .start_refresh(vec![row_with_parents(2, &[1])].into(), &[], &[id(2)], false)
+            .expect("a hidden-only refresh computes lanes");
+        assert_eq!(
+            rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [id(2)],
+            "only the current hidden tip remains in the view"
+        );
+        let (rows, graph, time) = compute_lanes(rows);
+        app.finish_lane_computation(rows, graph, time);
+        assert!(app.is_row_hidden(0), "the fallback remains a hidden boundary");
+    }
+
     #[test]
     fn refresh_keeps_an_advanced_tip_on_its_existing_side() {
         let mut app = App::new(10);
@@ -4574,8 +4599,20 @@ mod tests {
 
         let mut unborn_with_history = App::new(10);
         unborn_with_history.set_worktree_head_unborn(true);
-        unborn_with_history.extend_commits(vec![row(1)]);
+        unborn_with_history.extend_hidden_commits(vec![row(1)]);
         complete(&mut unborn_with_history);
+        unborn_with_history.set_new_commit_availability(Some(&Changes {
+            has_tracked_changes: true,
+            ..Changes::default()
+        }));
+        assert_eq!(
+            unborn_with_history.update(Action::NewCommit),
+            vec![Effect::NewCommit {
+                parent: Some(id(1)),
+                empty: false,
+            }],
+            "the hidden tip can parent the unborn branch's first commit"
+        );
         assert!(
             !unborn_with_history.can_fork_commit(),
             "a fork requires an existing worktree HEAD even when another ref is selected"
diff --git a/gix-tix/src/edit/create.rs b/gix-tix/src/edit/create.rs
index b6b1890e122..29d79c50bc5 100644
--- a/gix-tix/src/edit/create.rs
+++ b/gix-tix/src/edit/create.rs
@@ -719,6 +719,37 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn creates_the_unborn_branch_above_an_existing_base() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = open(fixture.path())?;
+        let base = repository.rev_parse_single("main")?.detach();
+        let graph = crate::history::HistoryGraph::for_commits(&repository, &[base])?;
+        drop(repository);
+        assert!(
+            Command::new("git")
+                .arg("-C")
+                .arg(fixture.path())
+                .args(["symbolic-ref", "HEAD", "refs/heads/unborn"])
+                .status()?
+                .success()
+        );
+
+        let prepared = prepare_empty(open(fixture.path())?, Some(base))?;
+        let edited = prepared.document.replacen(b"what\n\nwhy", b"first\n\nreason", 1);
+        let new_id = apply(open(fixture.path())?, &graph, prepared, &edited)?;
+        let repository = open(fixture.path())?;
+
+        assert_eq!(repository.head_id()?.detach(), new_id);
+        assert_eq!(repository.find_reference("refs/heads/main")?.id().detach(), base);
+        assert_eq!(
+            repository.find_commit(new_id)?.parent_ids().next().map(gix::Id::detach),
+            Some(base),
+            "the first commit is based on the selected hidden tip"
+        );
+        Ok(())
+    }
+
     #[test]
     fn explicit_empty_commit_preserves_index_and_worktree_changes() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("create_commit.sh")?;
diff --git a/gix-tix/src/edit/rebase.rs b/gix-tix/src/edit/rebase.rs
index 5066579e217..ec22ba3bafd 100644
--- a/gix-tix/src/edit/rebase.rs
+++ b/gix-tix/src/edit/rebase.rs
@@ -382,7 +382,6 @@ impl PersistedConflict {
 
 struct Prepared {
     repo: gix::Repository,
-    root: Option<ObjectId>,
     reset_indices: HashSet<ObjectId>,
     reset_index_paths: Option<Vec<BString>>,
     skip_worktree_transitions: bool,
@@ -1322,7 +1321,6 @@ fn perform_inner(
     }
     let mut prepared = Prepared {
         repo,
-        root,
         reset_indices,
         reset_index_paths,
         skip_worktree_transitions,
@@ -1577,7 +1575,6 @@ pub(super) fn finish_review_with_progress(
     });
     let mut prepared = Prepared {
         repo,
-        root: Some(review),
         reset_indices: HashSet::new(),
         reset_index_paths: None,
         skip_worktree_transitions: false,
@@ -2007,7 +2004,6 @@ pub(crate) fn perform_plan_with_progress(
     });
     let mut prepared = Prepared {
         repo,
-        root: Some(plan.base),
         reset_indices: marked.then_some(plan.base).into_iter().collect(),
         reset_index_paths: None,
         skip_worktree_transitions: false,
@@ -2204,7 +2200,9 @@ impl Prepared {
                 transition.new,
             )?;
         }
-        let current_ref = self.repo.head()?.referent_name().map(ToOwned::to_owned);
+        let head = self.repo.head()?;
+        let unborn = head.is_unborn();
+        let current_ref = head.referent_name().map(ToOwned::to_owned);
         let mut deferred_ref_deletions = Vec::new();
         if let (Some(expected_refs), Some(current_ref)) = (&mut self.expected_refs, current_ref) {
             if expected_refs
@@ -2225,7 +2223,7 @@ impl Prepared {
         let updated_refs = update_refs(
             &self.repo,
             &self.rewritten,
-            self.root.is_none(),
+            unborn,
             self.selected,
             &self.committer,
             self.expected_refs.take(),
@@ -2969,7 +2967,7 @@ fn update_refs(
             edits.push(ref_edit(name.clone(), old, new));
             rollback.push(ref_edit(name, new, old));
         }
-    } else {
+    } else if !unborn {
         for reference in repo.references()?.all()? {
             let reference = match reference {
                 Ok(reference) => reference,
diff --git a/gix-tix/src/history.rs b/gix-tix/src/history.rs
index 97888af23ab..9943a7c6c10 100644
--- a/gix-tix/src/history.rs
+++ b/gix-tix/src/history.rs
@@ -634,6 +634,7 @@ impl HistoryGraph {
         authors: &SharedAuthors,
     ) -> Result<Refresh> {
         let refs = snapshot(repo, revisions, hidden_revisions, include_worktrees)?;
+        let hidden_only = refs.view_tips.is_empty() && !refs.hidden_tips.is_empty();
         let shallow: HashSet<_> = repo
             .shallow_commits()
             .context("could not read shallow commits")?
@@ -799,6 +800,9 @@ impl HistoryGraph {
             if stop {
                 continue;
             }
+            if hidden_only {
+                continue;
+            }
             for parent in parent_indices {
                 self.schedule_cached(
                     repo,
@@ -818,7 +822,11 @@ impl HistoryGraph {
             }
         }
         self.tracking = tracking;
-        self.set_current_view(&refs.view_tips);
+        self.set_current_view(if hidden_only {
+            &refs.hidden_tips
+        } else {
+            &refs.view_tips
+        });
         let decorations = decorations(repo, &refs.pins, &refs.worktrees)?;
         Ok(Refresh {
             refs,
@@ -1012,17 +1020,16 @@ pub(crate) fn load(
 ) -> Result<()> {
     let refs = snapshot(repo, revisions, hidden_revisions, include_worktrees)?;
     let tips = refs.view_tips;
-    if tips.is_empty() {
-        emit(Event::Decorations(decorations(repo, &refs.pins, &refs.worktrees)?));
-        emit(Event::VisibleComplete);
-        emit(Event::Complete(HistoryGraph::default()));
-        return Ok(());
-    }
     let hidden_tips = refs.hidden_tips;
 
     if !emit(Event::Decorations(decorations(repo, &refs.pins, &refs.worktrees)?)) {
         return Ok(());
     }
+    if tips.is_empty() && hidden_tips.is_empty() {
+        emit(Event::VisibleComplete);
+        emit(Event::Complete(HistoryGraph::default()));
+        return Ok(());
+    }
     let shallow: HashSet<_> = repo
         .shallow_commits()
         .context("could not read shallow commits")?
@@ -1033,6 +1040,33 @@ pub(crate) fn load(
         .commit_graph_if_enabled()
         .context("could not open commit-graph for history traversal")?;
     let mut graph = HistoryGraph::default();
+    if tips.is_empty() {
+        let mut rows = Vec::with_capacity(hidden_tips.len());
+        let mut attributions = Vec::new();
+        let mut authors = gix::features::threading::lock(authors);
+        let mut buf = Vec::new();
+        for &id in &hidden_tips {
+            if cancelled.load(Ordering::Relaxed) {
+                emit(Event::Cancelled);
+                return Ok(());
+            }
+            let index = graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, id, &mut buf)?;
+            if graph.commits[index.as_usize()].state & NODE_STORED != 0 {
+                continue;
+            }
+            rows.push(decode_commit(repo, id, &mut authors, &mut attributions)?);
+            graph.commits[index.as_usize()].state |= NODE_STORED;
+            graph.stored_order.push(index);
+        }
+        drop(authors);
+        if !rows.is_empty() && !emit(Event::HiddenCommits(LoadedCommits { rows, attributions })) {
+            return Ok(());
+        }
+        emit(Event::VisibleComplete);
+        graph.set_current_view(&hidden_tips);
+        emit(Event::Complete(graph));
+        return Ok(());
+    }
     let hidden = hidden_frontier(&mut graph, repo, commit_graph.as_ref(), &tips, &hidden_tips, &shallow)?;
     let local_refs = local_refs_by_target(repo)?;
     let mut tracking = HashMap::new();
@@ -1202,31 +1236,7 @@ pub(crate) fn load(
                 emit(Event::Cancelled);
                 return Ok(());
             }
-            let object = repo.find_commit(id).context("could not read connected hidden commit")?;
-            let parent_ids = object.parent_ids().map(gix::Id::detach).collect();
-            let Metadata {
-                committer_time,
-                author_time,
-                author,
-                attributions: row_attributions,
-                title,
-                has_agent_marker,
-                is_review,
-                signature,
-            } = decode_metadata(object.iter(), &mut authors, &mut attributions)?;
-            rows.push(Commit {
-                id,
-                parent_ids,
-                committer_time,
-                author_time,
-                author,
-                attributions: row_attributions,
-                title,
-                metadata_loaded: true,
-                has_agent_marker,
-                is_review,
-                signature,
-            });
+            rows.push(decode_commit(repo, id, &mut authors, &mut attributions)?);
             let index = graph.ensure_commit(repo, commit_graph.as_ref(), &shallow, id, &mut buf)?;
             if graph.commits[index.as_usize()].state & NODE_STORED == 0 {
                 graph.commits[index.as_usize()].state |= NODE_STORED;
@@ -1552,6 +1562,9 @@ pub(crate) fn referenced_refs(
     repo: &gix::Repository,
     revisions: &[OsString],
 ) -> Result<HashMap<BString, gix::refs::Target>> {
+    if revisions.is_empty() && repo.head()?.is_unborn() {
+        return Ok(HashMap::new());
+    }
     let implicit_head = OsString::from("HEAD");
     let revisions = if revisions.is_empty() {
         std::slice::from_ref(&implicit_head)
@@ -1610,6 +1623,39 @@ pub(crate) fn load_metadata(
     Ok((metadata, attributions))
 }
 
+fn decode_commit(
+    repo: &gix::Repository,
+    id: ObjectId,
+    authors: &mut Authors,
+    attributions: &mut Vec<Attribution>,
+) -> Result<Commit<BString>> {
+    let object = repo.find_commit(id).context("could not read commit")?;
+    let parent_ids = object.parent_ids().map(gix::Id::detach).collect();
+    let Metadata {
+        committer_time,
+        author_time,
+        author,
+        attributions: row_attributions,
+        title,
+        has_agent_marker,
+        is_review,
+        signature,
+    } = decode_metadata(object.iter(), authors, attributions)?;
+    Ok(Commit {
+        id,
+        parent_ids,
+        committer_time,
+        author_time,
+        author,
+        attributions: row_attributions,
+        title,
+        metadata_loaded: true,
+        has_agent_marker,
+        is_review,
+        signature,
+    })
+}
+
 fn decode_metadata<'a>(
     tokens: impl Iterator<Item = Result<Token<'a>, gix::objs::decode::Error>>,
     authors: &mut Authors,
@@ -2676,6 +2722,110 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn unborn_views_show_only_the_hidden_tips() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repo = crate::test_repository::open(fixture.path())?;
+        let main = repo.rev_parse_single("main")?.detach();
+        let topic = repo.rev_parse_single("topic")?.detach();
+        drop(repo);
+        assert!(
+            Command::new("git")
+                .current_dir(fixture.path())
+                .args(["symbolic-ref", "HEAD", "refs/heads/unborn"])
+                .status()?
+                .success(),
+            "the fixture enters an unborn branch"
+        );
+
+        for (hidden, expected) in [
+            (&["main"][..], HashSet::from([main])),
+            (&["main", "topic"][..], HashSet::from([main, topic])),
+        ] {
+            let events = loaded(fixture.path(), &[], hidden)?;
+            let visible: Vec<_> = events
+                .iter()
+                .filter_map(|event| match event {
+                    Event::Commits(commits) => Some(commits.rows.iter().map(|row| row.id)),
+                    _ => None,
+                })
+                .flatten()
+                .collect();
+            let boundaries: HashSet<_> = events
+                .iter()
+                .filter_map(|event| match event {
+                    Event::HiddenCommits(commits) => Some(commits.rows.iter().map(|row| row.id)),
+                    _ => None,
+                })
+                .flatten()
+                .collect();
+            let graph = events
+                .iter()
+                .find_map(|event| match event {
+                    Event::Complete(graph) => Some(graph),
+                    _ => None,
+                })
+                .expect("the hidden-only history completes");
+
+            assert!(visible.is_empty(), "hidden ancestry is not exposed as visible history");
+            assert_eq!(boundaries, expected, "each hidden tip is emitted as a boundary");
+            assert_eq!(
+                graph.stored_commit_ids().collect::<HashSet<_>>(),
+                expected,
+                "only hidden tips are retained as rows"
+            );
+        }
+        Ok(())
+    }
+
+    #[test]
+    fn hidden_only_refresh_stops_after_the_new_tip() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        assert!(
+            Command::new("git")
+                .current_dir(path)
+                .args(["symbolic-ref", "HEAD", "refs/heads/unborn"])
+                .status()?
+                .success()
+        );
+        let mut graph = loaded(path, &[], &["main"])?
+            .into_iter()
+            .find_map(|event| match event {
+                Event::Complete(graph) => Some(graph),
+                _ => None,
+            })
+            .expect("the hidden-only history completes");
+
+        for args in [
+            &["symbolic-ref", "HEAD", "refs/heads/main"][..],
+            &[
+                "-c",
+                "commit.gpgSign=false",
+                "commit",
+                "--allow-empty",
+                "-q",
+                "-m",
+                "new",
+            ][..],
+            &["symbolic-ref", "HEAD", "refs/heads/unborn"][..],
+        ] {
+            assert!(Command::new("git").current_dir(path).args(args).status()?.success());
+        }
+        let repo = crate::test_repository::open(path)?;
+        let new_tip = repo.rev_parse_single("main")?.detach();
+        let authors =
+            gix::features::threading::OwnShared::new(gix::features::threading::Mutable::new(Authors::default()));
+        let refresh = graph.refresh(&repo, &[], &["main".into()], false, &HashSet::new(), &authors)?;
+
+        assert_eq!(
+            refresh.commits.rows.iter().map(|row| row.id).collect::<Vec<_>>(),
+            [new_tip],
+            "refresh emits the advanced hidden tip without walking its ancestry"
+        );
+        Ok(())
+    }
+
     #[test]
     fn refresh_stops_at_the_persistent_graph() -> gix_testtools::Result {
         let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;

From 86e6a2b7688eee9d76d7862cb3a7f2d9fd33dc3e Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 19:44:02 +0200
Subject: [PATCH 281/282] perf(gix-tix): avoid status refreshes for unrelated
 refs

Keep cached worktree status when a reference event leaves the logical HEAD referent and target unchanged. Let the worktree watcher exclusively handle index events so they don't also trigger history work.
---
 gix-tix/src/lib.rs | 174 ++++++++++++++++++++++++++++++++++++++++++++-
 1 file changed, 172 insertions(+), 2 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index 37eb9088b05..c388353968a 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -86,6 +86,12 @@ struct ConflictHead {
     parents: Vec<gix::ObjectId>,
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct WorktreeStatusHead {
+    reference: Option<gix::refs::FullName>,
+    target: Option<gix::ObjectId>,
+}
+
 enum ExternalConflictResolution {
     Current,
     Changed,
@@ -227,10 +233,18 @@ fn notification_is_actionable(event: &notify::Event) -> bool {
 }
 
 fn reference_event_is_relevant(event: &notify::Event, git_dir: &Path, worktrees_dir: &Path) -> bool {
+    let common_dir = worktrees_dir.parent();
     notification_is_actionable(event)
         && (event.need_rescan()
             || event.paths.is_empty()
             || event.paths.iter().any(|path| {
+                let is_index = [Some(git_dir), common_dir]
+                    .into_iter()
+                    .flatten()
+                    .any(|git_dir| path == &git_dir.join("index") || path == &git_dir.join("index.lock"));
+                if is_index {
+                    return false;
+                }
                 if let Ok(relative) = path.strip_prefix(git_dir)
                     && (relative.components().count() <= 1 || relative.starts_with("refs"))
                 {
@@ -248,6 +262,17 @@ fn reference_event_is_relevant(event: &notify::Event, git_dir: &Path, worktrees_
             }))
 }
 
+fn reference_event_changes_status_configuration(event: &notify::Event, git_dir: &Path, worktrees_dir: &Path) -> bool {
+    event.need_rescan()
+        || event.paths.is_empty()
+        || event.paths.iter().any(|path| {
+            [Some(git_dir), worktrees_dir.parent()]
+                .into_iter()
+                .flatten()
+                .any(|dir| path == &dir.join("config") || path == &dir.join("config.worktree"))
+        })
+}
+
 fn reference_watch_set_may_change(event: &notify::Event, worktrees_dir: &Path) -> bool {
     event.need_rescan()
         || event.paths.iter().any(|path| {
@@ -915,6 +940,7 @@ fn event_loop(
         }
     };
     let mut ref_watch_set_changed = false;
+    let mut ref_status_config_changed = false;
     let (cancelled, receiver) = start_history(
         repository,
         &revisions,
@@ -942,6 +968,7 @@ fn event_loop(
     let mut commit_message = None;
     let mut tree_changes = TreeChangesCache::default();
     let mut worktree_changes = None;
+    let mut cached_status_head = None;
     let mut worktree_watcher: Option<WorktreeWatcher> = None;
     let mut worktree_refresh_deadline: Option<Instant> = None;
     let mut worktree_watch_set_changed = false;
@@ -988,6 +1015,7 @@ fn event_loop(
         &mut commit_message,
         &mut tree_changes,
         &mut worktree_changes,
+        &mut cached_status_head,
         &mut history_graph,
         &mut selection_relation,
         &mut line_diff_pool,
@@ -1028,6 +1056,7 @@ fn event_loop(
             worktree_watch_set_changed = false;
             filesystem_responses.cancel_pending_worktree("worktree-unavailable");
             worktree_changes = None;
+            cached_status_head = None;
             line_diff_pool = None;
             sync_line_diff_pool(
                 &mut line_diff_pool,
@@ -1046,6 +1075,7 @@ fn event_loop(
                 }
             };
             ref_watch_set_changed = false;
+            ref_status_config_changed = false;
             app.leave_attention("worktree removed; using the common repository without worktree changes");
             if history_graph.is_some() {
                 refresh_pending = true;
@@ -1128,6 +1158,11 @@ fn event_loop(
                         if watcher.event_is_relevant(&event) {
                             actionable += 1;
                             ref_watch_set_changed |= watcher.watch_set_may_change(&event);
+                            ref_status_config_changed |= reference_event_changes_status_configuration(
+                                &event,
+                                &watcher.git_dir,
+                                &watcher.worktrees_dir,
+                            );
                             filesystem_responses.observe_references(&event, &repository_path, &common_dir);
                             ref_refresh_deadline = Some(Instant::now() + REF_EVENT_IDLE);
                         }
@@ -1152,6 +1187,7 @@ fn event_loop(
             ref_watcher = None;
             ref_refresh_deadline = None;
             ref_watch_set_changed = false;
+            ref_status_config_changed = false;
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
         }
         if take_due(&mut ref_refresh_deadline, Instant::now()) {
@@ -1171,7 +1207,29 @@ fn event_loop(
             }
             let response_ids = filesystem_responses.references_due();
             refresh_pending = true;
-            let invalidated = invalidate_worktree_changes(&mut worktree_changes);
+            let status_config_changed = std::mem::take(&mut ref_status_config_changed);
+            if status_config_changed {
+                fill_repository.retain = false;
+                fill_repository.retained = None;
+            }
+            let head_changed = status_config_changed
+                || worktree_changes
+                    .as_ref()
+                    .is_some_and(|(marker, _)| *marker != usize::MAX)
+                    && match cached_status_head.as_ref() {
+                        Some(previous) => open_repository(&repository_path, repository_is_bare, false)
+                            .context("could not reopen repository to compare HEAD after a reference change")
+                            .and_then(|repository| worktree_status_head(&repository))
+                            .map_or_else(
+                                |err| {
+                                    tracing::warn!(error = %err, "could not compare HEAD after a reference change");
+                                    true
+                                },
+                                |current| current != *previous,
+                            ),
+                        None => true,
+                    };
+            let invalidated = head_changed && invalidate_worktree_changes(&mut worktree_changes);
             filesystem_responses.phase(&response_ids, "reference-worktree-cache-invalidation");
             if invalidated {
                 filesystem_responses.queue_frame(&response_ids, "reference-worktree-cache-invalidation");
@@ -1465,6 +1523,7 @@ fn event_loop(
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
+                &mut cached_status_head,
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
@@ -1541,6 +1600,7 @@ fn event_loop(
                 &mut commit_message,
                 &mut tree_changes,
                 &mut worktree_changes,
+                &mut cached_status_head,
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
@@ -3767,6 +3827,16 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
     })
 }
 
+fn worktree_status_head(repository: &gix::Repository) -> Result<WorktreeStatusHead> {
+    let mut head = repository.head().context("could not read HEAD")?;
+    let reference = head.referent_name().map(ToOwned::to_owned);
+    let target = head
+        .try_peel_to_id()
+        .context("could not peel HEAD")?
+        .map(gix::Id::detach);
+    Ok(WorktreeStatusHead { reference, target })
+}
+
 fn worktree_watch_directories(repository: &gix::Repository) -> Result<HashSet<PathBuf>> {
     let root = repository
         .workdir()
@@ -4128,6 +4198,7 @@ fn draw(
     commit_message: &mut Option<(gix::ObjectId, BString)>,
     tree_changes: &mut TreeChangesCache,
     worktree_changes: &mut Option<(usize, Changes)>,
+    status_head: &mut Option<WorktreeStatusHead>,
     history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
@@ -4244,6 +4315,7 @@ fn draw(
     if app.changes_mode.is_none() {
         tree_changes.clear();
         *worktree_changes = None;
+        *status_head = None;
     }
     if let Some(id) = relation_to_load
         && let Some(graph) = history_graph
@@ -4363,6 +4435,13 @@ fn draw(
                     app.set_worktree_conflicted(loaded.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
                     restore_change_selection(&mut app.worktree_changes, &loaded, worktree_selection);
                     *worktree_changes = Some((0, loaded));
+                    *status_head = match worktree_status_head(repository) {
+                        Ok(head) => Some(head),
+                        Err(err) => {
+                            tracing::warn!(error = %err, "could not remember HEAD for worktree status");
+                            None
+                        }
+                    };
                 }
                 Err(err) => {
                     tracing::warn!(error = %err, "could not load worktree changes");
@@ -6775,6 +6854,64 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn worktree_status_head_changes_only_with_head() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let repository = test_repository::open(fixture.path())?;
+        let baseline = worktree_status_head(&repository)?;
+        let main = repository.rev_parse_single("main")?.detach();
+        let topic = repository.rev_parse_single("topic")?.detach();
+        drop(repository);
+
+        let update_ref = |name: &str, target: gix::ObjectId| -> gix_testtools::Result {
+            let status = Command::new("git")
+                .current_dir(fixture.path())
+                .args(["update-ref", name, &target.to_string()])
+                .status()?;
+            assert!(status.success(), "git updates {name}");
+            Ok(())
+        };
+        update_ref("refs/heads/unrelated", topic)?;
+        assert_eq!(
+            worktree_status_head(&test_repository::open(fixture.path())?)?,
+            baseline,
+            "an unrelated ref does not affect worktree status"
+        );
+
+        update_ref("refs/heads/alias", main)?;
+        let status = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["symbolic-ref", "HEAD", "refs/heads/alias"])
+            .status()?;
+        assert!(status.success(), "git reattaches HEAD to the alias");
+        let alias = worktree_status_head(&test_repository::open(fixture.path())?)?;
+        assert_ne!(alias, baseline, "the symbolic referent is part of the status baseline");
+        assert_eq!(
+            alias.target, baseline.target,
+            "the alias initially names the same commit"
+        );
+
+        update_ref("refs/heads/alias", topic)?;
+        let moved = worktree_status_head(&test_repository::open(fixture.path())?)?;
+        assert_ne!(
+            moved.target, alias.target,
+            "moving the checked-out ref changes the baseline"
+        );
+
+        let status = Command::new("git")
+            .current_dir(fixture.path())
+            .args(["symbolic-ref", "HEAD", "refs/heads/unborn"])
+            .status()?;
+        assert!(status.success(), "git makes HEAD unborn");
+        let unborn = worktree_status_head(&test_repository::open(fixture.path())?)?;
+        assert_eq!(
+            unborn.reference.as_ref().map(gix::refs::FullName::as_bstr),
+            Some("refs/heads/unborn".into())
+        );
+        assert_eq!(unborn.target, None, "an unborn HEAD has no peeled target");
+        Ok(())
+    }
+
     #[test]
     fn caches_recent_tree_changes_by_commit_and_parent() {
         let id = |value| {
@@ -8485,11 +8622,44 @@ mod tests {
             &worktrees
         ));
         let current_linked = worktrees.join("current");
-        assert!(reference_event_is_relevant(
+        assert!(!reference_event_is_relevant(
             &modified(&current_linked.join("index")),
             &current_linked,
             &worktrees
         ));
+        assert!(!reference_event_is_relevant(
+            &modified(&git_dir.join("index")),
+            &current_linked,
+            &worktrees
+        ));
+        assert!(!reference_event_is_relevant(
+            &modified(&git_dir.join("index")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(reference_event_is_relevant(
+            &modified(&git_dir.join("refs/heads/other")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(reference_event_changes_status_configuration(
+            &modified(&git_dir.join("config")),
+            &git_dir,
+            &worktrees
+        ));
+        assert!(reference_event_changes_status_configuration(
+            &modified(&current_linked.join("config.worktree")),
+            &current_linked,
+            &worktrees
+        ));
+        assert!(
+            !reference_event_changes_status_configuration(
+                &modified(&git_dir.join("refs/heads/other")),
+                &git_dir,
+                &worktrees
+            ),
+            "unrelated refs don't invalidate worktree status through configuration"
+        );
         assert!(reference_event_is_relevant(
             &modified(&current_linked.join("refs/worktree/tix/pins/abcd")),
             &current_linked,

From d5c8f1d1e69e02f5fb36aba32559da328aace8b5 Mon Sep 17 00:00:00 2001
From: OpenAI Codex <codex@openai.com>
Date: Sat, 22 Aug 2026 19:48:52 +0200
Subject: [PATCH 282/282] perf(gix-tix): refresh worktree state incrementally

---
 gix-tix/src/lib.rs | 1094 ++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 993 insertions(+), 101 deletions(-)

diff --git a/gix-tix/src/lib.rs b/gix-tix/src/lib.rs
index c388353968a..c75c6416fa9 100644
--- a/gix-tix/src/lib.rs
+++ b/gix-tix/src/lib.rs
@@ -59,13 +59,15 @@ const FRAME_INTERVAL: Duration = Duration::from_nanos(16_666_667);
 const TODO_PROGRESS_DELAY: Duration = Duration::from_millis(300);
 const HISTORY_STATUS_DELAY: Duration = Duration::from_millis(500);
 const REPEAT_IDLE: Duration = Duration::from_millis(75);
-const WORKTREE_EVENT_IDLE: Duration = Duration::from_millis(75);
 const REF_EVENT_IDLE: Duration = Duration::from_millis(100);
 const IMMEDIATE_PAGER_EXIT: Duration = Duration::from_millis(250);
 const REF_EVENT_INTERVAL: Duration = Duration::from_millis(250);
 const WATCH_RETRY_INTERVAL: Duration = Duration::from_secs(5);
 const LINE_DIFF_POOL_IDLE: Duration = Duration::from_secs(10);
 const THEME_QUERY_TIMEOUT: Duration = Duration::from_millis(100);
+const WORKTREE_STATUS_CURRENT: usize = 0;
+const WORKTREE_STATUS_PARTIAL: usize = usize::MAX - 1;
+const WORKTREE_STATUS_FULL: usize = usize::MAX;
 
 struct FillRepository {
     path: PathBuf,
@@ -92,6 +94,12 @@ struct WorktreeStatusHead {
     target: Option<gix::ObjectId>,
 }
 
+#[derive(Default)]
+struct WorktreeStatusParts {
+    staged: bool,
+    scopes: HashSet<BString>,
+}
+
 enum ExternalConflictResolution {
     Current,
     Changed,
@@ -107,15 +115,102 @@ enum ConflictReconcileStatus {
 }
 
 struct WorktreeWatcher {
-    _watcher: RecommendedWatcher,
+    watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
     directories: HashSet<PathBuf>,
+    index_projection: Vec<IndexWatchEntry>,
     workdir: PathBuf,
     dot_git: PathBuf,
     git_dir: PathBuf,
     index: PathBuf,
 }
 
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+struct IndexWatchEntry {
+    path: BString,
+    mode: u32,
+    flags: u32,
+}
+
+#[derive(Default)]
+struct WorktreeWatchRefresh {
+    full: bool,
+    index: bool,
+    scopes: HashSet<PathBuf>,
+}
+
+impl WorktreeWatchRefresh {
+    fn add_scope(&mut self, scope: &Path, workdir: &Path) {
+        if scope == workdir {
+            self.full = true;
+            self.scopes.clear();
+        } else if !self.full && scope.starts_with(workdir) {
+            self.scopes.insert(scope.to_owned());
+        }
+    }
+
+    fn observe(&mut self, event: &notify::Event, workdir: &Path, index: &Path, directories: &HashSet<PathBuf>) {
+        if self.full {
+            return;
+        }
+        if event.need_rescan() || event.paths.is_empty() || matches!(event.kind, notify::EventKind::Any) {
+            self.full = true;
+            self.scopes.clear();
+            return;
+        }
+        for path in &event.paths {
+            if path == index {
+                self.index = true;
+            } else if path.file_name().is_some_and(|name| name == ".gitignore") {
+                if let Some(parent) = path.parent() {
+                    self.add_scope(parent, workdir);
+                } else {
+                    self.full = true;
+                    self.scopes.clear();
+                    return;
+                }
+            }
+        }
+        let is_directory = |path: &Path| {
+            directories.contains(path)
+                || std::fs::symlink_metadata(path).is_ok_and(|metadata| metadata.file_type().is_dir())
+        };
+        match event.kind {
+            notify::EventKind::Create(notify::event::CreateKind::Folder)
+            | notify::EventKind::Remove(notify::event::RemoveKind::Folder) => {
+                for path in &event.paths {
+                    self.add_scope(path, workdir);
+                }
+            }
+            notify::EventKind::Modify(notify::event::ModifyKind::Name(_))
+                if event.paths.iter().any(|path| is_directory(path)) =>
+            {
+                for path in &event.paths {
+                    if let Some(parent) = path.parent() {
+                        self.add_scope(parent, workdir);
+                    }
+                }
+            }
+            notify::EventKind::Create(notify::event::CreateKind::Any | notify::event::CreateKind::Other)
+            | notify::EventKind::Remove(notify::event::RemoveKind::Any | notify::event::RemoveKind::Other)
+            | notify::EventKind::Modify(notify::event::ModifyKind::Any) => {
+                for path in event.paths.iter().filter(|path| is_directory(path)) {
+                    self.add_scope(path, workdir);
+                }
+            }
+            notify::EventKind::Other => {
+                self.full = true;
+                self.scopes.clear();
+            }
+            _ => {}
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        !self.full && !self.index && self.scopes.is_empty()
+    }
+}
+
 struct RefWatcher {
     _watcher: RecommendedWatcher,
     events: mpsc::Receiver<notify::Result<notify::Event>>,
@@ -127,10 +222,6 @@ impl WorktreeWatcher {
     fn event_is_relevant(&self, event: &notify::Event) -> bool {
         worktree_event_is_relevant(event, &self.workdir, &self.dot_git, &self.git_dir, &self.index)
     }
-
-    fn watch_set_may_change(&self, event: &notify::Event) -> bool {
-        worktree_watch_set_may_change(event, &self.index, &self.directories)
-    }
 }
 
 impl RefWatcher {
@@ -187,34 +278,51 @@ fn worktree_event_is_relevant(
 ) -> bool {
     event.need_rescan()
         || (!matches!(event.kind, notify::EventKind::Access(_))
-            && event.paths.iter().any(|path| {
-                path == index || (path.starts_with(workdir) && !path.starts_with(dot_git) && !path.starts_with(git_dir))
-            }))
+            && (event.paths.is_empty()
+                || event.paths.iter().any(|path| {
+                    path == index
+                        || (path.starts_with(workdir) && !path.starts_with(dot_git) && !path.starts_with(git_dir))
+                })))
 }
 
-fn worktree_watch_set_may_change(event: &notify::Event, index: &Path, directories: &HashSet<PathBuf>) -> bool {
-    if event.need_rescan()
-        || event
-            .paths
-            .iter()
-            .any(|path| path == index || path.file_name().is_some_and(|name| name == ".gitignore"))
-    {
-        return true;
+fn worktree_status_event_scopes(
+    event: &notify::Event,
+    workdir: &Path,
+    dot_git: &Path,
+    git_dir: &Path,
+    index: &Path,
+) -> Option<Vec<BString>> {
+    if event.need_rescan() || event.paths.is_empty() || event.paths.iter().any(|path| path == index) {
+        return None;
     }
-    match event.kind {
-        notify::EventKind::Create(notify::event::CreateKind::Folder)
-        | notify::EventKind::Remove(notify::event::RemoveKind::Folder)
-        | notify::EventKind::Modify(notify::event::ModifyKind::Name(_)) => true,
-        notify::EventKind::Create(notify::event::CreateKind::Any | notify::event::CreateKind::Other)
-        | notify::EventKind::Any => event
-            .paths
-            .iter()
-            .any(|path| path.is_dir() || directories.contains(path)),
-        notify::EventKind::Remove(notify::event::RemoveKind::Any | notify::event::RemoveKind::Other) => {
-            event.paths.iter().any(|path| directories.contains(path))
+    let mut out = Vec::new();
+    for path in &event.paths {
+        if !path.starts_with(workdir) || path.starts_with(dot_git) || path.starts_with(git_dir) {
+            continue;
+        }
+        if path
+            .file_name()
+            .is_some_and(|name| name == ".gitattributes" || name == ".gitmodules")
+        {
+            return None;
+        }
+        let scope = if path.file_name().is_some_and(|name| name == ".gitignore") {
+            path.parent()?
+        } else {
+            path
+        };
+        let relative = scope.strip_prefix(workdir).ok()?;
+        if relative.as_os_str().is_empty()
+            || !relative
+                .components()
+                .all(|component| matches!(component, std::path::Component::Normal(_)))
+        {
+            return None;
         }
-        _ => false,
+        let relative = gix::path::try_into_bstr(relative).ok()?;
+        out.push(gix::path::to_unix_separators_on_windows(relative).into_owned());
     }
+    (!out.is_empty()).then_some(out)
 }
 
 fn notification_is_actionable(event: &notify::Event) -> bool {
@@ -969,9 +1077,12 @@ fn event_loop(
     let mut tree_changes = TreeChangesCache::default();
     let mut worktree_changes = None;
     let mut cached_status_head = None;
+    let mut worktree_status_parts = WorktreeStatusParts::default();
     let mut worktree_watcher: Option<WorktreeWatcher> = None;
     let mut worktree_refresh_deadline: Option<Instant> = None;
-    let mut worktree_watch_set_changed = false;
+    let mut worktree_watch_refresh = WorktreeWatchRefresh::default();
+    let mut queued_worktree_status_full = false;
+    let mut queued_worktree_status_scopes = HashSet::new();
     let mut selection_relation = None;
     let mut history_graph = None;
     let line_diff_parallelism = std::thread::available_parallelism().map_or(1, Into::into);
@@ -1016,6 +1127,7 @@ fn event_loop(
         &mut tree_changes,
         &mut worktree_changes,
         &mut cached_status_head,
+        &mut worktree_status_parts,
         &mut history_graph,
         &mut selection_relation,
         &mut line_diff_pool,
@@ -1053,10 +1165,13 @@ fn event_loop(
             app.set_worktree_branch(None);
             worktree_watcher = None;
             worktree_refresh_deadline = None;
-            worktree_watch_set_changed = false;
+            worktree_watch_refresh = WorktreeWatchRefresh::default();
+            queued_worktree_status_full = false;
+            queued_worktree_status_scopes.clear();
             filesystem_responses.cancel_pending_worktree("worktree-unavailable");
             worktree_changes = None;
             cached_status_head = None;
+            worktree_status_parts = WorktreeStatusParts::default();
             line_diff_pool = None;
             sync_line_diff_pool(
                 &mut line_diff_pool,
@@ -1085,6 +1200,7 @@ fn event_loop(
         }
         let mut conflict_refresh_due = false;
         let mut worktree_watch_error = None;
+        let mut worktree_events_drained = true;
         if let Some(watcher) = worktree_watcher.as_mut() {
             let mut received = 0;
             let mut relevant = 0;
@@ -1096,9 +1212,29 @@ fn event_loop(
                         rescans += usize::from(event.need_rescan());
                         if watcher.event_is_relevant(&event) {
                             relevant += 1;
-                            worktree_watch_set_changed |= watcher.watch_set_may_change(&event);
+                            worktree_watch_refresh.observe(
+                                &event,
+                                &watcher.workdir,
+                                &watcher.index,
+                                &watcher.directories,
+                            );
                             filesystem_responses.observe_worktree(&event, &watcher.workdir, &watcher.index);
-                            schedule_once(&mut worktree_refresh_deadline, Instant::now(), WORKTREE_EVENT_IDLE);
+                            if !queued_worktree_status_full {
+                                match worktree_status_event_scopes(
+                                    &event,
+                                    &watcher.workdir,
+                                    &watcher.dot_git,
+                                    &watcher.git_dir,
+                                    &watcher.index,
+                                ) {
+                                    Some(scopes) => queued_worktree_status_scopes.extend(scopes),
+                                    None => {
+                                        queued_worktree_status_full = true;
+                                        queued_worktree_status_scopes.clear();
+                                    }
+                                }
+                            }
+                            schedule_once(&mut worktree_refresh_deadline, Instant::now(), Duration::ZERO);
                         }
                     }
                     Ok(Err(err)) => {
@@ -1114,6 +1250,7 @@ fn event_loop(
                 }
                 tracing::debug!(received, relevant, rescans, "processed worktree event batch");
             }
+            worktree_events_drained = received < EVENT_BATCH_SIZE;
         }
         if let Some(err) = worktree_watch_error {
             tracing::warn!(error = %err, "worktree watcher failed");
@@ -1121,14 +1258,25 @@ fn event_loop(
             app.worktree_changes.error = Some(format!("worktree watch: {err}"));
             worktree_watcher = None;
             worktree_refresh_deadline = None;
-            worktree_watch_set_changed = false;
+            worktree_watch_refresh = WorktreeWatchRefresh::default();
+            queued_worktree_status_full = false;
+            queued_worktree_status_scopes.clear();
             schedule_once(&mut watcher_retry_deadline, Instant::now(), WATCH_RETRY_INTERVAL);
             dirty = true;
             urgent = true;
         }
-        if take_due(&mut worktree_refresh_deadline, Instant::now()) {
+        if worktree_events_drained && take_due(&mut worktree_refresh_deadline, Instant::now()) {
             conflict_refresh_due = true;
-            if std::mem::take(&mut worktree_watch_set_changed) {
+            let watch_refresh = std::mem::take(&mut worktree_watch_refresh);
+            let watch_result = worktree_watcher
+                .as_mut()
+                .filter(|_| !watch_refresh.is_empty())
+                .map(|watcher| reconcile_worktree_watcher(watcher, &repository_path, repository_is_bare, watch_refresh))
+                .transpose();
+            if let Err(err) = watch_result {
+                tracing::warn!(error = %err, "worktree watcher update failed");
+                queued_worktree_status_full = true;
+                queued_worktree_status_scopes.clear();
                 match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => worktree_watcher = Some(watcher),
                     Err(err) => {
@@ -1139,7 +1287,18 @@ fn event_loop(
                     }
                 }
             }
-            let invalidated = invalidate_worktree_changes(&mut worktree_changes);
+            let invalidated = if std::mem::take(&mut queued_worktree_status_full) {
+                queued_worktree_status_scopes.clear();
+                worktree_status_parts = WorktreeStatusParts::default();
+                invalidate_worktree_changes(&mut worktree_changes)
+            } else {
+                invalidate_worktree_status_parts(
+                    &mut worktree_changes,
+                    &mut worktree_status_parts,
+                    false,
+                    queued_worktree_status_scopes.drain(),
+                )
+            };
             filesystem_responses.worktree_due(invalidated);
             tracing::debug!(invalidated, "worktree event deadline elapsed");
             dirty = true;
@@ -1215,7 +1374,7 @@ fn event_loop(
             let head_changed = status_config_changed
                 || worktree_changes
                     .as_ref()
-                    .is_some_and(|(marker, _)| *marker != usize::MAX)
+                    .is_some_and(|(marker, _)| *marker != WORKTREE_STATUS_FULL)
                     && match cached_status_head.as_ref() {
                         Some(previous) => open_repository(&repository_path, repository_is_bare, false)
                             .context("could not reopen repository to compare HEAD after a reference change")
@@ -1229,7 +1388,18 @@ fn event_loop(
                             ),
                         None => true,
                     };
-            let invalidated = head_changed && invalidate_worktree_changes(&mut worktree_changes);
+            let invalidated = if status_config_changed {
+                worktree_status_parts = WorktreeStatusParts::default();
+                invalidate_worktree_changes(&mut worktree_changes)
+            } else {
+                head_changed
+                    && invalidate_worktree_status_parts(
+                        &mut worktree_changes,
+                        &mut worktree_status_parts,
+                        true,
+                        std::iter::empty(),
+                    )
+            };
             filesystem_responses.phase(&response_ids, "reference-worktree-cache-invalidation");
             if invalidated {
                 filesystem_responses.queue_frame(&response_ids, "reference-worktree-cache-invalidation");
@@ -1524,6 +1694,7 @@ fn event_loop(
                 &mut tree_changes,
                 &mut worktree_changes,
                 &mut cached_status_head,
+                &mut worktree_status_parts,
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
@@ -1601,6 +1772,7 @@ fn event_loop(
                 &mut tree_changes,
                 &mut worktree_changes,
                 &mut cached_status_head,
+                &mut worktree_status_parts,
                 &mut history_graph,
                 &mut selection_relation,
                 &mut line_diff_pool,
@@ -2277,7 +2449,10 @@ fn event_loop(
         let effects = app.update(action);
         if refreshes_worktree {
             invalidate_worktree_changes(&mut worktree_changes);
-            worktree_watch_set_changed = false;
+            worktree_watch_refresh = WorktreeWatchRefresh::default();
+            queued_worktree_status_full = false;
+            queued_worktree_status_scopes.clear();
+            worktree_refresh_deadline = None;
             match start_worktree_watcher(&repository_path, repository_is_bare) {
                 Ok(watcher) => worktree_watcher = Some(watcher),
                 Err(err) => {
@@ -2298,7 +2473,10 @@ fn event_loop(
             );
             if app.changes_mode == Some(ChangesMode::Both) {
                 invalidate_worktree_changes(&mut worktree_changes);
-                worktree_watch_set_changed = false;
+                worktree_watch_refresh = WorktreeWatchRefresh::default();
+                queued_worktree_status_full = false;
+                queued_worktree_status_scopes.clear();
+                worktree_refresh_deadline = None;
                 match start_worktree_watcher(&repository_path, repository_is_bare) {
                     Ok(watcher) => {
                         worktree_watcher = Some(watcher);
@@ -2320,7 +2498,9 @@ fn event_loop(
             } else if previous_changes_mode == Some(ChangesMode::Both) {
                 worktree_watcher = None;
                 worktree_refresh_deadline = None;
-                worktree_watch_set_changed = false;
+                worktree_watch_refresh = WorktreeWatchRefresh::default();
+                queued_worktree_status_full = false;
+                queued_worktree_status_scopes.clear();
                 filesystem_responses.cancel_pending_worktree("watcher-disabled");
             }
         }
@@ -3350,7 +3530,7 @@ fn event_loop(
                                     let tree = tree_changes.as_ref().map(|(_, changes)| changes);
                                     let worktree = worktree_changes
                                         .as_ref()
-                                        .filter(|(marker, _)| *marker != usize::MAX)
+                                        .filter(|(marker, _)| *marker == WORKTREE_STATUS_CURRENT)
                                         .map(|(_, changes)| changes);
                                     terminal
                                         .draw(|frame| {
@@ -3780,11 +3960,15 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
         .workdir()
         .context("cannot watch a bare repository")?
         .to_owned();
-    let index = repository.index_path();
+    let index_path = repository.index_path();
     let git_dir = repository.git_dir().to_owned();
     let dot_git = workdir.join(gix::discover::DOT_GIT_DIR);
     let dirwalk_started = Instant::now();
-    let directories = worktree_watch_directories(&repository)?;
+    let index = repository
+        .index_or_empty()
+        .context("could not open index for worktree watcher")?;
+    let mut directories = worktree_watch_directories_with_index(&repository, &index)?;
+    let index_projection = index_watch_projection(&index);
     let dirwalk_ms = dirwalk_started.elapsed().as_millis();
     let registration_started = Instant::now();
     let (sender, events) = mpsc::channel();
@@ -3792,7 +3976,8 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
         let _ = sender.send(event);
     })
     .context("could not initialize worktree watcher")?;
-    let index_parent = index.parent().context("index path has no parent")?;
+    let index_parent = index_path.parent().context("index path has no parent")?;
+    directories.insert(index_parent.to_owned());
     {
         let mut paths = watcher.paths_mut();
         for directory in &directories {
@@ -3800,16 +3985,11 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
                 .add(directory, RecursiveMode::NonRecursive)
                 .with_context(|| format!("could not watch worktree directory at {}", directory.display()))?;
         }
-        if !directories.contains(index_parent) {
-            paths
-                .add(index_parent, RecursiveMode::NonRecursive)
-                .with_context(|| format!("could not watch index at {}", index_parent.display()))?;
-        }
         paths.commit().context("could not apply worktree watches")?;
     }
     tracing::info!(
         workdir = %workdir.display(),
-        index = %index.display(),
+        index = %index_path.display(),
         directories = directories.len(),
         dirwalk_ms,
         registration_ms = registration_started.elapsed().as_millis(),
@@ -3817,13 +3997,14 @@ fn start_worktree_watcher(repository_path: &Path, bare: bool) -> Result<Worktree
         "watching worktree changes"
     );
     Ok(WorktreeWatcher {
-        _watcher: watcher,
+        watcher,
         events,
         directories,
+        index_projection,
         workdir,
         dot_git,
         git_dir,
-        index,
+        index: index_path,
     })
 }
 
@@ -3837,14 +4018,38 @@ fn worktree_status_head(repository: &gix::Repository) -> Result<WorktreeStatusHe
     Ok(WorktreeStatusHead { reference, target })
 }
 
+fn remember_worktree_status_head(
+    cached: &mut Option<WorktreeStatusHead>,
+    refreshes_staged: bool,
+    scanned: Result<WorktreeStatusHead>,
+) {
+    if refreshes_staged {
+        *cached = match scanned {
+            Ok(head) => Some(head),
+            Err(err) => {
+                tracing::warn!(error = %err, "could not remember HEAD for worktree status");
+                None
+            }
+        };
+    }
+}
+
+#[cfg(test)]
 fn worktree_watch_directories(repository: &gix::Repository) -> Result<HashSet<PathBuf>> {
+    let index = repository
+        .index_or_empty()
+        .context("could not open index for worktree watcher")?;
+    worktree_watch_directories_with_index(repository, &index)
+}
+
+fn worktree_watch_directories_with_index(
+    repository: &gix::Repository,
+    index: &gix::index::State,
+) -> Result<HashSet<PathBuf>> {
     let root = repository
         .workdir()
         .context("cannot walk a bare repository")?
         .to_owned();
-    let index = repository
-        .index_or_empty()
-        .context("could not open index for worktree watcher")?;
     let options = repository
         .dirwalk_options()
         .context("could not configure worktree directory walk")?;
@@ -3853,22 +4058,221 @@ fn worktree_watch_directories(repository: &gix::Repository) -> Result<HashSet<Pa
         paths: HashSet::from([root]),
     };
     repository
-        .dirwalk(&index, None::<&str>, &AtomicBool::default(), options, &mut directories)
+        .dirwalk(index, None::<&str>, &AtomicBool::default(), options, &mut directories)
         .context("could not enumerate worktree directories")?;
     Ok(directories.paths)
 }
 
+fn index_watch_projection(index: &gix::index::State) -> Vec<IndexWatchEntry> {
+    let mut out: Vec<_> = index
+        .entries()
+        .iter()
+        .map(|entry| IndexWatchEntry {
+            path: entry.path(index).to_owned(),
+            mode: entry.mode.bits(),
+            flags: entry.flags.bits(),
+        })
+        .collect();
+    out.sort_unstable();
+    out
+}
+
+fn changed_index_watch_scopes(
+    before: &[IndexWatchEntry],
+    after: &[IndexWatchEntry],
+    workdir: &Path,
+) -> HashSet<PathBuf> {
+    fn add_scope(entry: &IndexWatchEntry, workdir: &Path, out: &mut HashSet<PathBuf>) {
+        let path = entry.path.as_bstr();
+        let scope = path
+            .find_byte(b'/')
+            .map(|pos| &path[..pos])
+            .or_else(|| (entry.mode == gix::index::entry::Mode::DIR.bits()).then_some(path.as_ref()));
+        if let Some(scope) = scope {
+            out.insert(workdir.join(gix::path::from_bstr(scope)));
+        }
+    }
+
+    let mut out = HashSet::new();
+    let (mut left, mut right) = (0, 0);
+    while left < before.len() || right < after.len() {
+        match (before.get(left), after.get(right)) {
+            (Some(a), Some(b)) => match a.cmp(b) {
+                std::cmp::Ordering::Less => {
+                    add_scope(a, workdir, &mut out);
+                    left += 1;
+                }
+                std::cmp::Ordering::Greater => {
+                    add_scope(b, workdir, &mut out);
+                    right += 1;
+                }
+                std::cmp::Ordering::Equal => {
+                    left += 1;
+                    right += 1;
+                }
+            },
+            (Some(a), None) => {
+                add_scope(a, workdir, &mut out);
+                left += 1;
+            }
+            (None, Some(b)) => {
+                add_scope(b, workdir, &mut out);
+                right += 1;
+            }
+            (None, None) => break,
+        }
+    }
+    out
+}
+
+fn minimize_worktree_scopes(scopes: HashSet<PathBuf>) -> Vec<PathBuf> {
+    let mut scopes: Vec<_> = scopes.into_iter().collect();
+    scopes.sort_by(|a, b| {
+        a.components()
+            .count()
+            .cmp(&b.components().count())
+            .then_with(|| a.cmp(b))
+    });
+    let mut out: Vec<PathBuf> = Vec::new();
+    for scope in scopes {
+        if !out.iter().any(|parent| scope.starts_with(parent)) {
+            out.push(scope);
+        }
+    }
+    out
+}
+
+fn reconcile_worktree_watcher(
+    watcher: &mut WorktreeWatcher,
+    repository_path: &Path,
+    bare: bool,
+    mut refresh: WorktreeWatchRefresh,
+) -> Result<(usize, usize)> {
+    let repository = open_repository(repository_path, bare, false)
+        .context("could not reopen repository to update worktree watches")?;
+    let index = repository
+        .index_or_empty()
+        .context("could not open index to update worktree watches")?;
+    let next_projection = index_watch_projection(&index);
+    let update_projection = refresh.index || refresh.full;
+    if refresh.index {
+        refresh.scopes.extend(changed_index_watch_scopes(
+            &watcher.index_projection,
+            &next_projection,
+            &watcher.workdir,
+        ));
+    }
+    if !refresh.full && refresh.scopes.is_empty() {
+        if update_projection {
+            watcher.index_projection = next_projection;
+        }
+        return Ok((0, 0));
+    }
+
+    let all_desired = worktree_watch_directories_with_index(&repository, &index)?;
+    let scopes = minimize_worktree_scopes(refresh.scopes);
+    let mut desired = if refresh.full {
+        all_desired
+    } else {
+        watcher
+            .directories
+            .iter()
+            .filter(|path| !scopes.iter().any(|scope| path.starts_with(scope)))
+            .cloned()
+            .chain(
+                all_desired
+                    .into_iter()
+                    .filter(|path| scopes.iter().any(|scope| path.starts_with(scope))),
+            )
+            .collect()
+    };
+    desired.insert(watcher.index.parent().context("index path has no parent")?.to_owned());
+    let changed = update_worktree_watch_paths(watcher, desired)?;
+    if update_projection {
+        watcher.index_projection = next_projection;
+    }
+    Ok(changed)
+}
+
+fn update_worktree_watch_paths(watcher: &mut WorktreeWatcher, desired: HashSet<PathBuf>) -> Result<(usize, usize)> {
+    let mut remove: Vec<_> = watcher.directories.difference(&desired).cloned().collect();
+    let mut add: Vec<_> = desired.difference(&watcher.directories).cloned().collect();
+    if remove.is_empty() && add.is_empty() {
+        return Ok((0, 0));
+    }
+    remove.sort_by(|a, b| {
+        b.components()
+            .count()
+            .cmp(&a.components().count())
+            .then_with(|| a.cmp(b))
+    });
+    add.sort_by(|a, b| {
+        a.components()
+            .count()
+            .cmp(&b.components().count())
+            .then_with(|| a.cmp(b))
+    });
+    let removed = remove.len();
+    let added = add.len();
+    let mut first_error = None;
+    let mut paths = watcher.watcher.paths_mut();
+    for path in remove {
+        if let Err(err) = paths.remove(&path)
+            && !matches!(&err.kind, notify::ErrorKind::WatchNotFound)
+            && first_error.is_none()
+        {
+            first_error = Some(err);
+        }
+    }
+    for path in add {
+        if let Err(err) = paths.add(&path, RecursiveMode::NonRecursive)
+            && first_error.is_none()
+        {
+            first_error = Some(err);
+        }
+    }
+    if let Err(err) = paths.commit()
+        && first_error.is_none()
+    {
+        first_error = Some(err);
+    }
+    if let Some(err) = first_error {
+        return Err(err).context("could not update worktree watches");
+    }
+    tracing::debug!(removed, added, "updated worktree watches");
+    watcher.directories = desired;
+    Ok((removed, added))
+}
+
 fn invalidate_worktree_changes(changes: &mut Option<(usize, Changes)>) -> bool {
     if let Some((marker, _)) = changes {
-        if *marker == usize::MAX {
+        if *marker == WORKTREE_STATUS_FULL {
             return false;
         }
-        *marker = usize::MAX;
+        *marker = WORKTREE_STATUS_FULL;
         return true;
     }
     false
 }
 
+fn invalidate_worktree_status_parts(
+    changes: &mut Option<(usize, Changes)>,
+    parts: &mut WorktreeStatusParts,
+    staged: bool,
+    scopes: impl IntoIterator<Item = BString>,
+) -> bool {
+    let Some((marker, _)) = changes else {
+        return false;
+    };
+    if *marker == WORKTREE_STATUS_FULL {
+        return false;
+    }
+    parts.staged |= staged;
+    parts.scopes.extend(scopes);
+    *marker = WORKTREE_STATUS_PARTIAL;
+    true
+}
+
 fn leave_recorded_success(
     app: &mut App,
     repository_path: &Path,
@@ -4199,6 +4603,7 @@ fn draw(
     tree_changes: &mut TreeChangesCache,
     worktree_changes: &mut Option<(usize, Changes)>,
     status_head: &mut Option<WorktreeStatusHead>,
+    status_parts: &mut WorktreeStatusParts,
     history_graph: &mut Option<HistoryGraph>,
     selection_cache: &mut Option<SelectionRelationCache>,
     line_diff_pool: &mut Option<LineDiffPool>,
@@ -4297,7 +4702,7 @@ fn draw(
         && app.changes_mode == Some(ChangesMode::Both)
         && worktree_changes
             .as_ref()
-            .is_none_or(|(marker, _)| *marker == usize::MAX);
+            .is_none_or(|(marker, _)| *marker != WORKTREE_STATUS_CURRENT);
     let worktree_selection = worktree_changes_to_load
         .then(|| {
             remembered_change_selection(
@@ -4316,6 +4721,7 @@ fn draw(
         tree_changes.clear();
         *worktree_changes = None;
         *status_head = None;
+        *status_parts = WorktreeStatusParts::default();
     }
     if let Some(id) = relation_to_load
         && let Some(graph) = history_graph
@@ -4410,16 +4816,30 @@ fn draw(
         if worktree_changes_to_load {
             let started = Instant::now();
             repository.object_cache_size(OBJECT_CACHE_SIZE);
-            let loaded = load_worktree_changes(
-                repository,
-                line_diff_pool
-                    .as_mut()
-                    .context("line diff pool is missing while the changes pane is visible")?,
-            );
+            let line_diff_pool = line_diff_pool
+                .as_mut()
+                .context("line diff pool is missing while the changes pane is visible")?;
+            let partial = worktree_changes
+                .as_ref()
+                .is_some_and(|(marker, _)| *marker == WORKTREE_STATUS_PARTIAL);
+            let refreshes_staged = !partial || status_parts.staged;
+            let status_head_before = worktree_status_head(repository);
+            let loaded = if partial {
+                let mut updated = worktree_changes
+                    .as_ref()
+                    .map(|(_, changes)| changes.clone())
+                    .expect("partial status requires cached changes");
+                update_worktree_changes(repository, &mut updated, status_parts, line_diff_pool)
+                    .map(|full| (updated, refreshes_staged || full))
+            } else {
+                load_worktree_changes(repository, line_diff_pool).map(|loaded| (loaded, true))
+            };
             repository.object_cache_size(None);
+            *status_parts = WorktreeStatusParts::default();
             match loaded {
-                Ok(loaded) => {
+                Ok((loaded, refreshes_staged)) => {
                     tracing::debug!(
+                        partial,
                         path_count = loaded.paths.len(),
                         elapsed_ms = started.elapsed().as_millis(),
                         "loaded worktree changes"
@@ -4434,22 +4854,16 @@ fn draw(
                     }
                     app.set_worktree_conflicted(loaded.paths.iter().any(|change| change.kind == ChangeKind::Unmerged));
                     restore_change_selection(&mut app.worktree_changes, &loaded, worktree_selection);
-                    *worktree_changes = Some((0, loaded));
-                    *status_head = match worktree_status_head(repository) {
-                        Ok(head) => Some(head),
-                        Err(err) => {
-                            tracing::warn!(error = %err, "could not remember HEAD for worktree status");
-                            None
-                        }
-                    };
+                    *worktree_changes = Some((WORKTREE_STATUS_CURRENT, loaded));
+                    remember_worktree_status_head(status_head, refreshes_staged, status_head_before);
                 }
                 Err(err) => {
                     tracing::warn!(error = %err, "could not load worktree changes");
                     app.worktree_changes.error = Some(format!("status: {err:#}"));
                     if let Some((marker, _)) = worktree_changes.as_mut() {
-                        *marker = 0;
+                        *marker = WORKTREE_STATUS_CURRENT;
                     } else {
-                        *worktree_changes = Some((0, Changes::default()));
+                        *worktree_changes = Some((WORKTREE_STATUS_CURRENT, Changes::default()));
                     }
                 }
             }
@@ -4460,7 +4874,7 @@ fn draw(
     let tree_changes = tree_changes.as_ref().map(|(_, changes)| changes);
     let worktree_changes = worktree_changes
         .as_ref()
-        .filter(|(marker, _)| *marker != usize::MAX)
+        .filter(|(marker, _)| *marker == WORKTREE_STATUS_CURRENT)
         .map(|(_, changes)| changes);
     terminal
         .autoresize()
@@ -6180,8 +6594,77 @@ fn load_worktree_changes_without_lines(repository: &gix::Repository) -> Result<C
     })
 }
 
-fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
-    let mut out = load_worktree_changes_without_lines(repository)?;
+fn load_unstaged_changes_without_lines(repository: &gix::Repository, patterns: Vec<BString>) -> Result<Changes> {
+    let mut status = repository
+        .status(gix::progress::Discard)
+        .context("could not initialize incremental worktree status")?
+        .untracked_files(gix::status::UntrackedFiles::Files)
+        .into_index_worktree_iter(patterns)
+        .context("could not start incremental worktree status")?;
+    let mut unstaged = Vec::new();
+    let mut has_tracked_changes = false;
+    for item in status.by_ref() {
+        if let Some((path, diff, tracked)) = unstaged_change(
+            item.context("could not obtain incremental worktree status")?,
+            repository.object_hash(),
+        )? {
+            has_tracked_changes |= tracked;
+            unstaged.push((path, diff));
+        }
+    }
+    drop(status);
+    unstaged.sort_by(|(a, _), (b, _)| a.path.cmp(&b.path));
+    let (paths, diffs) = unstaged.into_iter().unzip();
+    Ok(Changes {
+        paths,
+        diffs,
+        has_tracked_changes,
+        ..Changes::default()
+    })
+}
+
+fn load_staged_changes_without_lines(repository: &gix::Repository) -> Result<Changes> {
+    let head_tree = repository
+        .head_tree_id_or_empty()
+        .context("could not resolve HEAD tree for staged status")?;
+    let index = repository
+        .index_or_empty()
+        .context("could not open index for staged status")?;
+    let mut pathspec = repository
+        .pathspec(
+            false,
+            None::<&str>,
+            false,
+            &index,
+            gix::worktree::stack::state::attributes::Source::IdMapping,
+        )
+        .context("could not initialize staged status pathspec")?;
+    let mut raw = Vec::new();
+    repository
+        .tree_index_status(
+            &head_tree,
+            &index,
+            Some(&mut pathspec),
+            gix::status::tree_index::TrackRenames::AsConfigured,
+            |change, _, _| {
+                raw.push(change.into_owned());
+                Ok::<_, std::convert::Infallible>(std::ops::ControlFlow::Continue(()))
+            },
+        )
+        .context("could not obtain staged status")?;
+    let mut staged = raw.into_iter().map(staged_change).collect::<Result<Vec<_>>>()?;
+    let has_tracked_changes = !staged.is_empty();
+    staged.sort_by(|(a, _), (b, _)| a.path.cmp(&b.path));
+    let (paths, diffs) = staged.into_iter().unzip();
+    Ok(Changes {
+        paths,
+        diffs,
+        has_tracked_changes,
+        ..Changes::default()
+    })
+}
+
+fn add_worktree_line_counts(mut out: Changes, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
     let diffs = std::mem::take(&mut out.diffs);
     for (path, (change, lines)) in out.paths.iter_mut().zip(line_diff_pool.line_counts(diffs)?) {
         path.lines = lines;
@@ -6194,6 +6677,113 @@ fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut Line
     Ok(out)
 }
 
+fn load_worktree_changes(repository: &gix::Repository, line_diff_pool: &mut LineDiffPool) -> Result<Changes> {
+    add_worktree_line_counts(load_worktree_changes_without_lines(repository)?, line_diff_pool)
+}
+
+fn literal_status_patterns(repository: &gix::Repository, scopes: &HashSet<BString>) -> Result<Option<Vec<BString>>> {
+    let defaults = repository
+        .pathspec_defaults()
+        .context("could not load pathspec defaults for incremental status")?;
+    if defaults.literal || defaults.signature.contains(gix::pathspec::MagicSignature::ICASE) {
+        return Ok(None);
+    }
+    Ok(Some(
+        scopes
+            .iter()
+            .map(|scope| {
+                gix::pathspec::Pattern::from_literal(scope.as_slice(), gix::pathspec::MagicSignature::TOP).to_bstring()
+            })
+            .collect(),
+    ))
+}
+
+fn path_is_in_status_scope(path: &BString, scope: &BString, ignore_case: bool) -> bool {
+    let Some(prefix) = path.get(..scope.len()) else {
+        return false;
+    };
+    let prefix_matches = if ignore_case {
+        prefix.eq_ignore_ascii_case(scope.as_slice())
+    } else {
+        prefix == scope.as_slice()
+    };
+    prefix_matches && (path.len() == scope.len() || path.get(scope.len()) == Some(&b'/'))
+}
+
+fn replace_cached_changes(
+    repository: &gix::Repository,
+    cached: &mut Changes,
+    replacement: Changes,
+    mut replace: impl FnMut(&PathChange) -> bool,
+) -> Result<()> {
+    let mut pairs: Vec<_> = std::mem::take(&mut cached.paths)
+        .into_iter()
+        .zip(std::mem::take(&mut cached.diffs))
+        .filter(|(change, _)| !replace(change))
+        .collect();
+    pairs.extend(replacement.paths.into_iter().zip(replacement.diffs));
+    pairs.sort_by(|(a, _), (b, _)| {
+        let rank = |group| match group {
+            ChangeGroup::Staged => 0,
+            ChangeGroup::Unstaged => 1,
+            ChangeGroup::Tree => 2,
+        };
+        rank(a.group).cmp(&rank(b.group)).then_with(|| a.path.cmp(&b.path))
+    });
+    (cached.paths, cached.diffs) = pairs.into_iter().unzip();
+    (cached.lines_added, cached.lines_removed) = cached
+        .paths
+        .iter()
+        .filter_map(|change| change.lines)
+        .fold((0, 0), |(added, removed), (a, r)| {
+            (added + u64::from(a), removed + u64::from(r))
+        });
+    let index = repository
+        .index_or_empty()
+        .context("could not open index after incremental status")?;
+    cached.has_tracked_changes = cached.paths.iter().any(|change| {
+        change.group == ChangeGroup::Staged
+            || change.group == ChangeGroup::Unstaged
+                && (index.entry_by_path(change.path.as_bstr()).is_some()
+                    || change
+                        .source
+                        .as_ref()
+                        .is_some_and(|source| index.entry_by_path(source.as_bstr()).is_some()))
+    });
+    Ok(())
+}
+
+fn update_worktree_changes(
+    repository: &gix::Repository,
+    cached: &mut Changes,
+    parts: &WorktreeStatusParts,
+    line_diff_pool: &mut LineDiffPool,
+) -> Result<bool> {
+    if parts.staged {
+        let staged = add_worktree_line_counts(load_staged_changes_without_lines(repository)?, line_diff_pool)?;
+        replace_cached_changes(repository, cached, staged, |change| change.group == ChangeGroup::Staged)?;
+    }
+    if !parts.scopes.is_empty() {
+        let Some(patterns) = literal_status_patterns(repository, &parts.scopes)? else {
+            *cached = load_worktree_changes(repository, line_diff_pool)?;
+            return Ok(true);
+        };
+        let unstaged = add_worktree_line_counts(
+            load_unstaged_changes_without_lines(repository, patterns)?,
+            line_diff_pool,
+        )?;
+        let ignore_case = repository.filesystem_options()?.ignore_case;
+        replace_cached_changes(repository, cached, unstaged, |change| {
+            change.group == ChangeGroup::Unstaged
+                && parts
+                    .scopes
+                    .iter()
+                    .any(|scope| path_is_in_status_scope(&change.path, scope, ignore_case))
+        })?;
+    }
+    Ok(false)
+}
+
 fn actor_bytes(author: &app::Author) -> Vec<u8> {
     let mut out = Vec::with_capacity(author.name.len() + author.email.len() + 3);
     out.extend_from_slice(author.name);
@@ -6890,6 +7480,15 @@ mod tests {
             alias.target, baseline.target,
             "the alias initially names the same commit"
         );
+        let mut cached = Some(baseline.clone());
+        remember_worktree_status_head(&mut cached, false, Ok(alias.clone()));
+        assert_eq!(
+            cached,
+            Some(baseline.clone()),
+            "an unstaged-only refresh preserves the HEAD baseline"
+        );
+        remember_worktree_status_head(&mut cached, true, Ok(alias.clone()));
+        assert_eq!(cached, Some(alias.clone()), "a staged refresh advances the baseline");
 
         update_ref("refs/heads/alias", topic)?;
         let moved = worktree_status_head(&test_repository::open(fixture.path())?)?;
@@ -7773,6 +8372,87 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn incremental_worktree_status_matches_a_full_refresh() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let path = fixture.path();
+        let repository = test_repository::open(path)?;
+        let mut pool = LineDiffPool::new(path, false, 2);
+        let mut cached = load_worktree_changes(&repository, &mut pool)?;
+
+        std::fs::write(path.join("main"), "changed in worktree\n")?;
+        std::fs::write(path.join("literal[*]"), "untracked\n")?;
+        let parts = WorktreeStatusParts {
+            staged: false,
+            scopes: HashSet::from([BString::from("main"), BString::from("literal[*]")]),
+        };
+        update_worktree_changes(&repository, &mut cached, &parts, &mut pool)?;
+        assert_eq!(
+            cached,
+            load_worktree_changes(&repository, &mut pool)?,
+            "path-limited changes equal a fresh status"
+        );
+
+        let status = Command::new("git").current_dir(path).args(["add", "main"]).status()?;
+        assert!(status.success(), "git stages the tracked change");
+        std::fs::write(path.join("main"), "changed in index\nand worktree\n")?;
+        let parts = WorktreeStatusParts {
+            staged: true,
+            scopes: HashSet::from([BString::from("main")]),
+        };
+        update_worktree_changes(&repository, &mut cached, &parts, &mut pool)?;
+        assert_eq!(
+            cached,
+            load_worktree_changes(&repository, &mut pool)?,
+            "combined staged and worktree replacement equals a fresh status"
+        );
+
+        std::fs::create_dir_all(path.join("nested"))?;
+        std::fs::write(path.join("nested/untracked"), "untracked\n")?;
+        let parts = WorktreeStatusParts {
+            staged: false,
+            scopes: HashSet::from([BString::from("nested")]),
+        };
+        update_worktree_changes(&repository, &mut cached, &parts, &mut pool)?;
+        assert_eq!(
+            cached,
+            load_worktree_changes(&repository, &mut pool)?,
+            "directory scopes include their descendants"
+        );
+
+        std::fs::write(path.join("nested/.gitignore"), "untracked\n")?;
+        update_worktree_changes(&repository, &mut cached, &parts, &mut pool)?;
+        assert_eq!(
+            cached,
+            load_worktree_changes(&repository, &mut pool)?,
+            "a scoped ignore change removes newly ignored cache rows"
+        );
+
+        let topic = repository.rev_parse_single("topic")?.detach();
+        drop(repository);
+        let status = Command::new("git")
+            .current_dir(path)
+            .args(["update-ref", "refs/heads/main", &topic.to_string()])
+            .status()?;
+        assert!(status.success(), "git moves the checked-out branch");
+        let repository = test_repository::open(path)?;
+        update_worktree_changes(
+            &repository,
+            &mut cached,
+            &WorktreeStatusParts {
+                staged: true,
+                scopes: HashSet::new(),
+            },
+            &mut pool,
+        )?;
+        assert_eq!(
+            cached,
+            load_worktree_changes(&repository, &mut pool)?,
+            "a staged-only replacement follows the new HEAD tree"
+        );
+        Ok(())
+    }
+
     #[test]
     fn streams_diff_bytes_and_accepts_early_pager_exit() -> gix_testtools::Result {
         let diff = BuiltInDiff::new(
@@ -8598,6 +9278,11 @@ mod tests {
         let rescan = notify::Event::new(notify::EventKind::Other).set_flag(Flag::Rescan);
         assert!(worktree_event_is_relevant(&rescan, workdir, &dot_git, &git_dir, &index));
         assert!(notification_is_actionable(&rescan));
+        let empty = notify::Event::new(notify::EventKind::Modify(ModifyKind::Any));
+        assert!(
+            worktree_event_is_relevant(&empty, workdir, &dot_git, &git_dir, &index),
+            "an event without paths conservatively refreshes all status"
+        );
 
         let worktrees = git_dir.join("worktrees");
         let linked = worktrees.join("linked");
@@ -8680,28 +9365,116 @@ mod tests {
         ));
 
         let directories = HashSet::from([workdir.join("src")]);
-        assert!(!worktree_watch_set_may_change(
-            &modified(&workdir.join("src/lib.rs")),
-            &index,
-            &directories
-        ));
-        assert!(worktree_watch_set_may_change(&modified(&index), &index, &directories));
-        assert!(worktree_watch_set_may_change(
-            &modified(&workdir.join(".gitignore")),
+        let mut watch_refresh = WorktreeWatchRefresh::default();
+        watch_refresh.observe(&modified(&workdir.join("src/lib.rs")), workdir, &index, &directories);
+        assert!(watch_refresh.is_empty(), "ordinary file changes don't touch watches");
+        let file_rename = notify::Event::new(notify::EventKind::Modify(ModifyKind::Name(RenameMode::Both)))
+            .add_path(workdir.join("src/old"))
+            .add_path(workdir.join("src/new"));
+        watch_refresh.observe(&file_rename, workdir, &index, &directories);
+        assert!(watch_refresh.is_empty(), "ordinary file renames don't touch watches");
+        watch_refresh.observe(&modified(&index), workdir, &index, &directories);
+        assert!(watch_refresh.index, "index changes request a projection comparison");
+
+        let mut watch_refresh = WorktreeWatchRefresh::default();
+        watch_refresh.observe(
+            &modified(&workdir.join("src/.gitignore")),
+            workdir,
             &index,
-            &directories
-        ));
+            &directories,
+        );
+        assert_eq!(watch_refresh.scopes, directories, "nested ignores rescan their parent");
+        watch_refresh.observe(&modified(&workdir.join(".gitignore")), workdir, &index, &directories);
+        assert!(watch_refresh.full, "a root ignore change affects the whole worktree");
+
         let create_directory =
             notify::Event::new(notify::EventKind::Create(CreateKind::Folder)).add_path(workdir.join("new"));
-        assert!(worktree_watch_set_may_change(&create_directory, &index, &directories));
         let remove_directory =
             notify::Event::new(notify::EventKind::Remove(RemoveKind::Folder)).add_path(workdir.join("src"));
-        assert!(worktree_watch_set_may_change(&remove_directory, &index, &directories));
-        assert!(worktree_watch_set_may_change(&rescan, &index, &directories));
+        let mut watch_refresh = WorktreeWatchRefresh::default();
+        watch_refresh.observe(&create_directory, workdir, &index, &directories);
+        watch_refresh.observe(&remove_directory, workdir, &index, &directories);
+        assert_eq!(
+            watch_refresh.scopes,
+            HashSet::from([workdir.join("new"), workdir.join("src")]),
+            "directory topology is reconciled by scope"
+        );
+        watch_refresh.observe(&rescan, workdir, &index, &directories);
+        assert!(watch_refresh.full, "rescans compare the complete desired watch set");
+
+        assert_eq!(
+            worktree_status_event_scopes(
+                &modified(&workdir.join("src/lib.rs")),
+                workdir,
+                &dot_git,
+                &git_dir,
+                &index
+            ),
+            Some(vec!["src/lib.rs".into()]),
+            "file events become literal repository-relative scopes"
+        );
+        assert_eq!(
+            worktree_status_event_scopes(
+                &modified(&workdir.join("src/.gitignore")),
+                workdir,
+                &dot_git,
+                &git_dir,
+                &index
+            ),
+            Some(vec!["src".into()]),
+            "ignore changes refresh their subtree"
+        );
+        assert!(
+            worktree_status_event_scopes(
+                &modified(&workdir.join("src/.gitattributes")),
+                workdir,
+                &dot_git,
+                &git_dir,
+                &index
+            )
+            .is_none(),
+            "attribute changes require full status, including staged line counts"
+        );
+        assert!(
+            worktree_status_event_scopes(
+                &modified(&workdir.join(".gitmodules")),
+                workdir,
+                &dot_git,
+                &git_dir,
+                &index
+            )
+            .is_none(),
+            "submodule configuration changes require full status"
+        );
+        assert!(
+            worktree_status_event_scopes(&modified(&index), workdir, &dot_git, &git_dir, &index).is_none(),
+            "index events require full status"
+        );
+        #[cfg(unix)]
+        {
+            use std::os::unix::ffi::OsStringExt;
+            let raw = OsString::from_vec(vec![b'n', 0xff]);
+            assert_eq!(
+                worktree_status_event_scopes(&modified(&workdir.join(raw)), workdir, &dot_git, &git_dir, &index),
+                Some(vec![BString::from(vec![b'n', 0xff])]),
+                "event paths remain byte-preserving"
+            );
+        }
 
-        let mut changes = Some((0, Changes::default()));
+        let mut changes = Some((WORKTREE_STATUS_CURRENT, Changes::default()));
+        let mut parts = WorktreeStatusParts::default();
+        assert!(invalidate_worktree_status_parts(
+            &mut changes,
+            &mut parts,
+            false,
+            [BString::from("src/lib.rs")]
+        ));
+        assert_eq!(
+            changes.as_ref().map(|(marker, _)| *marker),
+            Some(WORKTREE_STATUS_PARTIAL)
+        );
         assert!(invalidate_worktree_changes(&mut changes));
-        assert_eq!(changes.as_ref().map(|(marker, _)| *marker), Some(usize::MAX));
+        assert_eq!(changes.as_ref().map(|(marker, _)| *marker), Some(WORKTREE_STATUS_FULL));
         assert!(!invalidate_worktree_changes(&mut changes));
     }
 
@@ -8741,6 +9514,126 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn worktree_watches_apply_only_directory_set_differences() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let root = fixture.path();
+        let mut watcher = start_worktree_watcher(root, false)?;
+        let initial_projection = watcher.index_projection.clone();
+        std::fs::create_dir_all(root.join("new/nested"))?;
+        std::fs::create_dir_all(root.join("staged"))?;
+        std::fs::write(root.join("staged/tracked"), "new\n")?;
+        let status = Command::new("git")
+            .current_dir(root)
+            .args(["add", "staged/tracked"])
+            .status()?;
+        assert!(status.success(), "git adds a path outside the refresh scope");
+
+        let refresh = WorktreeWatchRefresh {
+            scopes: HashSet::from([root.join("new")]),
+            ..WorktreeWatchRefresh::default()
+        };
+        assert_eq!(
+            reconcile_worktree_watcher(&mut watcher, root, false, refresh)?,
+            (0, 2),
+            "the new subtree adds exactly its two directories"
+        );
+        assert!(watcher.directories.contains(&root.join("new/nested")));
+        assert_eq!(
+            watcher.index_projection, initial_projection,
+            "a scoped worktree refresh doesn't consume a pending index change"
+        );
+
+        assert_eq!(
+            reconcile_worktree_watcher(
+                &mut watcher,
+                root,
+                false,
+                WorktreeWatchRefresh {
+                    index: true,
+                    ..WorktreeWatchRefresh::default()
+                }
+            )?,
+            (0, 1),
+            "the later index refresh still adds its directory watch"
+        );
+        assert!(watcher.directories.contains(&root.join("staged")));
+
+        let refresh = WorktreeWatchRefresh {
+            scopes: HashSet::from([root.join("new")]),
+            ..WorktreeWatchRefresh::default()
+        };
+        assert_eq!(
+            reconcile_worktree_watcher(&mut watcher, root, false, refresh)?,
+            (0, 0),
+            "an unchanged desired set never mutates the watcher"
+        );
+
+        std::fs::write(root.join(".gitignore"), "new/\n")?;
+        assert_eq!(
+            reconcile_worktree_watcher(
+                &mut watcher,
+                root,
+                false,
+                WorktreeWatchRefresh {
+                    full: true,
+                    ..WorktreeWatchRefresh::default()
+                }
+            )?,
+            (2, 0),
+            "new ignore rules remove only the newly ignored subtree"
+        );
+        assert!(!watcher.directories.contains(&root.join("new")));
+        assert!(
+            watcher
+                .directories
+                .contains(watcher.index.parent().expect("index path has a parent")),
+            "the index directory always remains watched"
+        );
+        Ok(())
+    }
+
+    #[test]
+    fn index_watch_projection_ignores_content_but_tracks_topology() -> gix_testtools::Result {
+        let fixture = gix_testtools::scripted_fixture_writable("history.sh")?;
+        let root = fixture.path();
+        let repository = test_repository::open(root)?;
+        let index = repository.index_or_empty()?;
+        let before = index_watch_projection(&index);
+        drop(index);
+        drop(repository);
+
+        std::fs::write(root.join("main"), "new contents\n")?;
+        let status = Command::new("git").current_dir(root).args(["add", "main"]).status()?;
+        assert!(status.success(), "git stages new contents for an existing path");
+        let repository = test_repository::open(root)?;
+        let index = repository.index_or_empty()?;
+        let after_content = index_watch_projection(&index);
+        drop(index);
+        drop(repository);
+        assert_eq!(
+            before, after_content,
+            "object and stat changes do not affect directory watches"
+        );
+
+        std::fs::create_dir_all(root.join("new"))?;
+        std::fs::write(root.join("new/tracked"), "new\n")?;
+        let status = Command::new("git")
+            .current_dir(root)
+            .args(["add", "new/tracked"])
+            .status()?;
+        assert!(status.success(), "git adds a path in a new directory");
+        let repository = test_repository::open(root)?;
+        let index = repository.index_or_empty()?;
+        let after_path = index_watch_projection(&index);
+        assert_eq!(
+            changed_index_watch_scopes(&after_content, &after_path, root),
+            HashSet::from([root.join("new")]),
+            "index topology changes identify the affected top-level directory"
+        );
+        Ok(())
+    }
+
     #[test]
     fn starts_worktree_watching_for_the_combined_view() {
         assert!(worktree_watcher_needed(false, Some(ChangesMode::Both)));
@@ -8781,16 +9674,15 @@ mod tests {
     fn event_deadlines_coalesce_without_extending_and_can_be_retried() {
         let now = Instant::now();
         let mut deadline = None;
-        assert!(schedule_once(&mut deadline, now, WORKTREE_EVENT_IDLE));
+        assert!(schedule_once(&mut deadline, now, Duration::ZERO));
         let first = deadline;
         assert!(!schedule_once(
             &mut deadline,
             now + Duration::from_millis(50),
-            WORKTREE_EVENT_IDLE
+            Duration::ZERO
         ));
-        assert_eq!(deadline, first, "later events do not extend the debounce window");
-        assert!(!take_due(&mut deadline, now + Duration::from_millis(74)));
-        assert!(take_due(&mut deadline, now + WORKTREE_EVENT_IDLE));
+        assert_eq!(deadline, first, "queued worktree events share an immediate deadline");
+        assert!(take_due(&mut deadline, now));
         assert_eq!(deadline, None);
 
         assert!(schedule_once(&mut deadline, now, WATCH_RETRY_INTERVAL));