bootstrap user ' ' requires group ' ', but that group is…

Error message

bootstrap user '{}' requires group '{group}', but that group is absent

What it means

A bootstrap user lists a group in its group/groups fields, but that group is explicitly declared with state=absent elsewhere in the bootstrap accounts config. Since the user cannot join a group that bootstrap is deleting, mise fails fast with a configuration contradiction.

Solutions

Remove the group from the user's group/groups lists.
Change the group's state to "present" (or delete its absent declaration) if it should exist.
Run `mise bootstrap plan` to verify group/user consistency after edits.

Example fix

// before
[[bootstrap.groups]]
name = "docker"
state = "absent"
[[bootstrap.users]]
name = "ci"
groups = ["docker"]

// after
[[bootstrap.groups]]
name = "docker"
state = "absent"
[[bootstrap.users]]
name = "ci"
groups = []

Defensive patterns

Strategy: validation

Validate before calling

function validateGroupRefs(config) {
  const absent = new Set(config.groups.filter((g) => g.state === 'absent').map((g) => g.name));
  for (const u of config.users) {
    const refs = [u.group, ...(u.groups || [])].filter(Boolean);
    for (const g of refs) {
      if (absent.has(g)) throw new Error(`user '${u.name}' references absent group '${g}'`);
    }
  }
}

Try / catch

try {
  await mise.bootstrap.apply(config);
} catch (e) {
  if (String(e).includes("but that group is absent")) {
    console.error('Remove the group from the user or keep the group present:', e.message);
  } else throw e;
}

Prevention

Cross-check user group references against declared groups in CI.
When deleting a group, update all user entries that reference it.
Run `mise bootstrap plan` to surface contradictions.

When it happens

Trigger: user.groups or user.group references a group name whose corresponding [[bootstrap.groups]] entry has state="absent".

Common situations: Removing an old group while user entries still reference it; copying user definitions from another config that assumes the group exists; refactoring group names without updating users.

Understand the failure class

Background: Conflicting config options: "cannot be used together" — configuration validation errors across open-source libraries — this error's family across 162 libraries.

Related errors

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

Appendix: source

Thrown at src/system/accounts.rs:608

    }
}

fn validate_requests(groups: &[GroupRequest], users: &[UserRequest]) -> Result<()> {
    let managed_groups = groups
        .iter()
        .map(|group| (group.name.as_str(), group.state))
        .collect::<IndexMap<_, _>>();
    for user in users
        .iter()
        .filter(|user| user.state == AccountState::Present)
    {
        for group in user
            .group
            .iter()
            .chain(user.groups.iter().flat_map(|groups| groups.iter()))
        {
            match managed_groups.get(group.as_str()) {
                Some(AccountState::Absent) => bail!(
                    "bootstrap user '{}' requires group '{group}', but that group is absent",
                    user.name
                ),
                Some(AccountState::Present) => {}
                None if nix::unistd::Group::from_name(group)?.is_none() => bail!(
                    "bootstrap user '{}' requires undeclared group '{group}'",
                    user.name
                ),
                None => {}
            }
        }
    }
    Ok(())
}

fn inspect_user(name: &str, desired_uid: Option<u32>) -> Result<UserInspection> {
    let Some(user) = nix::unistd::User::from_name(name)? else {
        return match desired_uid {

View on GitHub (pinned to 533346cc37)