checkpoint {} is still running or was interrupted; nothing t

Error message

checkpoint {} is still running or was interrupted; nothing to undo

What it means

A checkpoint whose operation status is Pending is either still executing or was interrupted mid-run. Its file state is not final, so undoing from it would restore an inconsistent snapshot; mise refuses to undo such checkpoints.

Source

Thrown at src/system/history/replay.rs:276

        None => entries
            .iter()
            .rev()
            .find(|entry| {
                entry.checkpoint.operation.as_ref().is_some_and(|op| {
                    op.status != OperationStatus::Pending
                        && op.before.is_some()
                        && !op.affected.is_empty()
                }) && !undone.contains(&entry.checkpoint.uuid)
            })
            .cloned()
            .ok_or_else(|| eyre::eyre!("nothing to undo: no tracked-file operation is left"))?,
    };
    let Some(op) = operation.checkpoint.operation.clone() else {
        bail!("checkpoint {} is not an operation", operation.id);
    };
    // Undo restores tracked files only, never package or service state.
    if op.status == OperationStatus::Pending {
        bail!(
            "checkpoint {} is still running or was interrupted; nothing to undo",
            operation.id
        );
    }
    if op.status == OperationStatus::Failed && !op.affected.is_empty() {
        info!(
            "history: operation {} failed midway; reversing the {} path(s) it changed",
            operation.id,
            op.affected.len()
        );
    }
    let Some(before_uuid) = &op.before else {
        bail!(
            "checkpoint {} has no protective checkpoint to undo from",
            operation.id
        );
    };
    let Some(before) = entries

View on GitHub (pinned to afd2eddd3a)

Solutions

Wait for the running operation to finish, then retry undo
If the operation was interrupted, let the failed-operation path handle it or manually resolve the checkpoint status
Inspect history to confirm the checkpoint's status before undoing

Example fix

// before
mise bootstrap dotfiles undo   # checkpoint still Pending
// after
# wait for the running operation to complete, then:
mise bootstrap dotfiles undo

Defensive patterns

Strategy: validation

Validate before calling

const entry = await getCheckpoint(id);
if (entry?.checkpoint?.operation?.status === "pending") {
  throw new Error("checkpoint still running or interrupted");
}

Type guard

const isFinished = (op: Operation): op is Operation & { status: Done | Failed } =>
  op.status !== OperationStatus.Pending;

Try / catch

try {
  await undo();
} catch (e) {
  if (String(e).includes("still running or was interrupted")) {
    await waitForOperation(id);
    await undo();
  } else throw e;
}

Prevention

Avoid concurrent operations on the same dotfiles store
After a crash, finalize or clean up Pending checkpoints before undo
Poll operation status until terminal before issuing undo

When it happens

Trigger: Running undo against a checkpoint whose OperationStatus is Pending — the operation is concurrently running in another session, or a previous operation crashed and left its checkpoint marked Pending.

Common situations: Two terminal sessions where one is mid-install while the other undoes; a crashed operation (killed process, power loss) leaving a stale Pending checkpoint in history.

Understand the failure class

Background: "Invalid state transition" errors: "status must be X, actually Y", "already rejected/charging/uninstalled", "cannot ... while running" — what they mean when a library rejects your call — this error's family across 31 libraries.

Related errors

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