continue

Resume a paused loom operation after resolving rebase conflicts.

Usage

git loom continue

When to Use It

When an in-scope loom command (commit, update, absorb, drop, fold) encounters a rebase conflict, it pauses instead of aborting. The operation is saved to .git/loom/state.json and the process exits with code 0.

The terminal output shows which files are conflicted and what to do next:

! Conflicts detected — resolve them with git, then run:
  loom continue   to complete the commit
  loom abort      to cancel and restore original state

Once you’ve resolved conflicts and staged the resolution:

# resolve conflicts in your editor, then:
git add <resolved-files>
git loom continue

What It Does

1. Loads the saved state from .git/loom/state.json
2. If a rebase is still in progress, runs git rebase --continue
   • If that stops again (a conflict, or anything else): stays paused, keeps the state file, exits successfully
   • If it only reaches the next edit step: stays paused, keeps the state file, says so
   • If it completes: moves on
3. If no rebase is in progress (e.g. you already ran git rebase --continue manually): skips to dispatch
4. Dispatches to the interrupted command’s post-rebase work (restoring staged patches, printing the success message, etc.)
5. Deletes the state file on success

Double Conflicts

If your branch has multiple conflicting commits, each loom continue may hit a new conflict at the next commit. Repeat the resolve-and-continue cycle as many times as needed:

git loom commit -b feature-auth -m "add auth" zz
# ! Conflicts detected...

git add auth.rs && git loom continue
# ! Conflicts remain — resolve them and run `loom continue` again

git add shared.rs && git loom continue
# ✓ Created commit `a1b2c3d` on branch `feature-auth`

Which Commands Are Paused

Commands Allowed While Paused

While a loom operation is paused, most commands are blocked. The following are still available:

• show — inspect commits
• trace — check recent command output
• continue — resume the paused operation
• abort — cancel the paused operation

Without a Saved State File

If git has a rebase or merge in progress that no loom state file describes, loom continue drives it (git rebase --continue, or git merge --continue) and reports the outcome, including a rebase that only reached the next edit step.

git loom continue
# ✓ Completed the rebase git had in progress (no loom state, so nothing else was done)

Only git’s own step runs: with no state file there is no command to finish off, so no saved patch is re-staged, no temp branch removed, and no per-command success line such as ✓ Updated branch … is printed — just the generic line above.

Pausing at an edit Step

git rebase --continue exits successfully when it only advances to the next edit step, so a completed run and a rebase that is still half-done look the same from outside. Loom checks and says which one happened:

! The `loom drop` is paused at an `edit` step — finish the work there, then run:
  `loom continue`   to carry on
  `loom abort`      to cancel and restore original state

With no state file there is no command to name, so the line opens with “The rebase is paused at an edit step”, and loom abort is offered as “to cancel it (no loom state to roll back)” — there is nothing else to undo.

Error: No Operation in Progress

With neither a state file nor a rebase or merge in progress:

git loom continue
# error: No loom operation is in progress

See Also

• abort — cancel instead of resuming