> ## Documentation Index
> Fetch the complete documentation index at: https://docs.bloombot.cloud/llms.txt
> Use this file to discover all available pages before exploring further.

# Mute and jail

> Silence a member, take away images or reactions, or move them into a jail channel until they cool off.

Bloom can restrict what a member is able to do without removing them from the server. A mute takes away their voice, a narrower mute takes away only images or only reactions, and jail moves them out of the server entirely into a single channel where staff can talk to them.

## Choosing a restriction

| Restriction     | What it takes away                                      | Set up first     |
| --------------- | ------------------------------------------------------- | ---------------- |
| Discord timeout | Talking, reacting, and joining voice, for up to 28 days | Nothing          |
| Bloom mute      | Talking and speaking in voice, with no time limit       | `mutesetup`      |
| Image mute      | Attaching files and posting links                       | `mutesetup`      |
| Reaction mute   | Adding reactions                                        | `mutesetup`      |
| Jail            | Every channel except the jail channel                   | `jailsetup`      |
| Self mute       | Whatever the member chooses, on their own request       | `selfmute setup` |

<Info>
  A [Discord timeout](/moderation/punishments) needs no setup and lifts itself, so it is usually the right first reach. Bloom's own mute exists for restrictions that need to outlast Discord's 28 day ceiling, or that should take away only part of what a member can do.
</Info>

<Warning>
  `!mute` runs Bloom's mute, not a Discord timeout. They are different restrictions with different setup. Type `timeout` in full when you want Discord's.
</Warning>

## Setting up mutes

<ParamField path="mutesetup" type="Administrator">
  Creates the three mute roles and applies them across every channel in the server. Run it once before using any mute command.

  * **Bloom needs:** Manage Roles.
  * Creates **Muted**, **Image Muted**, and **Reaction Muted** if roles with those names do not already exist.
  * Adds the matching denials to every text, voice, announcement, stage, and forum channel.
  * Bloom reports how many channels it updated, and how many it could not.
</ParamField>

Each role denies a different set of permissions:

| Role           | Denied                                                                                                                       |
| -------------- | ---------------------------------------------------------------------------------------------------------------------------- |
| Muted          | Send Messages, Add Reactions, Connect, Speak, Request To Speak, Stream, Use Voice Activity, and the three thread permissions |
| Image Muted    | Attach Files, Embed Links                                                                                                    |
| Reaction Muted | Add Reactions                                                                                                                |

<Info>
  Bloom finds these roles **by name**. If you rename `Muted`, the mute commands stop finding it and build a new one. Change the role's color or position freely, but leave the name alone.
</Info>

<Tip>
  Channels created after you run `mutesetup` do not have the denials on them. Run `!mutesetup` again after a round of channel building and it will fill in what is missing.
</Tip>

## Muting a member

<ParamField path="mute <user> [duration] [reason] [-s]" type="Moderate Members">
  Gives the member the Muted role, which stops them talking in text and voice.

  * **Bloom needs:** Manage Roles, and a role above the member's highest role.
  * Without a duration the mute lasts until someone lifts it.
  * With a duration Bloom removes the role within about a minute of it running out.
  * `!mute @Someone 2h Arguing in general` replies `Successfully muted Someone for 2h.`
</ParamField>

<ParamField path="unmute <user> [reason] [-s]" type="Moderate Members">
  Removes the Muted role early. Replies `This user is not muted.` if they do not have it.
</ParamField>

<ParamField path="imute <user> [duration] [reason]" type="Moderate Members">
  Image mute. Stops the member attaching files or posting links, while leaving them able to talk.

  * `!imute remove @Someone` lifts it.
  * Needs `mutesetup` to have run. Bloom does not create this role on demand.
</ParamField>

<ParamField path="rmute <user> [duration] [reason]" type="Moderate Members">
  Reaction mute. Stops the member adding reactions and nothing else. Aliases: `reactionmute`, `reactmute`.

  * `!rmute remove @Someone` lifts it.
  * Needs `mutesetup` to have run.
</ParamField>

<Info>
  If you run `!mute` before `!mutesetup`, Bloom creates a basic Muted role on the spot, but it only blocks messages and reactions in text channels and speaking in voice. Run `mutesetup` to get the full set of denials, including threads.
</Info>

Every mute opens a [case](/moderation/cases), and the member gets a direct message with your reason unless you end the command with `-s`.

## Setting up jail

Jail hides every channel from the member and leaves them one place to talk. Set it up once, then use `jail` as needed.

<Steps>
  <Step title="Build the jail">
    Run `!jailsetup`. Bloom creates a **Jailed** role, a hidden **Jail** category with a `jail` channel inside it, and denies the Jailed role View Channel, Send Messages, and Connect on every other channel.
  </Step>

  <Step title="Adjust the settings">
    Run `!jailconfig` and use the **General Jail Settings** button to set the jail role, the jail channel, the message jailed members see, and whether their roles are stripped while jailed.
  </Step>

  <Step title="Test it on yourself">
    Ask another admin to jail you for a minute. Confirm you can see only the jail channel, and that your roles come back when the jail ends.
  </Step>
</Steps>

<ParamField path="jailsetup" type="Administrator">
  Creates the jail role, category, and channel, and locks the Jailed role out of everything else.

  * **Bloom needs:** Manage Roles and Manage Channels.
  * Reuses a role named `Jailed` and a `Jail` category if they already exist.
  * Channels that already have a Jailed overwrite are left alone, so it is safe to run again after adding channels.
</ParamField>

<ParamField path="jailconfig" type="Administrator">
  Opens a settings panel with two buttons, **General Jail Settings** and **Manage Chambers**, each opening a form.

  * General covers the jail role, jail channel, jail message, and whether to remove roles on jail.
  * The buttons stop responding after two minutes. Run the command again for a fresh panel.
  * Only the person who ran the command can use the buttons.
</ParamField>

<ParamField path="jailrole <role>" type="Administrator">
  Points the jail system at an existing role instead of the one `jailsetup` made. Takes a mention or a role ID.
</ParamField>

<ParamField path="jailchannel <channel>" type="Administrator">
  Sets the channel jailed members are sent to, and grants the jail role access to it. Alias: `setjailchannel`.
</ParamField>

<ParamField path="jailmessage <message>" type="Administrator">
  Sets the message posted in the jail channel when someone is jailed. Alias: `setjailmessage`.

  * Up to **500 characters**.
  * Supports `{user}`, `{reason}`, and `{duration}`, each used once. See [variables](/reference/variables#jail-messages).
  * Bloom shows you a filled in preview after saving.
  * The default is `You have been jailed for {reason} for {duration}.`
</ParamField>

<Warning>
  Bloom cannot use a jail role that sits at or above its own highest role, and clears the setting if you pick one. Keep the Jailed role below Bloom in the role list.
</Warning>

## Jailing a member

<ParamField path="jail <user> [duration] [reason] [-s]" type="Manage Messages">
  Moves a member into the jail channel.

  * **Bloom needs:** Manage Roles and Manage Channels, and a role above the member's.
  * Without a duration the jail lasts until someone lifts it.
  * `!jail @Someone 12h Ban evasion, pending review` jails them for twelve hours.
</ParamField>

<ParamField path="unjail <user> [reason] [-s]" type="Manage Messages">
  Releases a member, restores the roles that were taken, and cleans up their private channel if chambers mode is on.
</ParamField>

### What happens to their roles

If **remove roles** is turned on in `jailconfig`, Bloom takes the member's roles when it jails them and gives them back on release. It saves the list first and only removes the roles once the save is confirmed.

Four kinds of role are never touched:

* The `@everyone` role.
* The server's booster role.
* Roles managed by another bot or integration.
* Roles above Bloom's own highest role.

<Warning>
  Roles Bloom cannot manage stay on the member while they are jailed. If one of those roles grants access to a channel, the member keeps that access from inside jail. Check that staff and access roles sit below Bloom before relying on jail to isolate someone.
</Warning>

## Private jail channels

Chambers mode gives each jailed member their own channel instead of putting everyone in one shared jail. Turn it on from `!jailconfig` with the **Manage Chambers** button, which also asks for the category the channels are made in and a channel to send transcripts to.

When someone is jailed with chambers on, Bloom creates a `jail-<name>` text channel in that category. The member can read and write in it, but cannot attach files or post links.

When they are released, whether by `unjail` or by the jail running out, Bloom writes a transcript of that channel, posts it to the transcript channel as a text file, and deletes the channel. Releases that happen on expiry are recorded as `System (Time Expired)`.

<Info>
  Chambers mode needs a category set before it will work. If you turn it on without one, `jail` refuses and tells you to set the category first.
</Info>

<Warning>
  Deleting a chamber channel by hand throws away the conversation. Release the member with `!unjail` instead, which saves the transcript before removing the channel.
</Warning>

## Letting members mute themselves

Self mute is an opt-in tool for members who want to stay out of chat for a while. It uses its own role and its own channel list, separate from the moderation mutes.

<ParamField path="selfmute setup" type="Administrator">
  Creates the **Self Muted** role and turns the system on.

  * **Bloom needs:** Manage Roles and Manage Channels.
  * Afterwards you must add at least one channel before anyone can use it.
</ParamField>

<ParamField path="selfmute channel <add|remove|list> [channel]" type="Administrator">
  Chooses where the self mute applies. Adding a channel denies the Self Muted role Send Messages, Add Reactions, Speak, and Stream there. Removing one clears that denial.

  * Text and voice channels only.
</ParamField>

<ParamField path="selfmute <duration>" type="Anyone">
  Mutes the member who ran it, in the channels an administrator set up.

  * Between **10 minutes and 10 hours**.
  * One at a time. Bloom refuses a second while one is running.
  * `!selfmute 45m` replies with when the mute lifts.
</ParamField>

<ParamField path="selfmute cancel" type="Anyone">
  Ends your own self mute early. `!selfmute cancel @Someone` ends someone else's and needs Administrator.
</ParamField>

<ParamField path="selfmute <enable|disable>" type="Administrator">
  Turns the system on or off for the whole server without losing the setup.
</ParamField>

<Info>
  A self mute can be cancelled by the member at any time, so treat it as a focus aid rather than a commitment they cannot back out of.
</Info>

## Troubleshooting

<AccordionGroup>
  <Accordion title="The Image Muted role hasn't been set up. Please run mutesetup first.">
    `imute` and `rmute` do not create their roles on demand. Run `!mutesetup` once and both commands start working.
  </Accordion>

  <Accordion title="A muted member can still talk in one channel">
    That channel has a permission overwrite that allows Send Messages for a role the member holds, and a channel level allow beats the mute role's deny. Fix the overwrite on the channel, or run `!mutesetup` again if the channel is new.
  </Accordion>

  <Accordion title="I cannot mute this user. They may have higher permissions than me.">
    Bloom's role is at or below the member's highest role, so it cannot add or remove roles for them. Move Bloom's role up in **Server Settings → Roles**.
  </Accordion>

  <Accordion title="Jail system is not set up. Please run jailsetup first.">
    There is no jail role saved, or chambers is off and no jail channel is set. Run `!jailsetup`, then `!jailconfig` to confirm both are filled in.
  </Accordion>

  <Accordion title="A jailed member can still see other channels">
    Those channels were created after `jailsetup` ran, so they have no denial for the Jailed role. Run `!jailsetup` again to fill in the gaps. If it persists, the member holds a role above Bloom's that Bloom could not remove.
  </Accordion>

  <Accordion title="Roles did not come back after an unjail">
    Role removal has to be turned on in `jailconfig` for Bloom to save them in the first place. Roles that were above Bloom's own role were never removed, and roles deleted while the member was jailed cannot be restored.
  </Accordion>

  <Accordion title="The mute did not lift when it ran out">
    Bloom checks for expired restrictions every minute, so allow a moment. A mute applied by hand, by adding the role directly, has no expiry attached and stays until someone removes it.
  </Accordion>
</AccordionGroup>

## Related pages

<CardGroup cols={2}>
  <Card title="Bans, kicks, and timeouts" icon="gavel" href="/moderation/punishments">
    Discord timeouts and the actions that remove a member outright.
  </Card>

  <Card title="Warnings, cases, and staff records" icon="clipboard-list" href="/moderation/cases">
    Every mute and jail opens a case you can read back later.
  </Card>

  <Card title="Durations and time zones" icon="clock" href="/reference/time">
    The time format these commands expect.
  </Card>

  <Card title="Variables and placeholders" icon="brackets-curly" href="/reference/variables">
    The tokens a jail message can use.
  </Card>
</CardGroup>