New Features

• toggle changes panes with Shift-C
  The ? e information shortcut cycles through Tree + Worktree, Tree only,
  and hidden, so hiding both panes requires several keys. Add Shift-C as a
  direct visibility toggle while preserving the existing cycle.

  One press hides either visible mode and returns focus to history. The next
  shows both panes, or Tree alone in a bare repository. Reuse the existing
  pane reset, diff-worker cleanup, and worktree-watcher refresh paths. Keep
  the toggle available during tree selection and rebase inspection, accept
  both terminal encodings of shifted letters, and advertise it in the
  information popup and keyboard documentation.

  The new regression failed before the binding existed. All 791 Tix tests
  pass with sha1, including focus, bare-repository, keyboard, and rendered
  help coverage. Run the full suite outside the sandbox for native filesystem
  notifications. Crate formatting and Clippy with -D warnings pass; Clippy
  retains the workspace's existing removed-lint warning.

• make initial commit messages configurable
  The new-commit editor always started with a what title and a why body,
  so users could not choose a reusable initial message for their workflow.

  Read literal multiline text from tix.new.message through Git's existing
  configuration resolution. Keep the original text when unset and allow an
  empty value to start with a blank message area. Shared preparation applies
  the setting to ordinary, empty, root, below-HEAD, CLI, and split creation.
  Use the configured message when detecting existing attribution trailers,
  and keep appended editor comments on separate lines.

  Show the source of tix.new.message alongside the existing tix.trailer.*
  editor hints so users can discover the key and the winning configuration.
  Share their formatter for configuration files, non-file overrides, and the
  built-in default. Show the hint for blank messages and messages that already
  include both attribution trailers.

  Explicit messages still override the initial text, and leaving the editor
  unchanged still creates nothing. Document the setting and global/local
  configuration examples beside the existing Tix configuration documentation.
  Extend isolated tests for defaults, multiline text, missing final newlines,
  blank messages, configuration sources, trailer suggestions, explicit inputs,
  and cancellation.

• include remote-tracking branches in the ref-tree
  The interactive ref-tree previously expanded the loaded history only with
  worktree tips. A remote-tracking branch outside that history could therefore
  be absent even though its reference existed and tix ref-tree displayed it.

  Expand the overview's cached graph with commit tips under refs/remotes/
  when entering it and whenever references refresh while it remains open.
  Reuse the graph's extra expansion inputs so ordinary history, hidden
  boundaries, and editing scope remain unchanged. Ignore stale symbolic
  references and non-commit targets using the existing reference iteration
  and peeling behavior.

  Cover remote branches from multiple remotes, moved tips, optional invalid
  references, rendered labels, and preserved history scope in a regression
  test. Keep the behavior documented in spec.md.

• collapse untracked directories in worktree changes
  Large untracked build trees expanded into individual worktree rows and file
  diffs. Use UntrackedFiles::Collapsed for the display so directories such as
  target/ occupy one added row without reading every file for line counts.

  Refresh untracked child events from their top-level scope so cached directory
  rows match a full status, including newly created and removed directories.
  Keep precise scopes for tracked files and explicit file enumeration for
  commit creation, whole-commit amend, and split so directory contents are retained.

  Represent directory diffs as unavailable. Discard validates the collapsed row
  and uses Git's existing literal-path cleanup, preserving ignored contents.
  Single-path amend requires staging the directory's files first; hide that
  action for directory rows and reject it before changing repository state.

  Update spec.md and cover Git-compatible collapsing, incremental refresh,
  directory actions, and retained commit contents. All 759 library tests pass,
  along with binary and documentation test targets, crate formatting, and
  Clippy for all targets with sha1. Tests use GIX_TEST_IGNORE_ARCHIVES=1;
  the native macOS reference-watcher test runs outside the sandbox.

• create commits below HEAD without changing worktree files
  Local edits sometimes belong before the current commit. Creating a child and
  moving it afterward requires extra history operations and can encounter a
  conflict only after the new commit has already been published.

  Add a Shift-W (neW-below) using the usual staged-first, tracked-worktree
  fallback. Prepare the local patch against HEAD's parent and replay HEAD above
  it entirely in memory, requiring the combined tree to match the selected
  candidate. Conflicts and editor cancellation leave the checkout unchanged.
  Keep HEAD's identity and notes on the rewritten upper commit and select the
  new lower commit, leaving siblings untouched and descendants lazily rebased.

  Consume the selected changes through the active index without checking out
  worktree files. Other affected worktrees retain their normal checkout safety
  and staged changes. Support ordinary commits and roots, reject unfinished
  HEAD or immediate parents, and preserve older pending ancestry.

  The Linux test-fast jobs passed their tests but failed the generated-archive
  cleanliness check because create_below.tar had not been committed. Include the
  archive produced by the existing fixture helper. Regenerated it from a fresh
  cache and validated all seven new_below tests.

  The full CI job also requires fixture scripts with a shebang to be executable.
  Track create_below.sh as mode 100755; the repository mode check passes with
  this correction staged.

• mark finished reviews as refackiewed
  Finishing a review should record the approval that the operation represents.
  Automatically add the sparkle enrichment to the resulting review commit's
  current patch, including an empty patch. Target that commit even when the
  recorded return checkout selects one of its descendants.

  Prepare approval alongside review completion so history, review resources,
  and enrichment publish in the same ref/worktree transaction. Cancelling a
  suspended finish publishes no approval; accepting a conflicting return
  checkout still approves the completed review. Finalize its replay markers
  and patch identity before preparing the enrichment.

• browse commands while holding a prefix key
  The prefix popups expose shortcuts but require knowing what a verb does before
  running it. Make a, v, n, and ? useful for exploration: a 300 ms hold
  selects the first displayed command and shows contextual help. Navigate the
  wrapped popup with hjkl or arrows, release the prefix or press Enter to run
  the selection once, and press Escape to cancel. Taps and fast shortcuts retain
  their existing behavior; terminals without key-release reporting keep toggles.

  Reuse the command catalog, actual popup geometry, and normal action validation.
  Cancel browsing when focus, input ownership, or the visible command changes.
  Handle shifted question-mark releases and native Windows repeated key-downs,
  read queued taps before promoting a hold, and clear held keys before handing
  input to editors or diff viewers. Keep contextual help separate from notices.

• accept explicit messages for enrichment notes
  Agents currently have to configure a shell editor just to copy a file into a
  Tix note. Let both tix enrich commit note and tix enrich commit git-note
  accept repeated -m/--message paragraphs and -f/--file, including - for
  standard input, using the same input reader as tix reword and tix new.
  This supports tix enrich commit note "$fixup_change" --file "$note_file"
  without editor configuration.

  Keep the editor as the default when no explicit source is provided. Both
  paths use the existing note cleanup, preserve comment-looking lines and
  non-UTF-8 bytes, clear empty notes, and leave identical notes and undo history
  alone. Preserve other enrichments and the configured ordinary Git notes ref.
  Message and file options are mutually exclusive; note commands do not expose
  commit-author options.

  Document the inputs in spec.md and cover option parsing, replacement,
  clearing, no-op behavior, change-ID targeting, file errors, and both note
  namespaces. Validation in an isolated source snapshot: all 67 command tests,
  crate Clippy, workspace formatting, and the SHA-1 binary build pass. A CLI
  smoke test also verifies stdin input and clearing in an independent temporary
  repository with the editor disabled.

• transplant merge trees and freeze copied AutoMerges
  Allow tree selections rooted at ordinary single-parent commits to include
  ordinary merges and finalized AutoMerges. Follow every eligible
  path to each selected endpoint, retain ordered parent slots and fixed
  outside-selection parents, and reconnect excluded descendants independently
  along each moved parent edge. Use the shared merge replay to preserve manual
  resolutions and merge-only changes across Copy/Move, Fork/Insert, and Above/Below
  placements.

  Freeze AutoMerges only when copying, leaving the original occurrences subscribed
  to their inputs. Move keeps AutoMerges live and follows their subscriptions as
  input refs move, using the same maintenance as ordinary rebases. Explain the
  distinction in the mode prompt and CLI help. Require valid, final metadata with
  no muted inputs, replace the copied subject with ordinary merge prose, and
  preserve the original line ending and all body bytes. There is no standalone
  freeze command, action, editor, or shortcut.

  Keep frozen copies distinct from live picks of the same source through early
  conflicts, saved continuation, notes, change identity, and undo. Finalize
  metadata-only freezing when parent IDs are unchanged. Keep selection roots
  single-parent and reject Below at merge destinations, including pending merges
  whose destination parent slots deduplicate to one Git parent. Cache only the
  detached metadata needed to make those UI decisions.

  When live maintenance collapses a moved AutoMerge after an earlier conflict,
  continue through its surviving result once. Remap refs, checkout, selection, and
  eager steps to that result, including unchanged or advanced external inputs,
  instead of saving duplicate picks or stale merge parent slots. Consuming a
  continuation releases its complete group of retained sources, including
  collapsed external inputs omitted from the remaining todo commands.

• preserve ordinary merges during rebase
  Replay each changed merge parent against the recorded merge tree, then combine
  its independent candidate with the accumulated result. This preserves manual
  resolutions and merge-only edits, handles common updates once, and exposes
  contradictory parent changes as conflicts instead of silently overwriting them.

  Carry ordered parent slots through plans and the version-3 rebase todo, with
  explicit merge commands for ordinary merges. Continue maintaining live
  AutoMerges through their existing recipes. Preserve lazy replay and the fast
  path for unchanged corresponding parent content. Fixed recorded parents may
  remain pending; rewritten parent IDs must be final before replay completes.

  Retain interrupted merge checkpoints and saved continuation sources through
  private transactional refs. Resume both conflict phases through Tix amend,
  external Git amend, and todo continuation; finalize signatures and patch
  identity only after all stages finish. Keep resources across restart and Git
  GC, distinguish overlapping continuations, and include publication and cleanup
  in rollback and undo without retaining repositories while idle.

  Time travel finishes pending side histories beneath finalized ordinary merges
  and their descendants, and refreshes every required AutoMerge input in one
  transaction. Share the required-ancestry boundary checks with replay so reviews,
  hidden history, shallow boundaries, and collapse onto fixed hidden inputs remain
  untouched.

• add optional auto-stashing to time travel
  Travelling while a checkout contains unfinished work currently carries those
  changes to the destination or refuses the checkout when they overlap. Allow
  leaving the work behind so it can be restored with its original staging when
  returning to the departure commit.

  Use bare 2 to stash and travel in the TUI, retain @ and Shift-2 for travel
  with the worktree, and add opt-in tix travel --stash. Reuse commit-associated
  stashes and retain automatic review-tree stashing at review boundaries.

  Defer saving until replay preparation succeeds or a conflict is accepted, then
  save before publishing changes to checked-out commits. Preserve stash
  associations through rewrites, restore departures after failed travel, and
  restore local work before waiting on a later conflict. Keep recovery state when
  restoration cannot complete and keep consumed stash references out of undo
  records.

  Update spec.md, CLI and TUI regressions, and stash/replay/rollback coverage.
  Validate with the complete SHA-1 gix-tix test suite, crate Clippy, and formatting
  checks. Native filesystem-watcher coverage runs outside the macOS sandbox.

• transplant selected commit trees
  Replace the separate interactive copy-, move-, and stack-insert actions with
  one tree selection workflow. Space fixes the inclusive root and adds paths;
  Shift-Space or the palette selects its eligible subtree. Remembered leaf
  endpoints allow partial branches, with persistent source, preview, and
  destination markers through Copy/Move, Fork/Insert, placement, and confirmation.

  Share the planner with tix transplant and bracketed paste. Remove the old
  copy-insert CLI command and fresh-fork editor action while retaining paste's
  checkout behavior and ordinary new/new-empty commits. Moves reconnect excluded
  descendants around the complete selection; insertion below a destination changes
  only that edge. Hidden boundaries, conflict placeholders, and unsupported merges
  remain barriers.

  Keep logical HEAD independent from the transplanted result selected by the UI
  and CLI. Advance applicable destination-tip refs, pin unreferenced result leaves,
  and eagerly replay selected commits and required pending destination ancestry.
  Preserve ordinary lazy replay, notes, enrichments, signing, and undo behavior.

  Keep idle selection state detached and cache candidate paths and membership.
  Use linear descendant traversal, revalidate references before applying, and run
  loading, planning, and replay in the existing progress worker. Escape aborts the
  whole flow and held confirmation keys cannot skip stages.

  Persist eager replay, result selection, and unaffected checkout identity through
  edited conflict continuations using produced commit IDs. Use the resolved index
  as the current worktree baseline when completing a conflict, and keep the plan's
  base outside rewritten scope so linked-worktree staging survives.

• pin detached worktrees from the ref-tree
  The reference tree listed detached worktrees at their physical HEADs, but
  Enter and p ignored those labels. Experiments discovered in the overview
  could not be retained in the current worktree's history through that action.

  Include foreign detached worktrees in the existing reference-pin action.
  Worktree snapshots retain their qualified physical HEAD reference separately
  from the displayed or remembered branch. Fresh discovery matches the selected
  commit, then the existing symbolic pin, undo, and history-refresh paths handle
  the action. Pins follow later commits and branch checkouts outside Tix.

  Main and linked worktrees retain distinct identities, including linked
  worktrees named main or sharing the same commit. Repeated pinning reuses
  each target. Existing attached-branch and current-detached-marker behavior
  is unchanged, and stale selections cannot pin a worktree that moved away.

  Cover keyboard dispatch, physical versus remembered HEAD, source pin privacy,
  external changes, pin reuse, and qualified identities. Update the behavioral
  specification with the new reference-tree action.

• explain and group AutoMerge input symbols
  AutoMerge titles could leave conflict markers visually detached from their
  inputs, especially when several pins appeared as identical symbols. Group each
  status with its input label, such as [✔️ A] [💥 📌] [✔️ 📌], and generate an
  ordered bullet list explaining every contribution in the commit body.

  The legend names full references and change IDs, including each pin's identity
  and symbolic target. Muted inputs explain that conflicts or pending replay
  exclude their entire contribution. Stable identities and the existing reference
  snapshots avoid message churn after input rewords and add no display-time reads.

  Eager rebuilds replace the generated legend while preserving other body text;
  lazy rebuilds retain their message until replay. Keep unchanged remerges
  idempotent and preserve legacy custom prose that uses the same section heading.

  Update the behavioral specification and cover grouped conflict symbols, real
  worktree HEAD pins, converged pin targets, full change identities, body
  preservation, and legend updates when inputs change or disappear.

• highlight autosquash markers in history
  Pending fixup!, squash!, and amend! commits will be folded during
  explicit rebases, but their titles previously looked like ordinary text.
  Show distinct bold, underlined light-magenta symbols before the target
  title so these commits stand out beyond conventional commit types.

  Reuse the rebase marker parser, including nested-prefix handling, and
  retain conventional formatting and Markdown within the target. Keep
  badges when history titles are shortened and preserve existing HEAD,
  selection, and hidden-boundary styling. Plain output and message panes
  retain the original titles.

• autosquash marked commits during explicit rebases
  Explicit history rebases previously left Git fixup!, squash!, and
  amend! commits as ordinary picks. Manually squashing a correction also
  retained its commentary, so fixups could not preserve or replace the
  target message.

  Recognize markers during initial CLI and TUI todo preparation, using
  Git subject/name/prefix matching and linked fold ordering within editable
  first-parent ancestry. Preserve intervening commits, fork topology, tip
  references, and checkout when moving corrections beside their targets.
  Generated actions remain editable, and accepting an unchanged autosquash
  todo applies it without changing implicit edit or travel replays.

  Carry append, discard, and replace modes through replay and continuation.
  Keep Tix squash messages and authorship conventions, support fixup and
  fixup -C, and preserve target identity and notes. Remove consumed review
  resources even when a fold conflicts, and omit those deleted resources
  from continuation expectations.

  Document the behavior and intentional Git differences in spec.md and
  todo help. Add Git-oracle, matching, ordering, topology, message, identity,
  and conflict-continuation regressions using the existing fixtures.

• track refackiewed patches with stable patch IDs
  Tree-based review marks disappear when an ancestor changes unrelated content.
  Attach explicit refactor/review approval to a version of a Tix change's patch,
  so the same edits retain their approval across rewording and replay even when
  context, line numbers, or hunk grouping change.

  Store a versioned patch-id commit header with a ghij-encoded fingerprint
  and its base/result tree witnesses. Hash raw changed paths, modes, and bytes
  with a fixed Histogram diff; preserve whitespace and newline distinctions.
  Reuse matching tree witnesses or changed-leaf records before reading blobs.
  Lazy rewrites keep stale IDs without computing patches. Conflict placeholders
  remain unavailable until explicit resolution, including when retained as
  muted AutoMerge inputs.

  Store refackiewed notes per change ID and patch version under the worktree's
  refs/worktree/tix/enrich-patch. Add n r and
  tix enrich patch refackiewed [--clear] [REVSPEC], and display ✨ alongside
  the existing enrichments in the TUI, show, and rebase todos. Legacy marking
  publishes its header, approval, and descendant ref rewrites atomically with
  one undo operation, preserving staging and worktree bytes. Existing identities
  need only a notes update. Keep tree checks independent.

  Browsing reads existing metadata only. Explicit fingerprinting uses the
  existing mutation worker and progress display. Preserve unchanged AutoMerge
  header order so no-op remerges retain commit IDs, and seed identities on new
  AutoMerges even when their first-parent delta is empty. Document the identity,
  eligibility, lifecycle, and performance rules in spec.md and README.md.

• toggle hidden history directly with Shift-H
  Showing configured hidden ancestry required the v h sequence or the
  command menu. Route Shift-H through the existing hidden-history action
  from history and both changes panes, including with a shortcut group open.
  Ordinary h and Shift-Left retain horizontal navigation; modal pickers keep
  consuming shortcut letters as input.

  Document the direct hidden-history and push shortcuts in ? help and a
  README keyboard section linked to the full specification. Embed the capital
  shortcut letters in the displayed verbs, following the existing action style.
  Cover terminal key encodings, both toggle directions, focused panes, prefix
  groups, command-menu input, and rendered help. All 612 Tix tests pass.

• create detached worktrees with source pins
  Spinning off an experiment previously required a local branch. Add
  tix wt switch --detach [COMMIT] (-d) to create a linked worktree at
  the current physical HEAD or a supplied commit revision. Keep the
  existing --path override and shell handoff, and choose numbered sibling
  paths when multiple experiments start at the same commit.

  When the source worktree already has valid Tix pins, create an ordinary
  symbolic pin there targeting worktrees/<id>/HEAD. Reuse the shared pin
  helper so external commits and checkouts stay visible in the source's
  history. The source pin is the entire parent/offspring relationship; the
  new worktree starts unpinned and no branch is created.

  Document the command and cover creation, protected destinations, invalid
  and unborn targets, physical versus remembered HEAD, and pin privacy and
  following from both main and linked source worktrees. Validate with all
  611 Tix tests, scoped Clippy, formatting, and CLI smoke checks in SHA-1 and
  SHA-256 repositories, including shell handoff and bare-repository creation.

• discard selected worktree changes
  Worktree paths could be amended, but discarding an unwanted edit required
  leaving tix. Add Actions discard to the command picker and reuse a d for
  the focused Worktree path. History keeps forget. Share action visibility
  between the picker, popup, and footer so discard also works when the selected
  history entry cannot be amended.

  Use Git with literal pathspecs to restore unstaged edits from the index and
  reset staged or conflicted paths in both the index and worktree to HEAD.
  Remove untracked and intent-to-add files, restore rename sources, and support
  an unborn HEAD. Revalidate the selected change before acting, reject
  unsupported submodules, and preserve unrelated paths and history. Close the
  actions group after discard so a repeated key cannot discard the next path.

  Update spec.md and cover menu routing, rendering, staged and unstaged edits,
  additions, renames, conflicts, literal filenames, stale selections, and index
  locks. All 602 tests pass with sha1,sha256, and all 607 pass with
  blocking-network-client as well. Formatting and scoped Clippy checks pass.

• track unnamed AutoMerge inputs by change ID
  AutoMerge previously required a named input and an unambiguous branch or pin
  at HEAD. Allow selected commits outside HEAD's ancestry to be merged into
  HEAD, preferring local branches and ordinary pins through the existing fuzzy
  picker and falling back to effective change IDs. An unnamed or ambiguously
  named HEAD uses the same fallback. Merge parents retain unnamed inputs
  without creating tracking refs or pins.

  Track logical rewrites separately from ref movement so change inputs follow
  retained commits through edits and todos without following inserted children
  or copies. Dropped inputs and inputs squashed into a different identity lose
  their subscription. Exact edits take precedence during both dependency
  discovery and replay, including inputs outside the lookup projection.

  Resolve change IDs lazily within the active history only when hidden tips
  bound it. Keep missing or ambiguous inputs at their recorded version, report
  ambiguity, and never choose a version by timestamp. Preserve this boundary
  when expanding replay graphs, and carry diagnostics through UI and CLI
  completion paths with CLI notices on stderr.

  Reuse AutoMerge's metadata, removal picker, muting, nested replay, checkout,
  signing, and undo machinery. Update gix-tix/spec.md and cover selection,
  metadata, bounded resolution, exact placements, insert/split/copy/drop/squash,
  nested conflicts, multiple memberships, and undo.

• add automatic merges of named tips
  Keep a checkout composed from named branches and pins without turning their
  merge into an obstacle to editing or rebasing its inputs. Store ordered ref
  subscriptions in tix-auto-merge commit headers and resolve them again when
  inputs change, on travel, or through an explicit remerge. Initial creation
  preserves source refs and checks out the derived commit detached.

  Merge inputs in order, retaining a conflicting tip as a parent while muting
  its entire tree contribution. Exclude muted inputs from intermediate merge
  ancestry so later inputs can still contribute. Generate titles such as
  ✔️ A 💥 B ✔️ 📌, prune disappeared refs, preserve distinct subscriptions
  when tips converge, and collapse a single remaining subscription to its tip.

  Reuse the command popup's fuzzy picker for aM and input removal. Prefer local
  branches, then pins, remote branches, and commit tags. aU refreshes the
  selected AutoMerge HEAD; ax removes a selected input and disambiguates its
  memberships; aX chooses an input from the selected AutoMerge. Preserve input
  refs, including subscribed pins which checkout cleanup would otherwise consume.

  Maintain derived commits throughout the current editable projection using the
  existing transactional edit and lazy replay machinery. Pending inputs replay
  independently; conflicting optional replays retain their original patch and
  stay muted. Rebase todos use ordinary pick lines and resolve subscriptions
  from final ref placements across fork sections. Review finishing and branch
  attachment also update dependent merges. Keep generated trees and titles out
  of direct editing while allowing ordinary descendants and enrichments.

  Group ref changes and checkout in undo, verify input refs at publication, and
  retain only detached AutoMerge metadata while the UI is idle. Watchers remain
  read-only. Document the behavior in gix-tix/spec.md and cover conflict muting,
  replay, external resets, pruning, nested dependencies, todo continuation,
  review finishing, attachment, concurrent changes, picker actions, and undo.

• pin related history from the view menu
  History reports hidden branches at their shared base and upstream
  relationships at local branch tips, but those indicators did not provide a
  way to bring the related history into the view.

  Add View → show related history (v o) to collect all matching hidden
  branches or unnamed tips and the selected branches' configured upstreams.
  Resolve upstream names through fetch refspecs and deduplicate by reference
  identity so distinct branches remain selectable. Pin immediately for one
  target; reuse the command menu's searchable picker and Escape handling for
  multiple targets. Report when there are no related targets.

  Create or reuse ordinary pins and select the target after refresh. References
  remain symbolic and are resolved again when chosen; unnamed commits use fixed
  pins. Pinning hidden history now shows the commits connecting the tip to the
  shared base with the existing dim, read-only boundary styling. The shared
  visibility calculation handles both cached refreshes and initial loading,
  while older shared ancestry remains hidden, including across merge parents.
  Only moved reference decorations may redirect refresh selection, so an
  unchanged branch cannot override the chosen pin target.

  The normal pin undo log and persistence apply. Derive visibility from current
  view tips so restarting preserves the revealed range and unpinning hides any
  rows no remaining tip needs. The checkout stays unchanged, and there is no
  separate state specific to the related-history action.

• use one branch color in history
  Local branch labels were less prominent than remote-tracking labels in the
  history view. The different colors also made branch kinds visually compete
  when their shared role as branch names was more useful.

  Render local, remote-tracking, checked-out, and remembered branch labels in
  the existing remote-branch yellow. Apply the override where history labels
  are rendered so the reference tree keeps its own palette. Retain tag colors
  and annotated-tag emphasis, detached-worktree colors, and branch markers.

  Update spec.md and the existing rendering checks for branch colors,
  worktree labels, and both tag styles.

• show diff statistics in reword editors
  Existing commit-message editors showed the message and identities without
  any summary of the underlying patch. New-commit editors already provided
  per-path churn, signed net line counts, and aggregate totals.

  Reuse that summary writer for both the TUI and command-line reword documents.
  Compare the selected commit's tree with its first parent, or the empty tree
  for a root. Pending rebases retain their recorded comparison parent so the
  summary describes the original patch independently of the current checkout.

  Keep the summary in comments that are stripped from the saved message, using
  the display formatter to keep filenames containing line breaks on one line.
  Update spec.md and cover committed line counts, root and merge comparisons,
  pending rebases, and message preservation in regression tests.

  Windows CI rejected the diff-stat fixture's newline filename in the tree editor
  with WindowsIllegalCharacter. This fixture only stores a Git tree and never
  checks the unusual filename out. Write a sorted tree object directly so the
  cross-platform test retains its newline-sanitization coverage without invoking
  filesystem-name validation. The targeted test and workspace formatting pass.

• confirm undo and redo with a second key press
  A stray u or U previously applied an undo queue entry immediately. Require
  uu for undo and UU for redo, showing an informational prompt after the first
  press. Each operation consumes its confirmation, and changing direction arms
  the new direction instead of changing history.

  Keep confirmation in App and cancel it on intervening input, new feedback,
  or conflicts. Handle Escape locally before pane or worktree navigation, and
  cancel input that bypasses App::update, including command menus, mouse input,
  paste, and focus loss. Ignore reported key repeats and releases so holding a
  key cannot confirm or repeat an operation. Preserve undo progress, conflict and
  review restrictions, a u, and Ctrl-u.

  Update spec.md and add regressions for confirmation, cancellation, keyboard
  event kinds, and blocked operations. All 556 tests, formatting, and Clippy pass.
  A live terminal check against a disposable two-entry queue verified the prompts,
  unchanged references after single presses, and one-step undo/redo after confirming.

• compact conventional prefixes in history
  Conventional types and scopes consumed space needed for commit subjects,
  while narrow history discarded the entire prefix, including breaking-change
  markers. Render known types as bold colored symbols, scopes in italic cyan,
  and breaking changes with a bright red !. Let the existing adaptive layout
  drop scopes before hiding metadata, using the displayed widths.

  Keep this presentation within interactive history. Plain tix show, rebase
  todos, commit-message panes, and enrichment notes retain their prefixes.
  Preserve Markdown paragraph context so leading subject text such as
  # heading and --- stays literal.

  Extend regression coverage for prefix grammar, custom types, non-UTF-8 text,
  Markdown, selection and hidden-row styling, and narrow layouts. Synchronize
  gix-tix/spec.md with the symbol mapping and display rules.

• highlight the configured author
  History rendered every actor in similar green text, making the active Git
  identity difficult to distinguish from other authors and attribution actors.
  Raw identity matching also missed older names that the mailmap displays as
  the configured person, such as Sebastian Thiel appearing as Byron.

  Retain Git's configured author as detached UI state and refresh it with
  repository context changes. Resolve both the configured identity and each
  actor through the borrowed mailmap lookup used for labels, then compare
  canonical names and emails independently of the mailmap display toggle.

  Render matching authors and attribution actors in bold bright cyan while
  other actors remain regular green. Preserve selection, copy feedback, bot
  labels, and GitHub noreply italics.

  Keep spec.md and rendering regressions together with the implementation.
  Cover canonical identities, configured aliases, historical names and emails,
  same-name nonmatches, agents, and trailers. A live terminal check verifies
  that both forms of the human identity stand out from [Codex].

• make agent trailer suggestions configurable
  Read tix.trailer.assistedBy and tix.trailer.coAuthoredBy from Git configuration while preserving the existing defaults. Editor comments identify either the effective configuration source or the key that can override a default, without separating the suggested trailer lines.

  The Windows fixture CI failed the configured-trailer source assertion because
  joining .git/config preserved a forward slash inside a native Windows path.
  Join each component separately to match the configuration reader's path spelling.
  The targeted trailer-source test and workspace formatting pass locally.

• offer the configured author while rewording
  Older commits can carry an author identity that differs from the one currently configured in Git, and re-entering the configured identity in the reword editor is unnecessary friction.

  Show a commented ConfiguredAuthor beside a differing Author. Uncommenting it makes that identity authoritative while preserving AuthorDate; matching or unavailable configured identities remain omitted, and other commit editors stay unchanged.

• expose HTTP client features
  Forward curl and reqwest transport selection to gix while enabling Tix blocking network support. This makes fetch available in standalone tix builds with either HTTP backend.

• navigate worktrunk search with ctrl-p and ctrl-n
  Reuse the existing arrow-key navigation behavior for Ctrl-P and Ctrl-N while the worktrunk search is active.

• retry rejected pushes with force-with-lease
  A rewritten active branch previously left users with only a failed background push and no in-interface recovery path.

  Run pushes in porcelain mode so local force-related rejections can be identified reliably. Keep the rejected request as a modal prompt, retry it once with force-with-lease on Enter, and let Escape cancel. Forced retries and unrelated failures remain final errors, with both porcelain and stderr diagnostics preserved.

  Cover detached tix/HEAD pushes, successful guarded rewrites, stale leases, rejection classification, prompt reporting, and retry input, and document the behavior.

• add repeatable trace output
  Give the standalone tix binary a bounded -t/--trace counter with forest INFO, forest DEBUG, flat DEBUG, and flat TRACE modes. Keep the option outside the shared subcommand platform so gix tix can inherit tracing from gix without exposing a duplicate flag.

  Buffer explicit traces independently until command and terminal-UI teardown. Use the local gix-trace forest instead of adding tracing-forest, and include completed spans in flat modes so -ttt and -tttt expose the work performed rather than events alone.

  Carry the spawning span and subscriber into push, fetch, worktree-removal, and worktree-picker metadata workers with in_thread(), matching the existing workers. Forest regression coverage checks scoped-subscriber propagation, nested worker output, deferred root completion, filtering, and the latest values of fields recorded after span creation.

• show worktree table non-interactively
  Add tix wt show for scripts and quick inspection without entering the picker. It reuses the picker table renderer and parallel dirty-state workers while carrying one incremental history graph across all worktrees, then emits complete, unclipped plain output only after every row has loaded. A failed row aborts instead of presenting partial data as complete.

• remove worktrees from CLI and switcher
  Add Git-style force levels to tix wt remove, hand the invoking shell back to the main worktree, and safely clean up merged associated branches with guarded reference deletion. Expose double-key removal in the picker through its existing background-task slot, with phased progress, non-interruptible worker lifetime, and post-removal reinventory.

• create branches while switching worktrunks
  Add --new-branch NAME as a branch-only alternative to the positional switch target. Create a missing local branch at the logical Tix HEAD, including the remembered branch while physically detached, then reuse the existing worktree resolution and creation path.

  Existing branches are never moved, already-claimed branches reuse their worktree, and --path remains available for either switch form.

• filter worktrunks by name
  Open an inline fuzzy search from the worktrunk picker so large worktree inventories can be narrowed without leaving the combined history view. Reuse the command menu Unicode-safe editing and fuzzy matching, map filtered positions back to stable inventory rows, and defer each preview rebind until the selected row has painted.

  Arrow and page keys navigate matches, Enter promotes the match, and Escape restores the selection that opened the search. Page movement uses the visible table body rather than counting its header.

• present worktrunks as a compact table
  Replace the unstructured worktree rows with aligned worktree, status, base-diff, and commit-relation columns so streamed state remains scannable beside history. Keep the distinguishing end of long worktree names visible with display-width-aware left truncation, and distinguish current, main, and linked worktrees in the gutter.

• compact history beside stacked changes
  Use the existing stacked-changes layout as the compact-history trigger. Keep gutters and graph through each commit node, then render only a Conventional Commit prefix-free title while preserving review and selection highlights.

• add a worktree switcher
  Add a native worktree picker that streams dirty state, Tix-aware ahead/behind counts, and base diffstats while embedding the existing interactive history in at least half of the terminal.

  Allow explicit local branches to reuse or create linked worktrees, and generate caller-directory wrappers for Bash, Zsh, Fish, Nushell, and PowerShell. Keep repository handles out of idle picker state, bound concurrent inspection, and leave forge integration and remote-branch creation out of scope.

  f0509d425e fix: dispatch repository-free gix tix commands before discovery

• fetch a configured remote with progress
  Add a general fetch action under the actions prefix using gix, including configured remote and refspec selection with phase-weighted progress in the message row.

  Share the existing background network slot with push so only one operation can run at a time. Prefer the active branch fetch remote, then origin or the sole remote, including from detached review checkouts. Keep network actions behind the blocking client feature.

• push the tix/HEAD branch in the background
  Expose aP when the worktree HEAD pin names a local branch and resolve the push remote using Git configuration precedence. Run git push with the remote and branch as explicit arguments without blocking the TUI.

  Show the active task in the footer, report completion with severity-aware notices, refresh references after success, and prevent normal exit while the task is running.

• add commit command aliases
  Let command-menu users search by the selected object instead of remembering each verb. Treat every available action and enrichment, plus commit message and changes information, as a commit search match while preserving existing group scopes.

• highlight checked-out reviews
  Shade a checked-out review from its first visible history gutter through its metadata with a purple background, leaving one normal cell before the title.

  Apply the review band after ordinary selection styling so it remains stable while the selection continues to show everywhere outside it.

• render review commits as graph diamonds
  Replace the ordinary commit disc with the review diamond directly in full and compressed history graphs. HEAD and pending topological choices still override the diamond.

  Remove the duplicate metadata marker while preserving pin and stash spacing, and style non-HEAD review diamonds like existing review decorations.

• copy-insert active reviews
  Make copy-insert available whenever move-insert is available, including when HEAD is an active review commit.

  Strip review identity and return ownership from the copied occurrence so the retained source remains the sole owner of its review resources. Reuse the same identity removal when finishing reviews.

• add view selection by entry number
  Add a View Select command and v c shortcut that collect a displayed #N through the existing notice area. Resolve the number relative to the selected row's visual root so duplicate entry numbers in disconnected history trees cannot move the cursor across trees.

  Keep invalid input editable, support pasted entry numbers, and document and test the interaction.

Bug Fixes

• retain caller locations in standalone diagnostics
  gix now makes caller-location printing opt-in independently of error
  representation. Standalone tix should continue showing captured locations
  when main() returns an error, including custom builds with default features
  disabled. Enable gix/error-print-location on its existing dependency.

  Document the diagnostic contract in spec.md and add a binary regression
  check that ordinary Debug includes the caller file while alternate Debug
  continues to omit it.

• quote terminal controls in history and rebase metadata
  Repository-derived commit titles and authors reached plain history and rebase
  todo output with terminal control sequences intact. A cloned
  commit or mailmap could therefore overwrite output or manipulate the terminal.

  Use gix::quote::for_display() after rendering plain metadata, including
  mailmapped authors and rebase anchor titles. Keep todo commands and
  machine-readable reference state intact, and document the display behavior in
  the Tix specification.

  Regressions cover ESC, BEL and Unicode control sequences in metadata and anchor
  titles. Todo parsing continues to accept quoted informational metadata.

  Git baseline: pager.c::setup_pager() at d38352cd43ab routes terminal output
  through a pager; Tix's plain stdout paths instead need explicit quoting.

  The tree after this commit matches the previously validated sanitizer fix,
  whose complete 461-test Tix suite passed with isolated Git configuration.
  The two terminal-control regressions also pass independently with
  cargo test -p gix-tix --lib --features gix/sha1 terminal_controls.

• reject checkout branch names that look like options
  A cloned repository may contain a local branch named -f. Returning through
  its symbolic Tix pin passed that name to git checkout as an option, forcing
  away uncommitted work while reporting a successful branch return.

  Reject leading-dash branch operands in checkout_branch() and route symbolic
  pin checkouts through that same guard. Existing checkout failure handling
  preserves the departure and return pin. A -- separator would instead change
  the operand into a pathspec and would not perform the intended branch checkout.

  An isolated regression starts from refs/heads/-f, travels to an ancestor,
  changes a tracked file, and returns through the HEAD pin. Before the fix it
  reports success; afterwards it refuses the option and preserves the file,
  detached HEAD and pin. Explicit branch checkout shares the validation.

  Git reference: refs.c::check_branch_ref() at d38352cd43ab rejects leading
  - in porcelain branch names, although plumbing can still create such refs.
  Validation: all 21 time-travel tests pass with SHA-1 enabled.

• validate undo changes before updating rebase references
  A trusted rebase document can intentionally describe reference edits beyond
  those shown by its generated body. Exposed that edits to the
  undo queue itself were rejected only after those refs and other refs had
  already changed, destroying the very history needed to recover.

  Validate the undo change set before applying the checked, non-dereferencing
  reference transaction, then record its actual applied changes. Keep the complete document trusted:
  tag and remote-reference edits remain possible and are recorded for undo.
  Only unrecordable changes fail before any reference is written.

  Regression coverage applies edited state anchors to both queue refs and
  verifies that the queue and other refs survive. A companion test applies
  explicit tag/remote deletions and restores them through undo. The prior
  implementation fails the reference-preservation assertion.

  Git reference: Documentation/git-update-ref.adoc at d38352cd43ab describes
  checked reference updates; the Tix undo queue is an additional local invariant.
  Review correction: a MustNotExist update can succeed as a no-op if the ref
  already points at the requested target. The regression now models creation
  while editing the document and verifies undo does not delete the existing ref.
  Validation: all 134 edit tests pass with SHA-1 enabled.

• keep travel descendants attached to rewritten commits
  Restricting travel to its destination route also removed later descendants
  from the rewrite graph. Visiting a pending middle commit finalized it while
  the branch above it still reached its old pending version, leaving two
  versions of the same change visible in the TUI.

  Keep the loaded edit graph for descendant rewrites and pass the original
  travel route separately to the replay engine. Only the destination route
  and its eligible AutoMerge inputs replay content. Affected descendants
  follow rewritten parents lazily, retaining their trees and original replay
  bases; their references and notes move in the same existing transaction.
  Pending commits whose parents did not change remain untouched.

  Remap the replay route independently across subsequent passes so AutoMerge
  collapse cannot widen it. Shared ancestry and unpinned history outside the
  loaded view retain their previous boundaries.

  Add a regression for a pending middle commit, its retained descendant, and
  onward travel. Update the sibling, merge, and backward-travel assertions to
  require connected parent links while preserving content replay boundaries.

• keep Windows editors attached to the console
  gix-command prepares background helpers with CREATE_NO_WINDOW. Even with
  inherited standard streams, that flag gives Windows editors a separate hidden
  console. Vim and Nano can exit unsuccessfully, while Helix can wait invisibly
  for input that never reaches it.

  Clear the creation flags when launching Tix's configured editor so both direct
  commands and shell commands share Tix's console. The common launch path covers
  editing from the TUI and command-line operations without changing editor
  selection or the handling of the edited document.

  Add an isolated Windows regression that runs in a hidden test console and
  checks that the editor shares its caller's console before editing the file.
  Checking console process membership matters: opening CONIN$ alone also works
  in the separate hidden console. Document the console-inheritance guarantee in
  spec.md.

  Verified interactive launches with Vim, Nano, and Helix, including returning
  from Vim and Helix to the TUI. The regression fails before the fix and passes
  afterward. The combined editor and command checks pass 75 tests; the remaining
  bare-clone test fails identically with the original implementation on Windows.

• confine travel replay to its destination path
  Branch and Git-hash travel loaded history without the normal hidden boundary.
  Old pending markers in merged ancestry could replay hundreds of commits,
  changing identities and metadata even when their file contents stayed intact.
  The shared replay engine also reparented siblings and later descendants that
  were unrelated to the requested checkout.

  Limit travel to editable commits in HEAD..destination, plus the destination
  itself. This permits refreshing a pending HEAD or backward destination while
  preserving older shared ancestry, siblings, and commits beyond the destination.
  The limit applies even without hidden history and when an explicit view omits
  HEAD. Branch and hash resolution now infer the usual hidden boundary, and
  hidden or shallow destinations remain exact checkouts.

  Keep AutoMerge dependency replay inside the original route, preserving the
  bounded change-ID lookup window and treating outside inputs as snapshots.
  Collapsing a merge cannot widen later replay passes. Pending boundary parents
  remain unchanged, including when accepting and resolving a travel conflict.

  Cover CLI resolution, endpoint replay, omitted HEAD, shallow boundaries, both
  ordinary merge sides, off-path identities, AutoMerge collapse, local changes,
  and conflict recovery in disposable repository regressions.

• make finishing reviews undoable
  Finishing explicitly cleared undo history, and accepted review-return conflicts
  suppressed recording through resolution. Even recording a successful finish
  was insufficient for redo: undo restored an active review, whose blanket guard
  hid the queue again.

  Record the complete finish transaction using the normal undo machinery,
  including its checkout, review resources, return pin, and patch approval.
  Recognize review-ending entries by the review-reference deletion they already
  contain, so they remain reversible across active reviews without a new queue
  format. Remove the UI veto and the special conflict-recording suppression.

  Keep ordinary edits during active reviews unrecorded and discard stale redo
  after those edits. Empty transactions, including cancelled unpublished previews,
  leave the queue alone. Cover attached and detached returns, repository reopens,
  another active review, edit-and-retry, and grouped return-conflict resolution.
  Update the review specification with the undo and redo contract.

• preserve commits below a finished review
  Finishing a review replaced its parent with the reviewed tip and transplanted
  only the review and its descendants. Independent commits inserted below the
  review disappeared from the resulting history, even though the review's exact
  tree retained their changes.

  Find the ordinary ancestor chain exclusive to the review and replay each patch
  onto the reviewed tip before attaching the finished review. Preserve change IDs,
  authors, messages, Git notes, and references, and reparent affected side history.
  The review keeps its exact tree and remains the only newly approved patch.

  Reject hidden, pending, nonlinear, or conflicting additions without publishing
  changes. A shared merge base remains valid. Cover single and multiple inserted
  parents, review and original successors, notes, distinct patches, and atomic
  failure, and document the completion behavior.

• keep command palette input responsive
  Every palette keystroke marked the full view dirty, formatting and measuring
  all changed paths even when only the query and matching commands changed.
  Large dirty worktrees therefore made ordinary typing noticeably slow.

  Retain one terminal-sized background buffer while a command or AutoMerge input
  menu is open and reuse it for menu-only redraws. Process these redraws after
  normal repository lifecycle and watcher handling. Pending background changes,
  resizes, and menu dismissal still redraw the full view, and menu input leaves
  the background frame deadline intact so it cannot postpone streaming updates.

  Regression coverage compares cached and complete frames across filtering,
  expansion, cursor placement, resizing, and updated worktree contents. In a debug
  build, eight palette edits over 20,000 changed paths dropped from about 350 ms
  to 10 ms. Update spec.md with the redraw and detached-buffer lifetime rules.

• recover when worktree removal interrupts the UI
  An external remover can delete a linked worktree's HEAD, commondir, or
  gitdir before its checkout and administration directories disappear. The
  lifecycle check only noticed missing directories, so reference refreshes and
  view loads could exit while reopening that incomplete repository.

  Treat missing administration files as worktree loss and enter the normalized
  common repository. Explicitly clear its in-memory worktree path: overriding
  core.bare alone could retain the main checkout. Recovery leaves that
  checkout's HEAD and index untouched.

  Retry interrupted renders and snapshots through the existing lifecycle
  boundary. Keep refresh graphs and distinguish worker requests made before
  recovery so late failures reload the surviving history. A disappearing picker
  preview becomes unavailable instead of closing the UI. Requests against the
  recovered repository still propagate errors normally.

• show background progress in the message area
  Push displayed a separate line above the footer before putting a force-push
  prompt in the ordinary message area. Use that same message area for push,
  fetch, and worktree-removal progress so their status has a consistent place
  and does not reserve an extra row beside foreground feedback.

  Keep background task state independent from notices. Held-command help takes
  priority, followed by prompts and ordinary notices; the latest progress
  resumes when they clear. Preserve the completion fill, wrap long progress
  text, and move it above prefix popups like other messages.

• simplify travel hints for clean worktrees
  When there are no local changes, advertising both 2 stash & travel and
  @ with worktree suggests a distinction that does not affect the checkout.
  Show only @ travel for a current clean worktree status, or @ return at a
  pinned destination. Preserve both hints for dirty or unknown status, including
  untracked-only changes and unwatched or failed status snapshots. Key bindings
  remain unchanged.

  Build the travel shortcut spans once and reuse their width for prefix-popup
  positioning so the Information popup remains attached after the footer shrinks.
  Extend the existing rendering regression for clean, dirty, and unknown status,
  return destinations, shortcut underlining, and popup alignment.

• validate only the new commit parent
  Creating a commit reused checkout-ancestry validation, so a finalized parent
  could be rejected because an older visible ancestor still needed replay. With
  no hidden tip, the error directed users to time-travel through that history
  even though creating a child did not require changing it. A pending selected
  parent on another branch could also escape the checkout-based check.

  Validate the actual insertion parent before any objects or refs are persisted.
  Keep the existing pending-state predicate and AutoMerge exemption, but do not
  scan older ancestry for insertion. AutoMerge maintenance and validation of other
  edit operations retain their existing behavior.

  Cover every CLI content source and shared TUI normal/empty creation, including
  ordinary merges and selections away from HEAD. Check that older ancestry stays
  intact and that rejection preserves refs, undo state, index bytes, worktree
  files, and the object database.

• preserve staged changes when rewording
  Rewording a checked-out commit used the shared rebase engine's mixed index
  reset because reword retains lazy-replay metadata. That discarded staged
  versions even though the commit tree was unchanged, including contents no
  longer present in the worktree. The editor and explicit-message paths were
  both affected, as were linked checkouts and empty rewritten descendants.

  Recognize replacements that change only commit metadata and omit index resets
  for their unchanged output trees. Keep explicit path updates and pending HEAD
  finalization consuming the selected staging as requested. Split and insertion
  also retain their existing index behavior, even when their resulting tree is
  unchanged. Document index preservation in spec.md.

  The regression exercises TUI and CLI entry points against ordinary and empty
  HEAD commits, linked targets, and empty linked descendants. It verifies exact
  index bytes and worktree contents, including staged data absent from disk. A
  second regression keeps an unchanged-tree pending path amendment updating its
  selected index entry while retaining unrelated staging.

• Isolate Tix tests from the invoking worktree and environment
  Tests must keep Git subprocesses and repository reopens inside disposable
  fixtures even when the invoking shell exports repository selectors, signing
  configuration, or a shell-handoff destination.

  Route fixture Git commands through gix-testtools and share their isolation
  with production subprocess paths in test builds. Use deterministic isolated
  options for repository reopens under test. Run the worktree-removal command test
  in a child with its inherited shell-handoff destination removed.

  Skip default file logging in test builds and isolate the fetch transport test,
  so command tests cannot write user logs or pass user configuration to Git.

  A destructive discard regression checks that inherited selectors cannot change
  another disposable repository or its index.

  The regression fails against the prior code by changing the other fixture.
  All 726 Tix tests pass with SHA-1 and blocking network support from an isolated
  source copy. Existing snapshots are unchanged. Workspace formatting and Clippy
  for all affected packages and targets pass.

  Windows fixture CI reported hostname contains invalid characters in the bare
  clone tests: std::fs::canonicalize() added a verbatim device prefix that Git
  parsed as an SSH source. Use gix::path::realpath() to make fixture paths absolute
  without introducing that prefix. Both bare-clone regression tests and workspace
  formatting pass locally.

• refuse to push unfinished visible history
  A branch can contain lazy rebases or unresolved replay state beneath an
  otherwise finalized tip. Publishing it exposes temporary commit trees. Check
  the branch selected for push through every merge parent before both the initial
  push and a force-with-lease retry, reporting the blocking commit without replaying
  or changing local history.

  Limit validation to the active view's hidden boundary: exclude every hidden tip
  and all of its ancestors, including ancestry shared through other merge parents.
  Hidden history may retain unfinished markers that should not prevent publishing
  the visible work. Disable the check completely, including source locks, when no
  hidden tips are known or hidden history is shown. Carry the active hidden tips
  with the push request so a force retry keeps the same scope.

  Reuse the existing pending-state predicate for lazy parents, merge replay
  continuations, unavailable patch identities, and unfinished signatures.
  AutoMerges count as finalized regardless of their state; their visible Git
  parents are still checked. Validate the original objects that Git transfers
  and its actual local source ref, ignoring replacement objects and namespaces.

  When validation is active, hold standard ref locks on the source and each
  symbolic referent until Git finishes, so a concurrent rewrite cannot replace the
  validated history. Handle shared refs from linked worktrees and release locks
  on every return path. Join the push worker during shutdown so exiting Tix does
  not abandon its locks. Keep native Git's destination mapping and
  --force-with-lease behavior intact.

  Document the behavior in spec.md. Regression coverage includes every pending
  marker, visible ordinary and AutoMerge ancestry, hidden tips and shared ancestors,
  unbounded views with a pre-existing source lock, namespace and replacement
  disguises, muted AutoMerge inputs, and concurrent source rewrites from a linked
  worktree with packed and symbolic refs.

• always copy the commit hash before its change ID
  Copying a history row currently switches between a commit hash and a change
  ID as identifier display changes, including when siblings reveal change IDs
  automatically. This makes the clipboard value unpredictable and can identify
  multiple occurrences of a change.

  Make y always copy the full commit hash first. When change IDs are displayed, append
  one space and the full change ID. Keep copied pairs usable by bracketed paste,
  which resolves their commit hash and checks the accompanying change ID.

  Cover explicit and automatic identifier modes, sibling selection, and pasted
  pairs in regression tests, and document the clipboard format in spec.md.

• track detached offspring from unpinned sources
  Detached worktree creation only installed a source pin when the source
  already had valid Tix pins. An ordinary attached source could therefore
  create an experiment whose later commits disappeared from its history.

  Always create the source-local symbolic pin when a source worktree exists.
  The existing worktrees/<id>/HEAD target follows external commits and
  branch checkouts without additional reference or watcher machinery. Bare
  sources remain unpinned, and newly created worktrees receive no pins.

  Extend the existing regressions to cover main and linked sources with
  attached or detached HEADs, with and without prior pins, and child branch
  checkouts. Verify that children starting at the same commit have distinct
  tracking targets, and update the README and behavioral specification.

• delete AutoMerge commits without moving an unrelated HEAD
  The UI rejected every merge commit before the existing deletion machinery
  could handle AutoMerges. Allow generated merges through the same command while
  retaining the restrictions on ordinary merges and their descendants.

  Deleting an AutoMerge returns to its first parent only when it is checked out.
  When HEAD is already below the merge, keep its symbolic state, index and
  worktree untouched without a checkout-target prompt. Preserve input branches
  and reparent descendants with their existing lazy replay behavior.

  Cover command availability, deletion at and above HEAD, staged and unstaged
  content, and descendant reparenting. Update the behavioral specification.

• keep metadata-only descendants fully replayed
  Rewording an ancestor used to mark off-checkout descendants for lazy replay
  even when neither their tree nor their parent trees changed. Besides making
  time travel do unnecessary work, that made content-derived metadata appear
  stale after edits that only changed commit headers.

  Share the final-state decision across ordinary edits, review completion, todo
  replay, and AutoMerge. A previously final commit can be reparented and signed
  immediately when its result and ordered parent trees are unchanged and its
  new parents are final. AutoMerge also preserves its ordered recipe and muted
  inputs. Existing pending commits and conflict-dependent writes remain lazy.

  Add regressions for off-checkout descendants, configured signatures, nested
  AutoMerges, and undo/redo. Adapt replay tests to use actual content changes
  when pending history is required, and synchronize gix-tix/spec.md.

• retain stashes when restoration fails
  A failed git stash apply --index previously deleted the Tix reference
  unconditionally. A conflict in Cargo.lock could stop Git before other
  files were restored, leaving the saved index, worktree, and untracked
  state unreachable through Tix.

  Delete the reference only after Git succeeds, retaining the existing
  expected-target check. Report that the complete stash remains available
  on any failed apply. This shared path protects both manual commit
  stashes and review auto-stashes, including restoration during time
  travel. Partial index and worktree changes remain available for
  inspection or conflict resolution.

  Match git stash pop, which retains its entry when application fails.
  Add a regression for an early index conflict followed by a successful
  retry of all staged, unstaged, and untracked files. Update the review
  regression to retain saved state after merge conflicts and index-lock
  failures, and synchronize spec.md.

• leave the date separator uncolored
  Selected history rows invert their field colors, so the blue date background
  previously ran straight into the author background. Render the date's existing
  trailing space with the row's default colors to preserve the margin without
  moving any metadata columns.

  Update the selected-row buffer and palette expectations and document the
  spacing in spec.md.

• keep the command-menu hint in keyboard help
  The status line repeated the p command hint already available under ?.
  Remove that duplicate to leave more room for contextual status and shortcuts.
  Adjust the shared prefix-popup anchor calculation so the expanded groups
  remain attached to their labels on the shorter footer.

  Keep p command in the information popup. Update the footer render fixtures
  and specification; the existing help and popup-alignment checks cover both
  its continued discoverability and the new layout.

• keep pinned hidden tips visible
  A reference-tree pin could be created successfully yet disappear on return to history: hidden view tips were retained only when the entire view was empty. The same filter lost existing pins on startup.

  Keep each hidden view tip as a selectable boundary alongside visible stacks, without exposing its ancestry. Apply the rule to initial loading and the shared display/edit scope, and cover pin refresh selection and reloading symbolic pins.

• allow pushing without the actions prefix
  Outside the actions prefix, Shift-P decoded as comparison-parent cycling,
  which did nothing in history. Make it push the active branch directly from
  history or the Worktree pane, regardless of the open prefix menu. Accept both
  uppercase P and terminals reporting lowercase p with Shift.

  Keep comparison-parent cycling local to the focused Tree pane, where
  a Shift-P still explicitly pushes. The command popup continues to consume
  p and Shift-P as query text, even when a push is available.

  Update spec.md and regression coverage for prefix-independent pushing,
  Tree's local shortcut, and command-popup input. All 557 tests, formatting,
  and Clippy pass, and the debug executable builds successfully.

• preserve history columns when overlays close
  Closing or shrinking changes panes could shift newly exposed history rows
  right by one cell. Ratatui 0.30 emits an extra trailing-cell blank when a wide
  emoji containing U+FE0F replaces text. Crossterm writes that blank after the
  two-column glyph, so subsequent cells drift even though the internal frame
  still records the correct coordinates.

  Before presenting each completed frame, use Ratatui's ForcedWidth option
  with the emoji's measured width to suppress writes inside its covered cells.
  Apply this to every presentation path, including history, command popups,
  worktree and ref-tree views, time travel, progress, and file diffs.

  The earlier gutter fix (c326831070), viewport alignment fix (11719eb), and
  repeat-layout fix (9e7b9e4) address layout geometry. This regression captures
  actual Crossterm output after pane text is replaced by ✔️, 👯‍♂️, or ⚠️,
  covering the cursor movement that coordinate-based test backends conceal.
  Document the invariant in gix-tix/spec.md.

• preserve pending ancestry when rewording
  Rewording an already lazy-rebased commit removed its tix-rebase-parent even though its tree remained unchanged. Full diffs then used the physical parent, and later travel replayed carried ancestor content.

  Preserve the existing marker for ordinary pending-root rewrites while retaining explicit pending-HEAD finalization. Cover spill, stash, reword, diff, and travel end to end.

• keep enrichment notes visible on selected HEAD commits
  Selected rows use reverse video, which inverted the enrichment note black-on-yellow styling at HEAD. Preserve that note style while retaining reverse video for the rest of the selected row.

• preserve hidden refs after worktree switch
  tix wt switch previewed each worktree with inferred hidden refs, but promotion launched a fresh history view without that filter and exposed the full history.

  Carry the resolved hidden revisions into the promoted view and keep the full-screen session in the worktrunk process. The shell wrapper now only applies the final directory handoff, avoiding a second unfiltered Tix launch.

• let tix amend finish conflict resolution
  A resolved, materialized rebase conflict leaves its checkout commit marked pending. The default command-line amend used the strict edit path and therefore refused the commit even after the index was conflict-free.

  Reuse the existing checked-out pending-commit finalization path for tix amend. It still rejects unresolved index entries and pending commits below HEAD, while removing the marker from the resolved commit. Cover the materialized time-travel conflict flow and document the behavior.

• keep push status out of the footer
  Push alone placed its running label in the shared navigation footer, while fetch and worktree removal used the dedicated background row. This made identical background-task ownership look inconsistent and crowded the footer.

  Use background progress as the single task state and render every running task in the existing row above the footer. Push remains a static status there, while fetch and removal continue updating progress; remove the footer-only rendering and anchor adjustment.

• keep top-level shortcut prefixes global
  Opened shortcut groups could shadow top-level entry points: Actions interpreted n as new-empty and p as split, while the ref-tree used p for pinning. This made keyboard behavior depend on the currently open view.

  Reserve p, v, a, n, and ? ahead of scoped shortcuts. Move new-empty and split to a Shift-N and a Shift-S, retain ref-tree pinning on <enter>, and route command-palette opening ahead of ref-tree input.

  e500df145d fix(gix-tix): keep reference-tree pinning local

  fix(gix-tix): keep reference-tree pinning local

  Making bare p global routed reference-tree input to the history command menu despite the reference-tree footer promising a pin action.

  Restore p alongside Enter for pinning every displayed reference at the selected node and returning to history. Keep the command-menu opener out of the active reference tree, with coverage for routing and synthetic nodes. History shortcuts and typing inside the command popup retain their existing behavior.

• load resized history rows before drawing
  The metadata fill used Ratatui’s cached frame dimensions, then autoresized immediately before painting. Growing the terminal could therefore expose deferred commit skeletons as empty rows dated at the Unix epoch.

  Refresh the terminal dimensions before selecting visible rows and paint that same frame size. Apply the ordering to time-travel animation too, document the invariant, and cover stale-frame growth with a regression test.

• paste unique change IDs
  The history view copies full reverse-hex change IDs, but paste previously accepted only object hashes. Resolve pasted change IDs against the current Tix view so unique changes can be copy-inserted directly.

  When a change ID has multiple siblings, show commit hashes, select the closest match, and direct the user to cycle siblings with x before copying the desired hash.

• keep conflict cancellation in the TUI
  Cancelling a conflicted rebase must return to usable history. Escape could
  be intercepted by the worktree picker, and fixing input routing alone
  still left another exit: discarding a todo conflict dropped its in-memory
  objects while their preview rows remained visible until an asynchronous
  refresh. The next frame failed while loading changed paths or a commit
  message from those missing objects.

  Let history prompts take priority over picker input and only treat Escape
  presses as picker transitions. Restore persisted history from the existing
  display cache and recompute its lanes before repository-backed panes
  resume loading, both on cancellation and failed materialization. Discarding
  a preview leaves repository objects, refs, the index, and the worktree
  unchanged.

  Cover prompt routing and Escape repeats, then exercise a real conflicting
  rebase, drop its object memory, and immediately load changes and the commit
  message before any async refresh. Verify restoration of the original
  history and hidden boundary as well as unchanged repository state.

• allow insertion at hidden boundaries
  Treat displayed hidden commits as immutable insertion anchors for copy, paste, move, and stack operations. Plans add the inserted commits as new children without replaying the target history or moving refs attached to that history.

  When copying onto the checked-out hidden boundary, advance only the branch attached to HEAD and keep HEAD attached. Reject moves whose immutable target descends from the moved stack, since preserving that target would create a cycle.

• finalize path-scoped spills
  Path-scoped spills invalidated an existing signature whenever unselected changes remained, making the directly edited HEAD appear pending even though neither its parent nor its remaining tree required replay.

  Re-sign every non-review HEAD edit immediately while retaining lazy replay for rewritten descendants. Cover a signed two-file spill and prove that a follow-up edit succeeds.

• ignore non-checkout symbolic pins
  Ref-tree pinning can create symbolic ordinary pins for remote, tag, or review references. Destination selection treated every symbolic pin as a local branch and failed time travel. Restrict checkout selection to direct pins and refs/heads targets so other pins remain retention-only.

• show HEAD in plain history
  The plain history renderer suppressed the textual HEAD decoration without replacing the graph node as the TUI does, which left detached HEAD invisible. Render HEAD as @ for ordinary rows and base separators while preserving existing branch labels.

• replay diagnostics through worktree picker
  Route --quit-on-finish input through the focused worktree picker while preserving its read-only guarantee, and wait for each requested preview before replaying the next key. Keep graph-only metadata traversal from marking commits as delivered so later previews emit their history rows and keep the selected commit aligned with its change panes.

• batch worktree picker metadata
  Load graph-derived data for every worktree in one background pass using the same shared graph path as wt show, instead of coupling that work to serial preview warming. Keep selected previews responsive, skip invisible warming in diagnostic mode, and poll active row workers at frame cadence so completion is not delayed by a coarse timer.

  Capture the spawning span and subscriber with gix::trace::in_thread() in the metadata worker so its spans remain in the caller's forest, including with a scoped subscriber. The trace-output regression covers worker parentage and late field values.

• support worktree picker diagnostics
  Permit --quit-on-finish on the target-less worktrunk picker forms and carry it into the shared history event loop. Wait for every worktree status and graph-metadata update before retaining the final diagnostic frame, making the mode useful for deterministic inspection and performance measurement.

• preserve detail before dropping metadata
  A single wide visible prefix, such as paired local and tracking refs, could push the shared title column far enough right to minimize every history row even when natural per-row spacing had ample room.

  Fall back to natural spacing before shortening titles or hiding metadata, and keep hidden boundary rows out of both aligned and natural width decisions.

• avoid redundant worktrunk metadata work
  The worktrunk table only needs ancestry for relation and diffstat calculations. Resolve and deduplicate every worktree head first, populate one shared graph without decorations, linked-worktree snapshots, or commit-row payloads, then reuse it for each row.

  Keep a broken-tag regression fixture so unused decoration loading cannot creep back in.

• put worktrunk status below its list
  Render the contextual status and search row after the worktree table so it separates the picker from the embedded history.

• preserve the graph in compact history
  Adaptive compact rendering truncated every lane at its commit disc, hiding topology in merge-heavy histories.

  Keep the complete trimmed graph and place the shortened title directly after it.

• align only visible history rows
  History alignment included rows covered by change panes and hidden boundary metadata, leaving large gaps in otherwise compact rows.

  Limit alignment inputs to the unobscured viewport and render visible hidden boundaries with their natural unaligned spacing.

• adapt history detail to available width
  History detail previously followed the changes-pane layout and retained trailing graph padding, wasting horizontal space and making rapid navigation flip layouts.\n\nMeasure the drawable history width against visible title widths instead. Shorten conventional prefixes first, then reduce aligned rows to graph and title when needed, while preserving the horizontally scrollable unaligned view.

• preserve compact history during key repeats
  Keep using the persisted stacked changes layout while repeat navigation suppresses the change panes. This prevents history rows from briefly expanding until key release and protects the behavior with a rendering regression test.

• compile edit handling on Rust 1.88
  Rust 1.88 rejects binding the whole edit effect around this or-pattern while also binding its object ID. Determine amend versus spill from the existing match scrutinee instead, preserving behavior at the crate’s declared MSRV.

• make worktrunk previews incremental
  Reuse one append-only history graph across worktree previews so selecting another worktree only traverses ancestry that is not already cached. Derive ahead/behind and base diffstats from that shared graph instead of repeating independent walks.

  Keep picker input responsive while graph and lane work runs, activate only the latest selected preview, and leave the previous history visible but read-only until then. Preview mode avoids filesystem watchers and refreshes worktree-specific diff state on activation.

  Render ahead/addition counts in green and behind/removal counts in light red. Preserve graph and selection correctness across hidden-frontier changes, stale completions, invalidation, and failed refresh retries.

• show worktrunk selection before rebind
  Changing the highlighted worktree previously returned from the event loop immediately, so rebuilding the history hid the cursor move until repository loading finished. Queue the rebind until the urgent frame has painted the new selection, then restart the history against that worktree.

• prioritize the active review tree
  Resolve the nearest active review root for the current worktree HEAD and prefer that root and all of its descendants whenever topological ordering has a choice.

  Keep the existing order for unrelated ambiguous review roots and share the nearest-root rule with time travel.

• preserve contrast on review highlights
  Use a uniform black foreground across the purple checked-out-review band so colored metadata remains legible. Keep the title margin and ordinary selection styling unchanged.

• rebase reviewed sibling stacks
  An active review can add a sibling stack at the same editable base as the reviewed branch. Updating that base rendered its mutable reference once per sibling section, so the parser rejected the unchanged generated todo as a duplicate placement.

  Track external reference destinations while formatting and emit their reference line only for the first section. Cover the reported topology with a real active review and its symbolic return pin.

• amend review worktree changes
  Let active review commits use the same index-first, worktree-fallback amend behavior as ordinary HEAD commits. This makes a freshly started review amendable without requiring the reviewed delta to be staged first, including from a focused unstaged path.

  Keep review identity, return ownership, pending-boundary handling, and index-only CLI behavior intact.

• retain reviews when checkout is blocked
  Prepare the review reference, return pin, and synthetic commit before attempting to activate the review checkout. Dirty worktrees can now proceed when Git accepts them, while a blocked checkout leaves the prepared review intact and reports its full commit ID.

  Avoid forced rollback after checkout failures so local worktree changes cannot be discarded. Keep the finish-time cleanliness check and cover the partial-success path with a regression test.

• choose ambiguous topology paths
  Make J/K traverse every displayed parent and child edge. When a node has multiple destinations, keep the cursor at the source and let h/l choose the numbered destination before Enter confirms it or Escape cancels.

  Use the same temporary choice interaction in the ref-tree, remove persistent child memory and lane emphasis, and discard choices whenever asynchronous lane computation replaces their indexed graph.

• centralize edit scope policy
  Pending checkout validation derived its boundary from commits cached or rendered in a HistoryGraph, while commands selected inconsistent graph loaders. This could reject edits because of hidden pending ancestry or skip checks for frozen rebase plans.

  Track the active edit scope explicitly, share visible-boundary calculation with the UI, validate plans against their declared scope, and model pending HEAD finalization as an explicit policy.

• ignore pending ancestry outside the view
  Checkout-path validation followed raw first-parent ancestry beyond the hidden base, so historical tix-rebase-parent markers could block edits in an otherwise final visible stack.

  Limit pending validation to commits stored in the active history graph and give command-line HEAD edits the same inferred hidden base as the history view. Cover both reword and index-only amend against pending history below that boundary.

• allow amending active reviews
  Pending-rebase validation followed the parent of a checked-out review commit and mistook the review’s lazy base for a pending checkout path. Stop validation at the edited review boundary so staged changes can amend the active review while preserving ordinary pending-path protection.

  Add regression coverage for a review commit whose parent carries tix-rebase-parent, and document the boundary behavior.

• allow pins on displayed hidden bases
  Ordinary pins at attached HEAD were filtered out together with the inactive HEAD return pin. When HEAD was displayed as an otherwise-empty hidden boundary, the missing decoration made the action menu call an existing pin "pin" instead of offering "unpin".

  Keep ordinary pins applicable at attached HEAD while continuing to exclude the special HEAD pin. The existing tip deduplication prevents any traversal change, and a regression covers the hidden-boundary decoration that drives the unpin action.

• preserve review return pins during rewrites
  Review departure pins were indistinguishable from ordinary user pins. When a rewrite moved one onto a later checkout destination, normal time travel could consume it before the review finished and force detached fallback selection.

  Give each review an explicitly owned pins/review/N return ref, keep generic travel and pin actions away from those refs, and consume the exact ref only when finishing or cancelling its review. Cover the squash-and-finish lifecycle and document the ownership contract.

• copy the displayed identifier
  The history copy action always emitted the selected commit's object ID, even while the view showed its change ID.

  Choose the clipboard effect from the effective ID display mode. Hidden and commit-ID modes retain object hashes, while change-ID mode writes the full reverse-hex change ID.

• keep a base visible without stack commits
  History previously used the absence of view tips as a proxy for empty visible
  history. A newly created branch at, or behind, a hidden branch still has a view
  tip, so traversal and projection discarded every row and left no selection for
  creating the first stack commit or opening a rebase.

  Keep current view tips as hidden boundaries when exclusion removes all visible
  commits, while retaining the hidden-tip fallback for unborn HEAD. Treat a
  boundary with zero visible descendants as an editable empty stack, and carry
  refs from the old base into an empty rebase-update so saving the unchanged todo
  advances the branch.

Changed (BREAKING)

• select insert sources before targets
  Make copy-insert and move-insert follow one source-first interaction: choose the commit, invoke the action, then choose its destination. Copy-insert now accepts any visible single-parent commit, while move-insert remains limited to HEAD.

  Reuse the existing target-selection mask for navigation, cancellation, compressed history, and refresh invalidation. This removes the ambiguity that previously made a selected commit act as the target while an implicit HEAD acted as the source.

New Features (BREAKING)

• auto-hide default-branch history at startup
  Interactive history already inferred local default branches from remote
  HEADs, but required Shift+H to hide their history after launch. Add -X /
  --auto-hide to tix and gix tix so the initial traversal applies those
  exclusions.

  Combine inferred exclusions with explicit -x revisions and retain the
  existing history toggle and revision diagnostics. Plain tix still opens
  with full history, and -x alone keeps its explicit-only scope. Reject the
  new history-view option alongside subcommands so it cannot be ignored.

  The public gix_tix::Options struct gains the default-false auto_hide
  field. Exhaustive initializers must supply it or use ..Options::default().

• retain paused rebases across CLI and TUI sessions
  Accepted rebase and transplant conflicts previously kept their continuation
  in an exported todo or in TUI memory. Restarting Tix or changing interfaces
  lost the operation context, and the TUI could not identify a CLI-created
  pause. Save accepted pauses in worktree-local Git metadata using the existing
  todo and undo formats, retaining their required objects through Git GC.

  Add tix rebase status [--porcelain], continue, and stop. Continuation
  consumes the staged index without launching an editor or staging files.
  Initial and later conflicts require explicit acceptance; refusal preserves
  the prior state. Plain rebase todo exports the saved plan, and matching
  edited-file application remains supported. Bare --materialize-conflicts
  now saves internally; exporting requires =FILE or =- for stdout. Optional
  filenames never consume a positional todo.

  Restore the TUI's persistent REBASE PAUSED notice on startup and refresh,
  including operation, remaining work, readiness, and blocked-state guidance.
  Enter continues, subsequent conflicts require acceptance, Escape stops at a
  saved pause, and quitting preserves it. Inspection and resolution amendments
  remain available while unrelated mutations are blocked.

  Check captured HEAD identity and reference expectations before continuing.
  Publish session transitions with checked history updates, serialize checkout
  and stop, and restore staged resolutions on failed publication. Completion
  or stop records one grouped undo entry without resurrecting session metadata
  on undo. Stop preserves partial commits, index, and worktree contents.
  Ordinary lazy replay, travel conflicts, and native Git rebases stay outside
  this continuation workflow.

• expose operation history through tix op
  Undo and redo were available only in the terminal UI even though CLI edits
  already recorded the same worktree-local operation queue. Expose one-step
  undo and redo alongside a plain operation log, with bare tix op showing
  the log and marking the current position among applied and undone entries.

  Move tix admin clear-undo to tix op clear so all queue operations share
  one command family. Keep history data on stdout and recovery feedback on
  stderr. Reuse checked reference and worktree updates, and reject unresolved
  index conflicts before applying an undo or redo.

Bug Fixes (BREAKING)

• hand worktree switches back to the shell
  Picker selections opened another Tix session before the shell wrapper could
  apply its directory handoff. The terminal emulator therefore kept reporting
  the source directory while the selected worktree's history was open.

  Return picker selections through the same path handoff as explicit switch
  targets. The wrapper can change directory and run the shell's normal CWD
  hooks before the user opens Tix again. Without shell integration, print the
  selected path and exit.

  When Tix starts without -x, infer integration branches through the remote
  HEAD mappings already used by tix show. Start with full history and offer
  one reversible display control: hide unrelated history applies those
  exclusions, and show related history restores the full ancestry of the same
  view tips. Both directions use Shift-H or v h. Explicit filters apply
  immediately and are not broadened by inference.

  Remove the separate related-target picker, its pinning action, and its v o
  shortcut. Showing or hiding history now only changes the view, preserving
  existing pins and undo history. Ordinary explicit pinning remains available.

  Update spec.md, the README, and regression coverage for inferred, explicit,
  missing, and invalid filters and the single contextual history command. All
  608 Tix tests pass with sha1,blocking-network-client. Pseudo-terminal checks
  cover picker selection and cancellation, path output, the shell's CWD hook,
  both live toggle directions, existing pins, and unavailable inference.

• embed action shortcuts in their verbs
  Several Actions labels repeated their shortcut before the verb, while others
  used letters absent from the verb. Make every action underline its key inside
  the verb, using the key's case in labels such as New-empty, Split, Fetch,
  Push, and AutoMerge. The command picker shares these labels and retains
  case-insensitive search.

  Rename forget to delete throughout the action, notices, undo descriptions,
  and editing module. Describe AutoMerge input removal as exclude from AutoMerge and eXclude input so its existing x and X keys are embedded.

Commit Statistics

• 140 commits contributed to the release over the course of 13 calendar days.
• 13 days passed between releases.
• 120 commits were understood as conventional.
• 0 issues like '(#ID)' were seen in commit messages

Commit Details