@staff0rd/assist 0.542.1 → 0.543.0

package/README.md

@@ -47,7 +47,7 @@ After installation, the `assist` command will be available globally. You can als
 - `/commit` - Commit only relevant files from the session
 - `/devlog` - Generate devlog entry for the next unversioned day
 - `/draft` - Draft a new backlog item with LLM-assisted questioning
-- `/fix-conflict` - Resolve the current PR branch's merge conflicts against the remote default, verify, commit and push
+- `/fix-conflict [--rebase]` - Resolve the current PR branch's conflicts against the remote default, verify, then push; merges by default, `--rebase` replays the branch and pushes with `--force-with-lease`
 - `/forward-comments` - Split a coarse PR comment into per-line review comments, attributed to the original reviewer
 - `/handover` - Write a session handover note for the next conversation
 - `/pr` - Raise a PR with a concise description, then watch CI in the background
@@ -344,7 +344,7 @@ The Config tab of the sessions web dashboard never receives secret values: `GET
 - `assist bug [description] [--once]` - Launch Claude in `/bug` mode, chain into next on `/next` signal
 - `assist refine [id] [--once] [--harness <claude|codex|pi>]` - Launch a coding harness in `/refine` mode; `--harness` picks the engine, defaulting to the configured `harness.engine` (Claude)
 - `assist review-pr-comments [number] [--announce]` - Launch Claude in `/review-pr-comments` mode; a PR number is checked out first via `gh pr checkout`. `--announce` (requires a number) announces the PR in Slack via `/prs-slack <number> --no-confirm` once every comment thread has been processed
-- `assist fix-conflict [number]` - Launch Claude in `/fix-conflict` mode to resolve the branch's conflicts against the remote default; a PR number is checked out first via `gh pr checkout`
+- `assist fix-conflict [number] [--rebase]` - Launch Claude in `/fix-conflict` mode to resolve the branch's conflicts against the remote default; a PR number is checked out first via `gh pr checkout`. `--rebase` rebases onto the remote default instead of merging it in
 - `assist signal next [id]` - Write a next signal to chain into `assist next`
 - `assist signal done [id]` - Write a done signal marking the session's initial task complete; an optional `id` surfaces the backlog item the session created onto its card
 

package/claude/commands/fix-conflict.md

@@ -6,26 +6,21 @@ Resolve the conflicts between this branch and the remote default branch, then pu
 
 The branch is already checked out — `assist fix-conflict <number>` checks the PR out before launching this session. Never switch branches.
 
-## Step 1: Find the remote default branch
+## Step 0: Pick the strategy
 
-```
-git remote show origin | sed -n 's/.*HEAD branch: //p'
-```
+If the arguments contain `--rebase`, follow the **rebase** flow (Steps R1–R4). Otherwise follow the **merge** flow (Steps M1–M4).
 
-Call the result `<default>`. If it comes back empty, fall back to `git symbolic-ref --short refs/remotes/origin/HEAD` and strip the `origin/` prefix.
-
-## Step 2: Fetch and merge
+Both flows start by finding the remote default branch:
 
 ```
-git fetch origin
-git merge origin/<default>
+git remote show origin | sed -n 's/.*HEAD branch: //p'
 ```
 
-If the merge reports "Already up to date" or completes cleanly with no conflicts, there is nothing to resolve — say so and stop. Do not push, do not create an empty commit.
+Call the result `<default>`. If it comes back empty, fall back to `git symbolic-ref --short refs/remotes/origin/HEAD` and strip the `origin/` prefix.
 
-## Step 3: Resolve every conflicted file
+## Resolving a conflicted file
 
-List the conflicts with `git diff --name-only --diff-filter=U`, then work through them one at a time:
+Both flows resolve conflicts the same way. List the conflicts with `git diff --name-only --diff-filter=U`, then work through them one at a time:
 
 1. Read the file and understand both sides. `git log --oneline origin/<default>..HEAD` and `git log --oneline HEAD..origin/<default>` show what each side changed and why.
 2. Write the resolution that keeps **both** intents. A conflict usually means two changes to the same region, not a choice between them — only drop a side when it is genuinely superseded.
@@ -43,13 +38,30 @@ Repeat until `git diff --name-only --diff-filter=U` is empty. Confirm no markers
 git grep -n '^<<<<<<< \|^>>>>>>> ' -- . || true
 ```
 
-## Step 4: Verify
+Note that during a rebase the sides are swapped: `--ours` is the upstream (`origin/<default>`) and `--theirs` is the commit being replayed.
+
+# Merge flow
+
+## Step M1: Fetch and merge
+
+```
+git fetch origin
+git merge origin/<default>
+```
+
+If the merge reports "Already up to date" or completes cleanly with no conflicts, there is nothing to resolve — say so and stop. Do not push, do not create an empty commit.
+
+## Step M2: Resolve every conflicted file
+
+Follow **Resolving a conflicted file** above.
+
+## Step M3: Verify
 
 Run `/verify`. Fix anything it reports — a merge that compiles on each side can still break where the two changes meet, so treat failures as part of the conflict resolution rather than pre-existing breakage.
 
-Do not proceed to Step 5 until verify passes.
+Do not proceed to Step M4 until verify passes.
 
-## Step 5: Commit and push
+## Step M4: Commit and push
 
 ```
 git commit --no-edit
@@ -60,8 +72,49 @@ git push
 
 Report the resolved files and the pushed SHA when done.
 
+# Rebase flow
+
+## Step R1: Fetch and rebase
+
+```
+git fetch origin
+git rebase origin/<default>
+```
+
+If the rebase completes with no conflicts, the branch is simply replayed — go straight to Step R3. If it reports the branch is already up to date and nothing was replayed, there is nothing to resolve — say so and stop without pushing.
+
+## Step R2: Resolve conflicts one commit at a time
+
+A rebase stops at each commit that conflicts. For every stop:
+
+1. Read `git status` to see which commit is being replayed (`git log -1 --oneline REBASE_HEAD`).
+2. Resolve the conflicted files following **Resolving a conflicted file** above, keeping that commit's intent intact — do not fold later commits' changes into an earlier one.
+3. `git rebase --continue`.
+
+If a replayed commit's changes have already landed upstream and it resolves to nothing, `git rebase --skip` is the right move — say which commit you skipped and why.
+
+Repeat until the rebase finishes. `git status` no longer reporting a rebase in progress is the signal.
+
+## Step R3: Verify
+
+Run `/verify`. Fix anything it reports — a rebase that replays cleanly per commit can still break where the two histories meet, so treat failures as part of the conflict resolution rather than pre-existing breakage.
+
+If a fix is needed, commit it on top rather than amending a replayed commit.
+
+Do not proceed to Step R4 until verify passes.
+
+## Step R4: Push
+
+```
+git push --force-with-lease
+```
+
+The rebase rewrote the branch's history, so a plain push is rejected. `--force-with-lease` is required and `--force` is not — the lease is what stops the push from clobbering commits someone else pushed while the session was running. If the push is rejected because the lease is stale, do not retry with `--force`: fetch, report what moved, and ask the user.
+
+Report the resolved files, any skipped commits, and the pushed SHA when done.
+
 ## Important
 
-- Never `git merge --abort` or reset without being asked — the user launched this session to get the conflicts resolved.
+- Never `git merge --abort`, `git rebase --abort`, or reset without being asked — the user launched this session to get the conflicts resolved.
 - Never force-push on the merge strategy; a plain `git push` is correct because the merge only adds a commit.
 - If a conflict genuinely cannot be resolved without a product decision, stop and ask the user rather than guessing.