Codex Resolve Rebase Conflicts

Resolve rebase conflicts

Settle every conflicted path and stage it, so the rebase can advance. This skill ends there. Continuing the replay and verifying the result belong to the codex-rebase skill.

Codex doesn't provide a skill-scoped command hook. Never use --ours or --theirs. The scripts use unambiguous side names. Stage only named paths after checking them for markers, and return through the continuation script, which checks the staged blobs again.

The inversion, once

During a rebase git checks out the base and replays your commits onto it. Your work is the side arriving, so git calls it --theirs, and the base you are moving onto becomes --ours. Every intuition about which word means which runs backwards here, and a wrong pick resolves cleanly and stays wrong.

Nothing in this skill uses either word. The sides are:

• base-side is the commit the branch replays onto. git calls it --ours, and the index calls it stage 2.
• replayed-side is the commit git is replaying right now. git calls it --theirs, and the index calls it stage 3.

The scripts read the index stages rather than the marker labels, so the naming holds under whatever marker style the repository sets.

Marker shape

With merge.conflictStyle set to diff3 or zdiff3, a conflict has three sections rather than two:

<<<<<<< HEAD
the base-side content
||||||| <ancestor label>
what both sides started from
=======
the replayed-side content
>>>>>>> <commit> (<subject>)

That ||||||| section is the common ancestor, and it's the most useful part of the block: it says what each side changed rather than only what each side now holds. The default merge style omits it. Handle both, and never assume the two-way form.

A bare ======= line isn't a marker on its own. It underlines a setext heading in ordinary Markdown, so the scripts here match only <<<<<<<, |||||||, and >>>>>>>.

Step 0: open the task list

Create these with update_plan, keeping exactly one item in_progress at a time.

1. Classify every conflicted path
2. Resolve the mechanical ones
3. Take a whole side where that's the answer
4. Read the rest, and stage what you resolved
5. Hand back

Where a class turns out empty, close its task and say so rather than deleting it. Which classes the stop produced is part of the report at the end.

The scripts stop with a plain message when no rebase is in progress. Say that and hand back, because nothing here applies outside one.

Step 1: classify before editing anything

bash .agents/skills/codex-resolve-rebase-conflicts/scripts/classify-conflicts.sh

One call reads every unmerged path and says what shape its conflict has, with the evidence for the claim printed beside it. Read that output before opening any file.

The classes:

For a content conflict the script also prints what each side changed against the common ancestor. The markers can't show you that, and it's what settles the resolution.

Step 2: resolve the mechanical ones

bash .agents/skills/codex-resolve-rebase-conflicts/scripts/resolve-union.sh <path> [path ...]

An append-only sorted list conflicts on nearly every rebase, and the answer comes out the same every time: every line either side has, sorted, once each. A word list, a spelling dictionary, a vocabulary file. Asking an operator to confirm that means asking them to rubber-stamp arithmetic.

Safety comes from the condition rather than the filename. The script refuses unless all three versions really do sort cleanly under the C collation with no duplicate line, and unless both sides kept every line the ancestor had. Those two conditions are what make a union provably lossless. A file that stops meeting them stops resolving here, which is what keeps a name-based shortcut from outliving the property it assumed.

After writing, the script re-derives the union from the index stages and compares the two. The result must carry exactly the lines the two sides carry between them. No duplicates, and still sorted. A resolution that dropped a line fails there rather than in a lint run three commits later.

Don't confirm any of this with the operator. Report it in the summary at the end.