⬡History rewriting

Interactive rebase editor rebase.interactive

A modal (InteractiveRebase) listing the commits from a chosen point to HEAD, oldest-first, each with a per-commit action.

Entry points

• Commit menuRight-click a commit → Interactively Rebase from Here…

What happens next

1. The editor opens with the range (its parent is the rebase base). Each row has a grip to drag, an action dropdown (pick squash fixup drop), the short SHA, the subject, and ↑/↓ move buttons.
2. The first kept (non-drop) commit must be pick — squash/fixup fold into the commit above, so a warning shows if it isn't.
3. Start Rebasing sends the plan to rebase.interactive, which scripts git rebase -i non-interactively.

Pause on conflict

If the rebase conflicts it pauses rather than aborting. The toolbar surfaces Continue / Skip / Abort (rebase.continue / rebase.skip / rebase.abort), and the state is restored across reloads via rebase.status.

Squash with parent commit.squash

Entry points

• Commit menuSquash with Parent.

1. You confirm (it rewrites history; the two commits' messages are combined).
2. Go runs commit.squash via the interactive-rebase machinery, folding the commit into its parent.
3. If it conflicts, the rebase pauses with Continue.

Drop commit rebase.drop

Entry points

• Commit menuDrop Commit.

1. You confirm the rewrite.
2. Go runs rebase.drop, removing the commit by rebasing later commits onto its parent (rebase --onto).

Edit / reword message rebase.reword

Entry points

• Commit menuEdit Commit Message…

1. You're prompted with the current message pre-filled; edit and confirm.
2. For HEAD it's a commit --amend; for an older commit a scripted rebase reword (rebase.reword).
3. A conflict pauses the rebase with Continue.

Create patch patch.format

Entry points

• Commit menuCreate Patch…

1. Go runs patch.format (git format-patch) for the commit.
2. A native save dialog (host helper savePatch) writes the <sha>.patch file where you choose.

Push up to a commit push.upto

Entry points

• Commit menuPush All up to Here…

1. You confirm pushing all commits up to the chosen one onto origin/<branch>.
2. Go runs push.upto with { commit, branch } — publishing history only up to that commit.

Fixup & autosquash commit.fixup rebase.autosquash

The "this belongs in an earlier commit" workflow without manual rebase surgery: park corrections as fixup! commits while you work, fold them all in at the end.

Entry points

• Commit menuFixup: Commit Changes into This… — commits the current changes as fixup! of the right-clicked commit.
• Commit menuApply Fixups Below (Autosquash)… — folds every fixup! into its target.

What happens next

1. Fixup: after a confirm listing the changed-file count, Go runs commit.fixup — stages the paths and commits with --fixup=<sha>. Repeat freely against any commits.
2. Autosquash: Go runs rebase.autosquash (rebase -i --autosquash with the auto-generated todo accepted as-is) from the target's parent — every fixup folds into its commit, messages untouched.
3. A conflict pauses with the standard Continue / Skip / Abort bar — never auto-aborted.