sync paused: resolve conflicts across the complete repositor

Error message

sync paused: resolve conflicts across the complete repository before publication: {}

What it means

When the local branch and origin diverge, mise merges their trees. Conflicting paths must be explicitly accepted by the user (recorded in the `accepted` set) before publication. If any conflict path remains unaccepted, publication is paused and the conflicting paths are listed, because publishing with unresolved conflicts would silently drop one side's changes across the complete repository.

Source

Thrown at src/system/history/sync/publish.rs:55

        // line merge can conflict on independent additions or combine policy
        // changes into invalid metadata. Validate its structured merge first.
        if let Some(base) = &heads.base {
            use crate::system::history::manifest::Manifest;
            if let (Some(base), Some(ours), Some(theirs)) = (
                Manifest::read(repo, base)?,
                Manifest::read(repo, local)?,
                Manifest::read(repo, remote)?,
            ) {
                merged = Manifest::merge(&base, &ours, &theirs)?.write(repo, &merged)?;
                conflicts.retain(|path| path != crate::system::history::manifest::PATH);
            }
        }
        let unresolved: Vec<_> = conflicts
            .iter()
            .filter(|path| !accepted.contains(*path))
            .collect();
        if !unresolved.is_empty() {
            bail!(
                "sync paused: resolve conflicts across the complete repository before publication: {}",
                unresolved
                    .into_iter()
                    .map(String::as_str)
                    .collect::<Vec<_>>()
                    .join(", ")
            );
        }
        // Accepted choices were validated against saved, live, and remote
        // versions. Carry their already-encrypted saved objects, not a new
        // plaintext publication representation.
        let overlays = conflicts
            .into_iter()
            .map(|path| {
                Ok(crate::system::history::shadow::Overlay {
                    object: repo.object_at(local, &path)?,
                    path,
                })

View on GitHub (pinned to afd2eddd3a)

Solutions

Run the reconcile flow (`mise bootstrap dotfiles pull`) and resolve every listed conflict path, accepting a version for each.
Re-run publication once all conflict paths are in the accepted set.
If publishing programmatically, supply resolutions for every conflicted path up front instead of leaving any unresolved.

Example fix

// before: publish with only some conflicts accepted
accepted = {"~/.config/mise/mise.toml"}
mise bootstrap dotfiles publish   # ~/.bashrc still unresolved -> paused
// after
mise bootstrap dotfiles pull      # resolve ~/.bashrc (and any others)
mise bootstrap dotfiles publish

Defensive patterns

Strategy: validation

Validate before calling

const { conflicts } = await mergeTree(local, remote);
const unresolved = conflicts.filter((p) => !accepted.has(p));
if (unresolved.length > 0) {
  throw new Error(`resolve conflicts before publication: ${unresolved.join(", ")}`);
}

Type guard

const allResolved = (conflicts, accepted) => conflicts.every((p) => accepted.has(p));

Try / catch

try {
  await publish();
} catch (e) {
  const m = String(e.message).match(/before publication: (.+)$/);
  if (m) {
    const paths = m[1].split(", ");
    for (const p of paths) await promptAndAccept(p);
    await publish();
  } else throw e;
}

Prevention

Always run the interactive reconcile and resolve every listed path, not just some.
Pull regularly so divergence (and thus conflicts) stays small.
When publishing from scripts, pre-populate resolutions for every conflicted path.

When it happens

Trigger: In publish `build`, `repo.merge_tree(local, remote)` yields conflicts; after structured manifest merging removes the manifest path conflict, any remaining conflict path not present in `accepted` triggers the bail, listing all unresolved paths comma-separated.

Common situations: Two machines edited the same managed file or enrollment entry offline and both pushed; the user answered some conflict prompts but skipped others; an automated publish ran non-interactively without supplying conflict resolutions.

Related errors

AI-assisted analysis of jdx/mise@afd2eddd3a (2026-09-09). Data as JSON: /api/errors/ced31d714113867d. Report an issue: GitHub.