Rebase

Intent-Aware Rebase

Run one rebase in the current checkout and resolve every conflict by understanding what each side was trying to do. A conflict is two authors disagreeing about code, not a syntax error: the resolution is the code they would have written together, expressed in the shape the upstream side has now.

The request is whatever the user typed with the invocation. When running in Claude Code, read .claude/commands/rebase.md for that host's substitutions; when running in Grok Build, read .grok/commands/rebase.md.

Hard rules

• Operate only in the current worktree. Never write into a sibling checkout slot, and never rebase a branch that git worktree list shows checked out elsewhere — say where it is instead.
• Never push, never force-push, never delete the backup ref, never touch origin/private refs beyond an explicitly confirmed fetch.
• Never run git rebase -i, git add -i, or anything else that opens an editor; these hosts have no interactive terminal. Use git -c core.editor=true for every rebase --continue. If commits must be dropped or reordered, do it with a non-interactive GIT_SEQUENCE_EDITOR and show the todo list you are producing.
• Never resolve with git checkout --ours/--theirs <file>, never delete a hunk to make the build pass, never leave a conflict marker, never --skip a commit to escape a hard conflict.
• This is a branch-integration operation. It is never an ai-tdesktop task: do not create, claim, or publish task records for it, and do not route it through perform-task, continue, or process-inbox.
• Resolve conflicts in this session, with both sides in context. Delegation is for gathering, never for deciding: a leaf may summarize history you name, but it must not write a resolution.

Host mechanics

• Asking the user. Where this document says to ask, use the host's structured question mechanism if it has one, and otherwise end the turn with a short numbered question and stop. Never continue a rebase past a question you have not had answered.
• Checkout kind. In a native Windows checkout run git directly. In the WSL checkout reached through \\wsl.localhost\..., route every git command through wsl.exe -d {distro} --cd /home/{user}/Telegram/tdesktop -- git ... per AGENTS.md; native Windows git over that UNC path fails with detected dubious ownership.
• Line endings. Keep each file's existing convention — CRLF in a native Windows checkout, LF in the WSL checkout — and never add a BOM. A git diff --stat that shows a whole-file rewrite means you broke them.

1. Read the request

Accept free prose. The shapes to recognize:

When the user proposes a literal command ("I believe command should be git rebase --onto private/alpha abcdefg alpha"), take it as a strong hint, not as gospel: resolve its refs and print the commit list it would actually replay. If that list disagrees with the prose — wrong <base>, a commit that should stay behind, a <base> that is not an ancestor of <branch> — say so plainly with the evidence and propose the corrected command.

Remote-tracking targets (private/*, origin/*) are local snapshots. Do not fetch on your own: print the target's sha, subject and commit date so staleness is visible, and ask before fetching if it looks old or the user mentions freshness.

Record these once and reuse them everywhere below:

• ONTO — the new base, resolved to a sha.
• REPLAY_BASE — exclusive start of the replayed range (<base> for the --onto form, otherwise git merge-base <ONTO> <branch>).
• OLD_TIP — the branch tip before the rebase.

Print the plan: the exact command, ONTO (sha, subject, date), the replay list git log --oneline REPLAY_BASE..OLD_TIP, and the likely conflict surface —

comm -12 \
  <(git diff --name-only REPLAY_BASE OLD_TIP | sort) \
  <(git diff --name-only REPLAY_BASE ONTO | sort)

Proceed without asking when the reading is unambiguous. Ask when two readings would replay different commits, or when the user's proposed command and prose disagree.

2. Preflight

• In-progress rebase — git rev-parse --git-path rebase-merge / rebase-apply exists: do not start a new one. Go to §7.
• Dirty tree — git status --porcelain non-empty: stop and ask (commit, stash, or cancel). Never stash silently.
• Backup, always, before the first replay:

git branch backup/<branch>-$(date +%Y%m%d-%H%M%S) <branch>

matching this repo's existing backup/wallet-engine-20260903 convention. Report the ref name and OLD_TIP in the final summary as the undo path.

• rerere.enabled is true in this repository, so past resolutions get replayed automatically. That is a hazard, not a convenience — see §6.

3. Start

git -c core.editor=true rebase [--onto ONTO] [REPLAY_BASE] <branch>

If the replayed range contains merge commits, say so and ask whether to flatten them (default) or pass --rebase-merges.

4. How much to read

Keep git's auto-merge. Hunks that do not overlap are merged deterministically and correctly; re-deciding them by hand costs enormously and is less reliable than git, because the failure mode is silently dropping something. Read a whole file only when it is small, or when the conflict cannot be judged from its region alone.

Tier the effort per conflict, judged from one pass over the three stages:

• Mechanical — both sides append to the same include block, list, enum, .style block or switch; whitespace; adjacent unrelated additions. Read the region, keep both, move on. No history dig.
• Overlapping logic — both sides changed the same function, the same condition, or the same behavior. Full §5 protocol.

The gap auto-merge leaves is the semantic conflict: hunks that merge cleanly but are wrong together — upstream renamed a symbol this commit calls, changed a signature it passes to, or moved the call site it hooks into. Git never reports these. Cover them cheaply rather than by reading everything:

• Before --continue, record OLD=$(git rev-parse REBASE_HEAD); after the commit lands, git range-diff $OLD^..$OLD HEAD^..HEAD and read whether the change arrived intact.
• For a commit that had any conflict, compile the translation units it touched (§5.7). In the native Windows checkout that is ~11s per file and catches nearly all rename and signature drift.
• The whole-rebase git range-diff in §8 is the net under all of it.

Do not read files that merged cleanly, do not re-review commits that replayed without conflict, and do not build after every commit.