diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
index 20ca13d..576d26a 100644
--- a/.github/workflows/docker-publish.yml
+++ b/.github/workflows/docker-publish.yml
@@ -6,13 +6,37 @@ on:
       - main
     tags:
       - 'v*.*.*'
+  pull_request:
 
 permissions:
   contents: read
   packages: write
 
 jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v3
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: pip install --no-cache-dir -r requirements-dev.txt
+
+      - name: Import smoke test (catch circular imports)
+        run: python -c "import hutbot, hutbot.state, hutbot.actions, hutbot.buttons, hutbot.scheduling, hutbot.routing, hutbot.commands.dispatch, hutbot.webui_backend"
+
+      - name: Run tests
+        run: python -m pytest
+
   build-and-push:
+    needs: test
+    if: github.event_name == 'push'
     runs-on: ubuntu-latest
 
     steps:
@@ -29,11 +53,23 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      # Tag pushes (v*.*.*) publish immutable release tags only, so deployments can
+      # pin an exact version. Pushes to main additionally move the `main`/`latest`
+      # floating tags, which are for convenience only and must not be deployed.
+      - name: Compute image tags
+        id: tags
+        run: |
+          image=ghcr.io/mittwald/hutbot
+          if [ "$GITHUB_REF_TYPE" = "tag" ]; then
+            tags="$image:$GITHUB_REF_NAME,$image:${GITHUB_REF_NAME#v}"
+          else
+            tags="$image:$GITHUB_REF_NAME,$image:latest"
+          fi
+          echo "tags=$tags" >> "$GITHUB_OUTPUT"
+
       - name: Build and push Docker image
         uses: docker/build-push-action@v4
         with:
           context: .
           push: true
-          tags: |
-            ghcr.io/mittwald/hutbot:latest
-            ghcr.io/mittwald/hutbot:${{ github.ref_name }}
\ No newline at end of file
+          tags: ${{ steps.tags.outputs.tags }}
diff --git a/.gitignore b/.gitignore
index 6ea8b91..4fdee46 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,5 @@ employees.json
 .env
 .codex
 scheduled_replies.json
+button_states.json
+.env-dev
diff --git a/Dockerfile b/Dockerfile
index 4375039..3f9bfd5 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -8,4 +8,6 @@ RUN pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-ENTRYPOINT ["python", "bot.py"]
+EXPOSE 8080
+
+ENTRYPOINT ["python", "-m", "hutbot"]
diff --git a/README.md b/README.md
index 6a27b4c..d5ef24a 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,7 @@
 
 The hutbot is a simple Slack bot that monitors messages in a channel and automatically replies in a thread if no one reacts or responds to the message within a configurable time period (by default 30 minutes). The bot reminds channel members that a message has gone unanswered. Scheduled reminders are cancelled when someone replies in the thread or reacts in a way that does not match the config criteria that caused that reminder to be scheduled, or when the original message is deleted. Users can adjust both the waiting time and the reminder message directly within the channel, including `{{variable}}` placeholders in the reminder text.
 
-Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
+Reply messages support built-in placeholders such as `{{user}}`, `{{channel}}`, and `{{message_link}}`. `{{date}}`, `{{time}}`, and `{{datetime}}` render the triggering message's time — or the time the rule ran, for `cron`/`manual` triggers and for `test`/`run` — using the config's date/time format, timezone, and locale, and take the same `fmt`/`tz`/`lc` arguments as the Opsgenie date/time variables below. `{{timestamp}}` is the raw Slack timestamp of the same instant. If a channel config also has an Opsgenie schedule configured via `/hutbot [config] set opsgenie-schedule <name>`, Hutbot can resolve the current on-call person and expose:
 
 - `{{opsgenie_schedule_name}}` for the configured schedule
 - `{{opsgenie_current_user}}` for a Slack `@mention`
@@ -22,12 +22,227 @@ Opsgenie date/time variables support `fmt`/`format`, `tz`/`timezone`, and `lc`/`
 /hutbot [config] set datefmt "<date>" "<time>" [<timezone> <locale>]
 ```
 
+The `<timezone>` is also the timezone the config's work days and work hours are
+counted in — `/hutbot [config] set work-hours 9:00 17:00`, `/hutbot [config] clear work-hours` to
+react at any hour, and `/hutbot [config] enable only-work-days` for Mon–Fri only. Without a
+timezone, all of them fall back to the server's local time.
+
+Instance-wide defaults for configs that set neither come from the deployment
+(`time.timezone` / `time.locale` in the Helm chart, `HUTBOT_TIMEZONE` /
+`HUTBOT_DEFAULT_DATETIME_LOCALE` for `helmfile`):
+
+- `time.timezone` is the container's `TZ`, i.e. the server local timezone. The
+  image itself is UTC, so without it every config that sets no timezone formats
+  and counts work hours in UTC.
+- `time.locale` is the fallback date/time locale. Only `de` has translations;
+  every other locale renders English day/month names. The server's own `LANG` is
+  never used for this.
+
+Neither has a default: without them the instance runs UTC with English names.
+The `.env` / `.env-dev` files the deploy scripts source are the place to set
+them, e.g. `HUTBOT_TIMEZONE='Europe/Berlin'` and
+`HUTBOT_DEFAULT_DATETIME_LOCALE='de_DE'`.
+
+`show config` prints what a config actually ends up with, e.g.
+`Date/time timezone  Europe/Berlin (CEST, UTC+02:00, server local time)` and
+`Date/time locale    de_DE (instance default)`.
+
 Opsgenie alert priority defaults to `P4` and can be configured per channel config with:
 
 ```bash
 /hutbot [config] set opsgenie-priority <P1|P2|P3|P4|P5>
 ```
 
+## Triggers, conditions, and actions
+
+Beyond the classic "reply if a message goes unanswered" behavior, each named config is a **rule**
+with a `trigger`, an optional `condition`, and an `action`. The trigger defaults to `message`, so
+existing configs keep working unchanged.
+
+- **Triggers** (`/hutbot [config] set trigger <trigger> [<cron expression>]`). The cron trigger
+  carries its expression, so a rule can never be left with a schedule that never fires.
+  - `set trigger message` — the classic behavior (matches channel messages by pattern/teams/hours).
+  - `set trigger cron "0 9 * * 1-5"` — fires on a 5-field cron schedule, in the config's date/time
+    timezone (see `set datetime-format`) or server local time without one. `schedule` and
+    `scheduled` are accepted as names for this trigger.
+  - `set trigger manual` — never fires on its own; used as the target of a button or a button timeout.
+
+- **Conditions** (`/hutbot [config] set condition <none|outlook>`) gate a `cron` trigger.
+  - `outlook` — matches Outlook calendar entries by `set outlook-subject <regex>` /
+    `set outlook-body <regex>`. Use `enable negate` to fire when *no* matching entry exists.
+    **Note:** the Outlook integration is currently a stub (events come from the
+    `HUTBOT_OUTLOOK_STUB_EVENTS` env var); the real implementation lands in a later task.
+
+- **Actions** (`/hutbot [config] set action <action> [<target>]`) decide what the rule does, using
+  `reply_message` (with the usual `{{variables}}`) as the body. The recipient is part of the same
+  command, so a config can never be left with an action that has nowhere to send.
+  - `set action reply` — post in the rule's channel. Takes no target.
+  - `set action dm-user <@user>` — DM a single user.
+  - `set action group-dm <@usergroup>` — open one group DM (mpim) with all members of a Slack user
+    group and post once (Slack caps a group DM at 8 members).
+  - `set action post-channel <#channel>` — post to another channel. Pick the channel from Slack's
+    autocomplete so it arrives as a link, or pass its `C…` id.
+
+- **Buttons** attach interactive buttons to the message a rule sends (including the classic
+  unanswered-message reply). Each button is added incrementally with a typed action (the leading
+  `add`, like `set` elsewhere, is optional):
+  - `/hutbot [config] add button "<label>" config <config>` — run another config (a `manual` rule).
+  - `/hutbot [config] add button "<label>" ack [text]` — mark the message handled: stop any
+    escalation, remove the buttons, and post `[text]` in the thread when given. Like a reply message,
+    the text may use `{{variables}}` and `@mentions`, both resolved against the *original* message
+    when pressed.
+  - `/hutbot [config] add button "<label>" delay <minutes>` — push the escalation out by N minutes
+    and leave the buttons in place (the only button that does not consume the message). It needs an
+    escalation to postpone, so set one first; `clear escalation` warns if it strands such a button.
+  - `/hutbot [config] clear buttons`
+  - `/hutbot [config] set escalation <minutes> button "<label>"` — if nobody presses within
+    `<minutes>`, auto-press that button (exactly as a human click would).
+  - `/hutbot [config] set escalation <minutes> config <config>` — …or run that config instead.
+  - `/hutbot [config] clear escalation` — never escalate; the buttons stay open until pressed.
+    The timeout and its target are one setting, so a timer can never exist with nothing to fire.
+    Pending escalations survive restarts.
+  - A button/timeout that runs a config passes the **original message context** to it, so the target's
+    templates and any OpsGenie alert reference the original message.
+  - Once a message is handled, its buttons are removed and replaced by a one-line note of what
+    happened: *Dave Grieser: [I've got it]* or *Dave Grieser: [Page] ▶︎ alarm* for a press, and
+    *⌛︎ 1m* or *⌛︎ 5m ▶︎ alarm* when the escalation acted instead.
+
+- **"Need help?" example** — a question that defaults to "Yes" if ignored:
+  ```bash
+  /hutbot helpcheck set message Need help?
+  /hutbot helpcheck add button "Yes" ack "Here's the help doc: …"
+  /hutbot helpcheck add button "No" ack
+  /hutbot helpcheck set escalation 5 button "Yes"
+  ```
+  Pressing *Yes* posts the help message; *No* dismisses it; if nobody clicks within 5 minutes, Hutbot
+  auto-presses *Yes* and posts the help message.
+
+- **OpsGenie is just a config property**: any config that runs and has OpsGenie enabled sends an alert
+  (with `set opsgenie-message "<template>"` to customise the alert text; default is the original
+  message). So to **button-gate** an alert, put OpsGenie on a *separate* `manual` config and run it
+  from a button or the escalation — don't put OpsGenie on the question config itself (or it would
+  alert as soon as the question is posted). Example:
+  ```bash
+  # question — no OpsGenie
+  /hutbot incident set message Incident — on it?
+  /hutbot incident add button "I've got it" ack
+  /hutbot incident set escalation 5 config page-oncall   # page if nobody acknowledges
+  # alert config — OpsGenie on, runs only when escalated (or via a Yes-style button)
+  /hutbot page-oncall set trigger manual
+  /hutbot page-oncall enable opsgenie
+  /hutbot page-oncall set opsgenie-schedule "Team Primary"
+  /hutbot page-oncall set opsgenie-message "Unanswered incident in {{channel}}: {{message}}"
+  ```
+  *I've got it* cancels the escalation (no page); otherwise after 5 minutes `page-oncall` runs and pages
+  on-call, referencing the original message. A `delay` button pushes the 5-minute timer out.
+
+Use `/hutbot [config] run` to fire a configuration's action immediately (handy for testing).
+
+## Leaving and rejoining a channel
+
+Configurations outlive channel membership, so removing the bot from a channel would otherwise leave
+`cron` rules firing (and pending reminders/escalations coming due) for a channel it can no longer
+post in. When Hutbot is removed from a channel (kicked, or `/remove`d):
+
+- every enabled configuration of that channel is disabled and marked as *disabled because Hutbot was
+  removed* (`disabled_reason`), which `/hutbot show config` and the web UI show;
+- all pending reminders scheduled for that channel are cancelled;
+- all pending button escalations are dropped — both those posted in that channel and those posted
+  elsewhere by one of its rules (so nothing escalates into a now-disabled configuration).
+
+Configurations are **not** re-enabled automatically. When Hutbot is added back it posts a message
+listing the configurations it disabled, which can then be re-enabled with `/hutbot [config] enable`
+(or the web UI). Configurations that a user had disabled by hand are left alone and are not part of
+that message.
+
+## Web configuration UI
+
+Hutbot can serve a small web UI from the **same bot process** (no separate service) that lets a
+logged-in user view and edit the Hutbot rule configuration for the Slack channels they belong to. It
+shows configuration only — there is no message log or analytics. It is **disabled by default**.
+
+The UI is intended to run behind a Keycloak-fronting reverse proxy (e.g. oauth2-proxy). The proxy
+authenticates the user and passes their email in a trusted HTTP header. Hutbot resolves that email to
+a Slack user (reusing the same employee-list / Slack mapping the bot already uses), determines their
+team, and lists the channels that (a) have a Hutbot config **and** (b) the user is a member of.
+Editing is gated by channel membership.
+
+> **Security model:** Hutbot **trusts** the configured header. You **must** ensure the bot's HTTP port
+> is only reachable through the authenticating proxy (in Kubernetes the Helm chart's NetworkPolicy plus
+> a ClusterIP Service + Ingress do this). Anyone able to reach the port directly could spoof the header.
+
+### Enabling it locally
+
+```bash
+export HUTBOT_UI_ENABLED=1
+# optional overrides:
+export HUTBOT_UI_PORT=8080            # default 8080
+export HUTBOT_UI_HOST=0.0.0.0         # default 0.0.0.0
+export HUTBOT_UI_USER_HEADER=X-Forwarded-Email   # default
+python -m hutbot
+```
+
+Then test with a manual header:
+
+```bash
+curl -H "X-Forwarded-Email: you@yourcompany.com" http://localhost:8080/api/me
+curl -H "X-Forwarded-Email: you@yourcompany.com" http://localhost:8080/api/channels
+```
+
+Open http://localhost:8080/ in a browser (send the header via a browser extension or your local proxy
+during development). Without a valid, resolvable header the API returns `403`.
+
+### Header per proxy
+
+Set `HUTBOT_UI_USER_HEADER` to match the header your proxy sends:
+
+- **oauth2-proxy** → `X-Forwarded-Email` (default)
+- **Keycloak gatekeeper (louketo)** → `X-Auth-Email`
+- **custom nginx `auth_request`** → whatever header you configure
+
+### Endpoints
+
+- `GET /healthz` — unauthenticated, for Kubernetes probes.
+- `GET /api/me`, `GET /api/meta`, `GET /api/channels` — require a resolvable user.
+- `GET`/`PUT`/`POST`/`DELETE` `/api/channels/{id}/configs[/{name}]` — require a resolvable user, and
+  channel routes additionally require membership of the channel.
+
+### Kubernetes / Helm
+
+Enable the UI through the chart with the following `values.yaml` keys under `ui:`:
+
+```yaml
+ui:
+  enabled: true
+  port: 8080
+  userHeader: "X-Forwarded-Email"
+  service:
+    type: ClusterIP
+  ingress:
+    enabled: true
+    className: "nginx"
+    host: "hutbot.internal.example.com"
+    annotations: {}   # put your Keycloak/oauth2-proxy auth annotations here
+    tls: []
+```
+
+When `ui.enabled` is `true` the chart renders a Service, exposes the container port, adds `/healthz`
+readiness/liveness probes, and opens the NetworkPolicy ingress for that port; the Ingress is rendered
+when `ui.ingress.enabled` is also `true`. The Keycloak integration itself (oauth2-proxy / annotations)
+is the operator's responsibility — Hutbot only consumes the resulting header.
+
+> **Security:** the UI trusts the proxy-set email header, so any pod able to reach the UI port can
+> spoof it and edit configs. Restrict the NetworkPolicy ingress to your auth proxy / ingress
+> controller with `ui.allowedIngress` (a list of NetworkPolicy peers rendered into the rule's `from:`).
+> Leaving it empty allows all sources (back-compat) and is not recommended:
+> ```yaml
+> ui:
+>   allowedIngress:
+>     - namespaceSelector:
+>         matchLabels:
+>           kubernetes.io/metadata.name: ingress-nginx
+> ```
+
 ## Step 1: Set Up the Slack App
 
 1. **Create a New Slack App**
@@ -80,8 +295,17 @@ Opsgenie alert priority defaults to `P4` and can be configured per channel confi
      - `message.groups`
      - `message.im`
      - `message.mpim`
+     - `member_joined_channel`
+     - `member_left_channel`
+
+6. **Enable Interactivity** (required for buttons)
+
+   - Go to **"Interactivity & Shortcuts"**.
+   - Turn on **"Interactivity"**.
+   - Because the app uses **Socket Mode**, no Request URL is needed — interactive
+     button presses (`block_actions`) are delivered over the same socket.
 
-6. **Add Slash Command**
+7. **Add Slash Command**
 
    - Go to **"Slash Commands"**.
    - Click **"Create New Command"**.
@@ -89,7 +313,7 @@ Opsgenie alert priority defaults to `P4` and can be configured per channel confi
    - Set the short description to `Configure @Hutbot`.
    - Click **"Save"**.
 
-7. **Install the App**
+8. **Install the App**
 
    - Go to **"Install App"**.
    - Click **"Install App to Workspace"** and authorize the app.
@@ -101,10 +325,11 @@ Opsgenie alert priority defaults to `P4` and can be configured per channel confi
 export SLACK_BOT_TOKEN='xoxb-your-bot-token'
 export SLACK_APP_TOKEN='xapp-your-app-level-token'
 pip install -r requirements.txt
-python bot.py
+python -m hutbot
 ```
 
    - See [Hutbot Slack App](https://api.slack.com/apps/A07RQ54Q5H9)
+   - See [Hutbot_DEV Slack App](https://api.slack.com/apps/A0BN19HUTAP)
    - Hosted at `nexus-cli get projects p-knksv4 -olink`
 
 9. **Invite Bot**
@@ -115,13 +340,29 @@ python bot.py
 
 ## Docker and Kubernetes Deployment
 
-A GitHub Actions workflow automatically builds and publishes the Docker image to GitHub Container Registry on pushes to `main` and tags `v*.*.*`. You can pull the image with:
+A GitHub Actions workflow automatically builds and publishes the Docker image to GitHub Container
+Registry on pushes to `main` and on tags matching `v*.*.*`. Cutting a release is just pushing a tag:
 
 ```bash
-docker pull ghcr.io/mittwald/hutbot:latest
-docker pull ghcr.io/mittwald/hutbot:<version>
+git tag v1.1.0
+git push origin v1.1.0
 ```
 
+The published tags are:
+
+| Trigger              | Image tags                     | Deployable |
+| -------------------- | ------------------------------ | ---------- |
+| Tag push `v1.1.0`    | `v1.1.0`, `1.1.0`              | yes        |
+| Push to `main`       | `main`, `latest`               | no         |
+
+```bash
+docker pull ghcr.io/mittwald/hutbot:v1.1.0
+```
+
+> **Note:** `latest` and `main` are floating convenience tags. Deployments must pin an exact release
+> tag — the Helm chart refuses to render if `image.tag` is empty, so a version has to be chosen
+> explicitly.
+
 This repository includes a Helm chart under `charts/hutbot` and a Helmfile configuration at `helmfile.yaml.gotmpl`.
 
 Create a `.env` file in the project root (this file is ignored by git) with the following content:
@@ -134,6 +375,10 @@ export OPSGENIE_HEARTBEAT_NAME='<your Opsgenie heartbeat name>'
 export EMPLOYEE_LIST_USERNAME='<your employee list username>'
 export EMPLOYEE_LIST_PASSWORD='<your employee list password>'
 export EMPLOYEE_LIST_MAPPINGS='<optional comma-separated mappings, e.g.: user1=alias1,user2=alias2>'
+# Slash command this instance listens on; must match the Slack app. Default: /hutbot
+export HUTBOT_SLASH_COMMAND='/hutbot'
+# Name the bot uses for itself in help/news messages. Default: Hutbot
+export HUTBOT_BOT_NAME='Hutbot'
 # To define netpol egress rules, you can set a space-separated list of <port>:<cidr[,cidr...]> entries:
 export NETWORKPOLICY_RULES='443:192.168.0.15/32 80:10.0.0.0/24,10.0.1.0/24'
 # To define host aliases for the pod (/etc/hosts entries), you can set a comma-separated list of <hostname>=<ip> entries:
@@ -166,6 +411,100 @@ helmfile sync
 > **Note:** Helmfile uses Go templating to inject these variables and will error if any required environment variables are missing.
 > Ensure you run `source .env` in the same shell as you execute `helmfile sync`.
 
+### Deploying a Dev Instance
+
+The Helmfile defines two environments so a second, independent instance can run alongside production
+in the same namespace:
+
+| Environment | Release name  | Purpose                                          |
+| ----------- | ------------- | ------------------------------------------------ |
+| `default`   | `hutbot`      | Production instance                              |
+| `dev`       | `hutbot-dev`  | Dev instance (separate Slack app, own PVC/Secret) |
+
+All chart resources are named after the Helm release, so the dev release gets its own Deployment,
+Secret (`hutbot-dev-secret`), PersistentVolumeClaim (`hutbot-dev-pvc`) and NetworkPolicy. The two
+instances share nothing.
+
+Register a second Slack app for the dev bot — [Hutbot_DEV Slack App](https://api.slack.com/apps/A0BN19HUTAP) —
+and put its credentials in a `.env-dev` file (also ignored by git). It uses the exact same variable
+names as `.env`:
+
+```bash
+export SLACK_BOT_TOKEN='<dev bot token>'
+export SLACK_APP_TOKEN='<dev app-level token>'
+# ... same variables as .env
+```
+
+Then deploy with the `dev` environment selected:
+
+```bash
+source .env-dev
+helmfile -e dev sync
+```
+
+Production is unaffected and keeps deploying as before (`source .env && helmfile sync`), which is
+equivalent to `helmfile -e default sync`.
+
+> **Note:** Point the dev instance at its own Opsgenie heartbeat (or leave `OPSGENIE_HEARTBEAT_NAME`
+> empty in `.env-dev`), otherwise the dev pod will ping the production heartbeat.
+
+#### Telling the instances apart
+
+`HUTBOT_BOT_NAME` (default `Hutbot`) is the name the bot uses for itself in user-facing text, so the
+dev instance introduces itself as *Hutbot (DEV)* in its help and news messages. The Helmfile sets it
+per environment (`botName`), and it can be overridden with the environment variable.
+
+The `@mention` examples in the help text are not affected by this: they have to be a working Slack
+handle, so they are taken from the bot's own `auth.test` response at startup (`@hutbot` vs.
+`@hutbot_dev`) rather than from `HUTBOT_BOT_NAME`.
+
+The name is used everywhere the instance identifies itself:
+
+| Surface           | With `HUTBOT_BOT_NAME='Hutbot (DEV)'`                       |
+| ----------------- | ----------------------------------------------------------- |
+| Help / news       | *Hi! I am **Hutbot (DEV)*** …                                 |
+| Web UI            | Page title, wordmark and messages (served via `/api/meta`)   |
+| OpsGenie alert    | Tag `Hutbot (DEV)`, detail `bot: hutbot-dev`                  |
+
+The OpsGenie **alias** — the field OpsGenie deduplicates on — uses a slug of the name
+(`Hutbot` → `hutbot`, `Hutbot (DEV)` → `hutbot-dev`) instead of the display name. The production
+alias is therefore unchanged, and dev alerts can no longer deduplicate against production ones.
+
+#### Slash command per instance
+
+A Slack app cannot register a slash command that another app already owns, so the dev Slack app has
+to use its own — e.g. `/hutbot_dev`. The bot listens on the command in `HUTBOT_SLASH_COMMAND`
+(default `/hutbot`) and uses it in all help and error texts, so `/hutbot_dev help` prints
+`/hutbot_dev …` examples. If the running instance does not know about the command, Slack Bolt logs:
+
+```
+Unhandled request ({'type': None, 'command': '/hutbot_dev'})
+```
+
+The Helmfile sets this per environment (`slashCommand` in the `environments` block: `/hutbot` for
+`default`, `/hutbot_dev` for `dev`), and it can be overridden per invocation:
+
+```bash
+export HUTBOT_SLASH_COMMAND=/hutbot_test
+helmfile -e dev sync
+```
+
+The command name must match exactly what is configured in the Slack app (the leading `/` is added
+automatically if omitted).
+
+Each environment pins a specific image tag in the `environments` block of `helmfile.yaml.gotmpl`
+(`imageTag`) — no floating `latest`. Bump that value to roll out a new release, or override it per
+invocation to test a build in dev before promoting it to production:
+
+```bash
+export IMAGE_TAG=v1.1.0
+export IMAGE_REPOSITORY=ghcr.io/mittwald/hutbot   # optional
+helmfile -e dev sync
+```
+
+The target namespace defaults to `mw-internal` for both environments and can be overridden with
+`NAMESPACE`.
+
 ### Persisting the Configuration File
 
 Hutbot stores its channel configuration in a JSON file (`bot.json`) on a mounted volume. You can configure the persistence options in the Helm chart like this:
@@ -198,3 +537,32 @@ export NETWORKPOLICY_RULES='443:192.168.0.15/32 80:10.0.0.0/24,10.0.1.0/24'
 export HOST_ALIASES='lb.mittwald.it=192.168.0.15'
 helmfile sync
 ```
+
+## Development
+
+Hutbot is a Python package (`hutbot/`). The former monolithic `bot.py` has been
+split into cohesive modules; `bot.py` remains as a backward-compatible launcher:
+
+- `hutbot/state.py` — shared in-memory caches and runtime flags
+- `hutbot/models.py`, `hutbot/constants.py` — data types and configuration defaults
+- `hutbot/textutil.py`, `hutbot/datetimefmt.py` — logging/text helpers and date/time formatting
+- `hutbot/persistence.py` — config and cache load/save
+- `hutbot/slackcache.py` — Slack user/channel/usergroup lookups
+- `hutbot/templating.py`, `hutbot/opsgenie.py` — reply templates and OpsGenie integration
+- `hutbot/messaging.py`, `hutbot/actions.py`, `hutbot/buttons.py` — sending, the action engine, and interactive buttons/escalation
+- `hutbot/scheduling.py`, `hutbot/routing.py` — scheduled replies / cron triggers and Slack event routing
+- `hutbot/commands/` — slash-command parsing and handlers
+- `hutbot/webui_backend.py` — the web-UI bridge (the HTTP server lives in `webui.py`)
+- `hutbot/__main__.py` — the entry point
+
+Run it locally with `python -m hutbot`. Existing `python bot.py` invocations remain supported.
+
+### Running tests
+
+```bash
+pip install -r requirements-dev.txt
+pytest
+```
+
+Tests live in `tests/` (one file per module) and run automatically in CI before
+the Docker image is built.
diff --git a/assets/hutbot.png b/assets/hutbot.png
new file mode 100644
index 0000000..ea408b8
Binary files /dev/null and b/assets/hutbot.png differ
diff --git a/assets/hutbot.xcf b/assets/hutbot.xcf
new file mode 100644
index 0000000..cea929e
Binary files /dev/null and b/assets/hutbot.xcf differ
diff --git a/assets/hutbot_dev_large_bg.png b/assets/hutbot_dev_large_bg.png
new file mode 100644
index 0000000..adda208
Binary files /dev/null and b/assets/hutbot_dev_large_bg.png differ
diff --git a/assets/hutbot_large.png b/assets/hutbot_large.png
new file mode 100644
index 0000000..3e20f8f
Binary files /dev/null and b/assets/hutbot_large.png differ
diff --git a/assets/hutbot_large_bg.png b/assets/hutbot_large_bg.png
new file mode 100644
index 0000000..70e3cc2
Binary files /dev/null and b/assets/hutbot_large_bg.png differ
diff --git a/assets/hutbot_medium.png b/assets/hutbot_medium.png
new file mode 100644
index 0000000..b626831
Binary files /dev/null and b/assets/hutbot_medium.png differ
diff --git a/bot.py b/bot.py
index d93b8a4..887518e 100644
--- a/bot.py
+++ b/bot.py
@@ -1,2416 +1,10 @@
-import os
-import re
-import sys
-import collections
-import asyncio
-import json
-import urllib.parse
-import aiofiles
-import datetime
-import aiohttp  # Added for making HTTP requests
-from dataclasses import dataclass
-from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
-from slack_bolt.async_app import AsyncApp
-from slack_bolt.adapter.socket_mode.aiohttp import AsyncSocketModeHandler
-from slack_sdk.errors import SlackApiError
-from employee_list import (
-    get_env_var,
-    load_employee_mappings,
-    load_employees,
-    load_env_file,
-    log,
-    log_error,
-    log_warning,
-    normalize_id,
-    normalize_real_name,
-    normalize_real_name_with_diagraphs,
-    normalize_user_name,
-)
-
-ScheduledReply = collections.namedtuple('ScheduledReply', ['task', 'user_id'])
-User = collections.namedtuple('User', ['id', 'name', 'real_name', 'team'])
-Usergroup = collections.namedtuple('Usergroup', ['id', 'handle', 'name'])
-Channel = collections.namedtuple('Channel', ['id', 'name', 'configs'])
-OpsGeniePeriod = collections.namedtuple('OpsGeniePeriod', ['recipient_email', 'slack_user', 'start', 'end'])
-OpsGenieContext = collections.namedtuple('OpsGenieContext', ['schedule_name', 'current', 'next'])
-
-DEFAULT_CONFIG_NAME = 'default'
-DEFAULT_DATE_FORMAT = "%a, %d %b %Y"
-DEFAULT_TIME_FORMAT = "%H:%M"
-DEFAULT_OPSGENIE_PRIORITY = "P4"
-OPSGENIE_PRIORITIES = {"P1", "P2", "P3", "P4", "P5"}
-DEFAULT_CONFIG = {
-    "wait_time": 30 * 60,
-    "reply_message": "Anybody?",
-    "opsgenie": False,
-    "opsgenie_schedule_name": "",
-    "opsgenie_priority": DEFAULT_OPSGENIE_PRIORITY,
-    "date_format": "",
-    "time_format": "",
-    "datetime_timezone": "",
-    "datetime_locale": "",
-    "debug": False,
-    "include_bots": False,
-    "excluded_teams": [],
-    "included_teams": [],
-    "only_work_days": False,
-    "hours": [],
-    "pattern": None,
-    "pattern_case_sensitive": False,
-    "forward_channel": "",
-    "enabled": True
-}
-
-CONFIG_FILE_NAME = os.environ.get('HUTBOT_CONFIG_FILE', 'bot.json')
-SCHEDULED_REPLIES_CACHE_FILE = os.environ.get('HUTBOT_SCHEDULED_REPLIES_CACHE_FILE', 'scheduled_replies.json')
-TEAM_UNKNOWN = '<unknown>'
-
-IGNORED_MESSAGE_SUBTYPES = set(['channel_join',
-                                'channel_leave',
-                                'channel_archived',
-                                'channel_unarchived',
-                                'channel_convert_to_private',
-                                'channel_convert_to_public',
-                                'channel_name',
-                                'channel_posting_permissions',
-                                'channel_purpose',
-                                'channel_topic' ])
-
-channel_config = {}
-scheduled_messages = {}
-_scheduled_replies_cache: dict[tuple, dict] = {}
-
-user_id_cache = {}
-user_email_cache = {}
-id_user_cache = {}
-usergroup_id_cache = {}
-id_usergroup_cache = {}
-team_cache = set()
-
-bot_user_id = None
-
-opsgenie_configured = False
-
-MENTION_PATTERN = re.compile(r'(?<![|<])@([a-z0-9-_.]+)(?!>)')
-ID_PATTERN = re.compile(r'<([#@!][a-zA-Z0-9^]+)([|]([^>]*))?>')
-TIME_HOUR_PATTERN = re.compile(r"^[0-9]{1,2}$")
-CONFIG_NAME_PATTERN = re.compile(r"^[A-Za-z0-9-_\.:/]+$")
-TEMPLATE_VARIABLE_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
-TEMPLATE_ARGUMENT_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
-TEMPLATE_ARGUMENT_ALIASES = {
-    "fmt": "fmt",
-    "format": "fmt",
-    "tz": "tz",
-    "timezone": "tz",
-    "lc": "lc",
-    "locale": "lc",
-}
-OPSGENIE_DATETIME_TEMPLATE_VARIABLES = {
-    f"opsgenie_{period}_{bound}_{part}"
-    for period in ("current", "next")
-    for bound in ("start", "end")
-    for part in ("date", "time", "datetime")
-}
-OPSGENIE_TEMPLATE_VARIABLES = {
-    "opsgenie_schedule_name",
-    "opsgenie_current_email",
-    "opsgenie_current_name",
-    "opsgenie_current_user",
-    "opsgenie_next_email",
-    "opsgenie_next_name",
-    "opsgenie_next_user",
-    *OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
-}
-SUPPORTED_TEMPLATE_VARIABLES = {
-    "channel",
-    "channel_name",
-    "config",
-    "message",
-    "message_link",
-    *OPSGENIE_TEMPLATE_VARIABLES,
-    "team",
-    "timestamp",
-    "user",
-    "user_name",
-    "wait_minutes",
-}
-UNKNOWN_EMAIL_ONCALL_PLACEHOLDER = "<no-email-set>"
-UNKNOWN_NAME_ONCALL_PLACEHOLDER = "<no-name-set>"
-UNKNOWN_USER_ONCALL_PLACEHOLDER = "<no-user-set>"
-UNKNOWN_ONCALL_PERIOD_PLACEHOLDER = "<unknown>"
-UNKNOWN_OPSGENIE_SCHEDULE_PLACEHOLDER = "<no-schedule-set>"
-
-@dataclass(frozen=True)
-class TemplateExpression:
-    variable: str
-    args: dict[str, str]
-
-class TemplateExpressionError(ValueError):
-    pass
-
-# Regex patterns for command parsing
-def create_command_pattern(command_regex: str) -> re.Pattern:
-    return re.compile(f'^{command_regex}', re.IGNORECASE)
-
-HELP_PATTERN = re.compile(r'help', re.IGNORECASE)
-WHATSNEW_PATTERN = re.compile(r'news', re.IGNORECASE)
-TEST_PATTERN = re.compile(r'^test$', re.IGNORECASE)
-TEST_WITH_MESSAGE_PATTERN = re.compile(r'^test(?:\s+(?P<message>.*))?$', re.IGNORECASE)
-SET_WAIT_TIME_PATTERN = create_command_pattern(r'(set\s+)?wait([_ -]?time)?\s+(?P<wait_time>.+)')
-SET_REPLY_MESSAGE_PATTERN = create_command_pattern(r'(set\s+)?(message|reply)\s+(?P<message>.+)')
-SET_OPSGENIE_SCHEDULE_PATTERN = create_command_pattern(r'set\s+opsgenie[_ -]?schedule\s+(?P<schedule>.+)')
-SET_OPSGENIE_PRIORITY_PATTERN = create_command_pattern(r'set\s+opsgenie[_ -]?priority\s+(?P<priority>.+)')
-SET_DATETIME_FORMAT_PATTERN = create_command_pattern(r'(set\s+)?(datetime[_ -]?format|date[_ -]?format|datefmt)\s+(?P<values>.+)')
-SET_PATTERN_PATTERN = create_command_pattern(r'set\s+pattern\s+(?P<pattern>"[^"]*"|\'[^\']*\'|[^\r\n\t\f\v\s"\']+)(?:\s+(?P<case_sensitive>true|false|1|0))?')
-ADD_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'(add\s+)?excluded?([_ -]?teams?)?\s+(?P<team>.+)')
-CLEAR_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'clear\s+excluded?([_ -]?teams?)?')
-ADD_INCLUDED_TEAM_PATTERN = create_command_pattern(r'(add\s+)?included?([_ -]?teams?)?\s+(?P<team>.+)')
-CLEAR_INCLUDED_TEAM_PATTERN = create_command_pattern(r'clear\s+included?([_ -]?teams?)?')
-LIST_TEAMS_PATTERN = re.compile(r'^(list\s+)?teams?$', re.IGNORECASE)
-EMPLOYEE_TEAM_PATTERN = re.compile(r'^team(\s+of)?\s+(?P<user>.+)$', re.IGNORECASE)
-LIST_OPSGENIE_SCHEDULES_PATTERN = re.compile(r'^list\s+opsgenie[_ -]?schedules$', re.IGNORECASE)
-ON_CALL_PATTERN = create_command_pattern(r'on[_ -]?call(?:\s+(?P<schedule>.+))?$')
-ENABLE_OPSGENIE_PATTERN = create_command_pattern(r'enable\s+(opsgenie|alerts?)')
-DISABLE_OPSGENIE_PATTERN = create_command_pattern(r'disable\s+(opsgenie|alerts?)')
-ENABLE_BOTS_PATTERN = create_command_pattern(r'(enable|include|set)?\s+bots?')
-DISABLE_BOTS_PATTERN = create_command_pattern(r'(disable|exclude)\s+bots?')
-SET_WORK_HOURS_PATTERN = create_command_pattern(r'(set\s+)?(work[_ -]?)?hours\s+(?P<start>.+)\s+(?P<end>.+)')
-ENABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'enable\s+(only[_ -]?)?work[_ -]?days')
-DISABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'disable\s+(only[_ -]?)?work[_ -]?days')
-SHOW_CONFIG_PATTERN = re.compile(r'^(show\s+)?config(uration)?$', re.IGNORECASE)
-DELETE_CONFIG_PATTERN = create_command_pattern(r'delete\s+config\s+(?P<name>.+)')
-SET_FORWARD_CHANNEL_PATTERN = create_command_pattern(r'set\s+forward[_ -]?channel\s+(?P<channel>.+)')
-CLEAR_FORWARD_CHANNEL_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+forward[_ -]?channel')
-ENABLE_REPLIES_PATTERN = create_command_pattern(r'enable$')
-DISABLE_REPLIES_PATTERN = create_command_pattern(r'disable$')
-
-def log_debug(channel: Channel | None, *args: object) -> None:
-    if channel and any(c.get('debug') for c in channel.configs.values()):
-        __log(sys.stderr, 'DEBUG', *args)
-
-def __log(file, prefix, *args: object) -> None:
-    parts = []
-    for arg in args:
-        part = str(arg)
-        if isinstance(arg, BaseException):
-            error_type = type(arg).__name__
-            error_message = str(arg)
-            part = f"{error_type}{': ' + error_message if error_message else ''}"
-        parts.append(part)
-    message = ' '.join(parts)
-    prefix = f"{datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')} {prefix}:"
-    print(prefix, message, flush=True, file=file)
-
-def strip_quotes(text: str) -> str:
-    if text and ((text.startswith('"') and text.endswith('"')) or (text.startswith("'") and text.endswith("'"))):
-        text = text[1:-1]
-
-    return text
-
-def parse_quoted_tokens(text: str) -> tuple[list[str], str]:
-    tokens = []
-    i = 0
-    while i < len(text):
-        while i < len(text) and text[i].isspace():
-            i += 1
-        if i >= len(text):
-            break
-
-        if text[i] in ("'", '"'):
-            quote = text[i]
-            i += 1
-            value = []
-            while i < len(text):
-                if text[i] == "\\" and i + 1 < len(text) and text[i + 1] in (quote, "\\"):
-                    value.append(text[i + 1])
-                    i += 2
-                    continue
-                if text[i] == quote:
-                    i += 1
-                    break
-                value.append(text[i])
-                i += 1
-            else:
-                return [], "unterminated quoted value"
-            if i < len(text) and not text[i].isspace():
-                return [], "quoted values must be separated by whitespace"
-            tokens.append("".join(value))
-        else:
-            start = i
-            while i < len(text) and not text[i].isspace():
-                i += 1
-            tokens.append(text[start:i])
-
-    return tokens, ""
-
-def normalize_locale_name(value: str) -> str:
-    value = value.strip()
-    if not value:
-        raise ValueError("locale must be non-empty")
-    match = re.fullmatch(r"([A-Za-z]{2,3})(?:[-_]([A-Za-z]{2}|\d{3}))?", value)
-    if not match:
-        raise ValueError("locale must look like `en`, `en-US`, or `de_DE`")
-
-    language = match.group(1).lower()
-    region = match.group(2)
-    if not region:
-        return language
-    return f"{language}_{region.upper()}"
-
-def validate_timezone_name(value: str) -> str:
-    value = value.strip()
-    if not value:
-        raise ValueError("timezone must be non-empty")
-    try:
-        ZoneInfo(value)
-    except ZoneInfoNotFoundError:
-        raise ValueError(f"unknown timezone `{value}`")
-    return value
-
-def get_local_timezone() -> datetime.tzinfo:
-    return datetime.datetime.now().astimezone().tzinfo or datetime.timezone.utc
-
-def get_config_timezone(config: dict | None, timezone_name: str = "", local_tz: datetime.tzinfo | None = None) -> datetime.tzinfo:
-    if local_tz is not None:
-        return local_tz
-
-    configured_timezone = timezone_name or (config or {}).get("datetime_timezone", "")
-    if configured_timezone:
-        try:
-            return ZoneInfo(validate_timezone_name(configured_timezone))
-        except ValueError as e:
-            log_warning("Ignoring invalid datetime timezone in configuration:", e)
-
-    return get_local_timezone()
-
-def get_config_locale(config: dict | None, locale_name: str = "") -> str:
-    configured_locale = locale_name or (config or {}).get("datetime_locale", "")
-    if not configured_locale:
-        return ""
-    try:
-        return normalize_locale_name(configured_locale)
-    except ValueError as e:
-        log_warning("Ignoring invalid datetime locale in configuration:", e)
-        return ""
-
-GO_LAYOUT_TOKENS = [
-    ("Monday", "%A"),
-    ("January", "%B"),
-    ("Mon", "%a"),
-    ("Jan", "%b"),
-    ("2006", "%Y"),
-    ("Z07:00", "%z"),
-    ("Z0700", "%z"),
-    ("-07:00", "%z"),
-    ("-0700", "%z"),
-    ("15", "%H"),
-    ("03", "%I"),
-    ("04", "%M"),
-    ("05", "%S"),
-    ("02", "%d"),
-    ("01", "%m"),
-    ("06", "%y"),
-    ("PM", "%p"),
-    ("pm", "%p"),
-    ("MST", "%Z"),
-]
-
-def go_layout_to_strftime(layout: str) -> str:
-    converted = []
-    i = 0
-    while i < len(layout):
-        for token, directive in GO_LAYOUT_TOKENS:
-            if layout.startswith(token, i):
-                converted.append(directive)
-                i += len(token)
-                break
-        else:
-            converted.append(layout[i])
-            i += 1
-    return "".join(converted)
-
-LOCALIZED_DATE_NAMES = {
-    "de": {
-        "Monday": "Montag",
-        "Tuesday": "Dienstag",
-        "Wednesday": "Mittwoch",
-        "Thursday": "Donnerstag",
-        "Friday": "Freitag",
-        "Saturday": "Samstag",
-        "Sunday": "Sonntag",
-        "Mon": "Mo",
-        "Tue": "Di",
-        "Wed": "Mi",
-        "Thu": "Do",
-        "Fri": "Fr",
-        "Sat": "Sa",
-        "Sun": "So",
-        "January": "Januar",
-        "February": "Februar",
-        "March": "Maerz",
-        "April": "April",
-        "May": "Mai",
-        "June": "Juni",
-        "July": "Juli",
-        "August": "August",
-        "September": "September",
-        "October": "Oktober",
-        "November": "November",
-        "December": "Dezember",
-        "Jan": "Jan",
-        "Feb": "Feb",
-        "Mar": "Mrz",
-        "Apr": "Apr",
-        "Jun": "Jun",
-        "Jul": "Jul",
-        "Aug": "Aug",
-        "Sep": "Sep",
-        "Oct": "Okt",
-        "Nov": "Nov",
-        "Dec": "Dez",
-    }
-}
-
-def localize_formatted_datetime(value: str, locale_name: str) -> str:
-    if not locale_name:
-        return value
-
-    language = locale_name.split("_", 1)[0].lower()
-    replacements = LOCALIZED_DATE_NAMES.get(language)
-    if not replacements:
-        return value
-
-    for source in sorted(replacements, key=len, reverse=True):
-        value = re.sub(rf"\b{re.escape(source)}\b", replacements[source], value)
-    return value
-
-def format_datetime_value(
-    value: str,
-    part: str = "datetime",
-    config: dict | None = None,
-    args: dict[str, str] | None = None,
-    local_tz: datetime.tzinfo | None = None,
-) -> str:
-    parsed = parse_opsgenie_datetime(value)
-    if not parsed:
-        return UNKNOWN_ONCALL_PERIOD_PLACEHOLDER
-
-    args = args or {}
-    timezone = get_config_timezone(config, args.get("tz", ""), local_tz)
-    local_time = parsed.astimezone(timezone)
-
-    date_format = (config or {}).get("date_format") or DEFAULT_DATE_FORMAT
-    time_format = (config or {}).get("time_format") or DEFAULT_TIME_FORMAT
-    default_format = {
-        "date": date_format,
-        "time": time_format,
-        "datetime": f"{date_format} {time_format}",
-    }.get(part, f"{date_format} {time_format}")
-
-    fmt = args.get("fmt") or default_format
-    if "%" not in fmt:
-        fmt = go_layout_to_strftime(fmt)
-
-    locale_name = get_config_locale(config, args.get("lc", ""))
-    return localize_formatted_datetime(local_time.strftime(fmt), locale_name)
-
-def format_opsgenie_template_datetime(value: str, variable: str, config: dict | None = None, args: dict[str, str] | None = None) -> str:
-    part = variable.rsplit("_", 1)[-1]
-    return format_datetime_value(value, part, config, args)
-
-def iter_template_expression_parts(message: str):
-    pos = 0
-    while pos < len(message):
-        next_open = message.find("{{", pos)
-        next_close = message.find("}}", pos)
-        if next_close != -1 and (next_open == -1 or next_close < next_open):
-            raise TemplateExpressionError("unexpected `}}`")
-        if next_open == -1:
-            break
-
-        close = message.find("}}", next_open + 2)
-        if close == -1:
-            raise TemplateExpressionError("missing closing `}}`")
-        yield next_open, close + 2, message[next_open + 2:close].strip()
-        pos = close + 2
-
-def parse_template_expression(content: str) -> TemplateExpression:
-    i = 0
-    match = TEMPLATE_VARIABLE_NAME_PATTERN.match(content, i)
-    if not match:
-        raise TemplateExpressionError("missing variable name")
-    variable = match.group(0)
-    i = match.end()
-
-    while i < len(content) and content[i].isspace():
-        i += 1
-    if i == len(content):
-        return TemplateExpression(variable, {})
-    if content[i] != "(":
-        raise TemplateExpressionError("expected `(` after variable name")
-    i += 1
-
-    args = {}
-    while True:
-        while i < len(content) and content[i].isspace():
-            i += 1
-        if i < len(content) and content[i] == ")":
-            i += 1
-            break
-        if i >= len(content):
-            raise TemplateExpressionError("missing closing `)`")
-
-        name_match = TEMPLATE_ARGUMENT_NAME_PATTERN.match(content, i)
-        if not name_match:
-            raise TemplateExpressionError("missing argument name")
-        arg_name = name_match.group(0)
-        i = name_match.end()
-        canonical_arg_name = TEMPLATE_ARGUMENT_ALIASES.get(arg_name)
-        if not canonical_arg_name:
-            raise TemplateExpressionError(f"unknown argument `{arg_name}`")
-        if canonical_arg_name in args:
-            raise TemplateExpressionError(f"duplicate argument `{arg_name}`")
-
-        while i < len(content) and content[i].isspace():
-            i += 1
-        if i >= len(content) or content[i] != "=":
-            raise TemplateExpressionError(f"missing `=` after argument `{arg_name}`")
-        i += 1
-        while i < len(content) and content[i].isspace():
-            i += 1
-        if i >= len(content) or content[i] in ",)":
-            raise TemplateExpressionError(f"missing value for argument `{arg_name}`")
-
-        if content[i] in ("'", '"'):
-            quote = content[i]
-            i += 1
-            value = []
-            while i < len(content):
-                if content[i] == "\\" and i + 1 < len(content) and content[i + 1] in (quote, "\\"):
-                    value.append(content[i + 1])
-                    i += 2
-                    continue
-                if content[i] == quote:
-                    i += 1
-                    break
-                value.append(content[i])
-                i += 1
-            else:
-                raise TemplateExpressionError(f"unterminated quoted value for argument `{arg_name}`")
-            arg_value = "".join(value)
-        else:
-            start = i
-            while i < len(content) and content[i] not in ",)":
-                i += 1
-            arg_value = content[start:i].strip()
-
-        if not arg_value:
-            raise TemplateExpressionError(f"missing value for argument `{arg_name}`")
-        args[canonical_arg_name] = arg_value
-
-        while i < len(content) and content[i].isspace():
-            i += 1
-        if i < len(content) and content[i] == ",":
-            i += 1
-            j = i
-            while j < len(content) and content[j].isspace():
-                j += 1
-            if j < len(content) and content[j] == ")":
-                raise TemplateExpressionError("missing argument after `,`")
-            continue
-        if i < len(content) and content[i] == ")":
-            i += 1
-            break
-        if i >= len(content):
-            raise TemplateExpressionError("missing closing `)`")
-        raise TemplateExpressionError("expected `,` or `)` after argument value")
-
-    while i < len(content) and content[i].isspace():
-        i += 1
-    if i != len(content):
-        raise TemplateExpressionError("unexpected text after closing `)`")
-
-    return TemplateExpression(variable, args)
-
-def parse_template_expressions(message: str) -> list[TemplateExpression]:
-    return [parse_template_expression(content) for _, _, content in iter_template_expression_parts(message)]
-
-def validate_template_expressions(message: str) -> str:
-    try:
-        expressions = parse_template_expressions(message)
-    except TemplateExpressionError as e:
-        return f"malformed template expression: {e}"
-
-    unknown_variables = sorted({expr.variable for expr in expressions if expr.variable not in SUPPORTED_TEMPLATE_VARIABLES})
-    if unknown_variables:
-        return (
-            "unsupported template variable(s) "
-            + ", ".join(f"`{{{{{variable}}}}}`" for variable in unknown_variables)
-            + ". Supported variables: "
-            + ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
-            + "."
-        )
-
-    for expr in expressions:
-        if expr.args and expr.variable not in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
-            return f"template variable `{{{{{expr.variable}}}}}` does not support arguments"
-        if "tz" in expr.args:
-            try:
-                validate_timezone_name(expr.args["tz"])
-            except ValueError as e:
-                return str(e)
-        if "lc" in expr.args:
-            try:
-                normalize_locale_name(expr.args["lc"])
-            except ValueError as e:
-                return str(e)
-
-    return ""
-
-async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
-    for channel_id, channel_data in config.items():
-        # Migration for old format
-        # old format: "C1234": { "wait_time": 60, ... }
-        # new format: "C1234": { "default": { "wait_time": 60, ... } }
-        is_flat_config = any(k in DEFAULT_CONFIG for k in channel_data.keys())
-        if is_flat_config:
-            # This looks like an old, flat config. Let's wrap it.
-            log(f"Migrating old configuration for channel {channel_id}")
-            channel_data = {DEFAULT_CONFIG_NAME: channel_data}
-            config[channel_id] = channel_data
-
-        for config_name, single_config in channel_data.items():
-            for key, value in DEFAULT_CONFIG.items():
-                if key not in single_config:
-                    single_config[key] = value
-    return config
-
-
-async def load_configuration(app: AsyncApp) -> None:
-    global channel_config
-    try:
-        async with aiofiles.open(CONFIG_FILE_NAME, 'r') as f:
-            content = await f.read()
-            loaded_config = json.loads(content)
-            channel_config = await migrate_and_apply_defaults(app, loaded_config)
-            log("Configuration loaded from disk.")
-    except FileNotFoundError:
-        log_warning("No configuration file found. Using default settings.")
-        channel_config = {}
-    except json.JSONDecodeError as e:
-        log_error(f"Failed to decode JSON configuration:", e)
-        channel_config = {}
-
-async def save_configuration() -> None:
-    try:
-        async with aiofiles.open(CONFIG_FILE_NAME, 'w') as f:
-            content = json.dumps(channel_config, indent=2)
-            await f.write(content)
-    except Exception as e:
-        log_error("Failed to save configuration:", e)
-
-async def load_replies_cache() -> None:
-    global _scheduled_replies_cache
-    try:
-        async with aiofiles.open(SCHEDULED_REPLIES_CACHE_FILE, 'r') as f:
-            content = await f.read()
-            entries = json.loads(content)
-            _scheduled_replies_cache = {
-                (e['channel_id'], e['ts'], e['config_name']): e
-                for e in entries
-            }
-            log(f"Loaded {len(_scheduled_replies_cache)} pending scheduled replies from cache.")
-    except FileNotFoundError:
-        _scheduled_replies_cache = {}
-    except Exception as e:
-        log_error("Failed to load scheduled replies cache:", e)
-        _scheduled_replies_cache = {}
-
-async def flush_replies_cache() -> None:
-    try:
-        async with aiofiles.open(SCHEDULED_REPLIES_CACHE_FILE, 'w') as f:
-            await f.write(json.dumps(list(_scheduled_replies_cache.values()), indent=2))
-    except Exception as e:
-        log_error("Failed to flush scheduled replies cache:", e)
-
-async def get_channel_by_id(app: AsyncApp, channel_id: str) -> Channel:
-    global channel_config
-    if channel_id not in channel_config:
-        channel_config[channel_id] = {}
-
-    name = await get_channel_name(app, channel_id)
-    configs = channel_config[channel_id]
-
-    return Channel(id=channel_id, name=name, configs=configs)
-
-async def get_channel_name(app: AsyncApp, channel_id: str) -> str:
-    try:
-        response = await app.client.conversations_info(channel=channel_id)
-        channel_name = response.get('channel', {}).get('name', '')
-        if channel_name:
-            return channel_name
-    except SlackApiError as e:
-        log_error(f"Failed to get channel name for {channel_id}", e)
-
-    return channel_id
-
-async def get_message_permalink(app: AsyncApp, channel: Channel, ts: str) -> str:
-    permalink = ""
-    try:
-        response = await app.client.chat_getPermalink(
-            channel=channel.id,
-            message_ts=ts
-        )
-
-        permalink = response.get('permalink', '')
-    except SlackApiError as e:
-        log_error(f"Failed to get permalink for message {ts} in channel #{channel.name}:", e)
-
-    return permalink
-
-async def update_usergroup_cache(app: AsyncApp) -> None:
-  global usergroup_id_cache, id_usergroup_cache
-  if not usergroup_id_cache or not id_usergroup_cache:
-      try:
-          response = await app.client.usergroups_list()
-          usergroups = response['usergroups']
-          for usergroup in usergroups:
-              if usergroup.get('date_deleted', 0) == 0:
-                  usergroup_id = usergroup.get('id', '')
-                  usergroup_handle = usergroup.get('handle', '')
-                  usergroup_name = usergroup.get('name', '')
-                  usergroup_id_cache[usergroup_handle] = Usergroup(id=usergroup_id, handle=usergroup_handle, name=usergroup_name)
-                  id_usergroup_cache[usergroup_id] = Usergroup(id=usergroup_id, handle=usergroup_handle, name=usergroup_name)
-      except SlackApiError as e:
-          log_error(f"Failed to fetch usergroup list:", e)
-
-def build_user(user: dict, employees: dict, mappings: dict) -> tuple[str, User]:
-    user_id = user.get('id', '')
-    user_name = normalize_id(user.get('name', ''))
-    if user_name in mappings:
-        log(f"Applying employee mapping: {user_name} -> {mappings[user_name]}")
-        user_name = mappings[user_name]
-    user_name_normalized = normalize_user_name(user_name)
-    user_email = normalize_id(user.get('profile', {}).get('email', ''))
-    user_email_alias = normalize_id(user_email.split('@')[0])
-    user_email_alias_normalized = normalize_user_name(user_email_alias)
-    user_real_name = user.get('real_name', '').strip()
-    user_real_name_normalized = normalize_real_name(user_real_name)
-    user_team = TEAM_UNKNOWN
-
-    if len(employees) > 0:
-        # Try different variations of the username to find a match in employees
-        user_key_candidates = [
-            user_name,
-            user_name_normalized,
-            user_email_alias,
-            user_email_alias_normalized
-        ]
-        user_key = next((k for k in user_key_candidates if k in employees), None)
-
-        if not user_key:
-            # loop through all employees and try to match some form of the real name
-            for employee_key, employee in employees.items():
-                employee_real_name = employee.get('fullname', '').strip()
-                employee_real_name_normalized = normalize_real_name(employee_real_name)
-                employee_real_name_super_normalized = normalize_real_name_with_diagraphs(employee_real_name)
-                user_real_name_super_normalized = normalize_real_name_with_diagraphs(user_real_name)
-                if employee_real_name_normalized == user_real_name_normalized or \
-                employee_real_name_super_normalized == user_real_name_normalized or \
-                employee_real_name_super_normalized == user_real_name_super_normalized:
-                    user_key = employee_key
-                    # finally!
-                    break
-            if not user_key:
-                user_json = json.dumps(user)
-                if len(user_json) > 100:
-                    user_json = user_json[:97] + '...'
-                log_warning(f"Failed to map user @{user_name} to a employee: {user_json}")
-
-        if user_key:
-            user_team = employees[user_key].get('group', '').strip()
-
-    return user_email, User(id=user_id, name=user_name, team=user_team, real_name=user_real_name)
-
-def cache_user(user_email: str, u: User) -> None:
-    user_id_cache[u.name] = u
-    if user_email:
-        user_email_cache[user_email] = u
-    id_user_cache[u.id] = u
-    if u.team not in team_cache:
-        team_cache.add(u.team)
-
-async def update_user_cache(app: AsyncApp) -> None:
-    global user_id_cache, user_email_cache, id_user_cache
-    if not user_id_cache or not user_email_cache or not id_user_cache:
-        employees = await load_employees()
-        mappings = load_employee_mappings()
-        try:
-            cursor = None
-            while True:
-                response = await app.client.users_list(cursor=cursor, limit=200)
-                for user in response['members']:
-                    if not user.get('deleted') and \
-                       not user.get('is_bot', False) and \
-                       not user.get('is_restricted', False) and \
-                       user.get('id', '') != 'USLACKBOT':
-                        cache_user(*build_user(user, employees, mappings))
-                cursor = response.get('response_metadata', {}).get('next_cursor')
-                if not cursor:
-                    break
-        except SlackApiError as e:
-            log_error(f"Failed to fetch user list:", e)
-
-async def fetch_user_by_id(app: AsyncApp, id: str, channel: Channel | None = None) -> User | None:
-    try:
-        response = await app.client.users_info(user=id)
-    except SlackApiError as e:
-        log_error(f"Failed to fetch user `{id}`:", e)
-        return None
-    slack_user = response.get('user')
-    if not slack_user:
-        return None
-    log_debug(channel, f"Retrieved user not in cache from Slack API: {json.dumps(slack_user)}")
-    employees = await load_employees()
-    mappings = load_employee_mappings()
-    user_email, user = build_user(slack_user, employees, mappings)
-    cache_user(user_email, user)
-    return user
-
-async def get_user_by_id(app: AsyncApp, id: str, channel: Channel | None = None) -> User:
-    await update_user_cache(app)
-    user = id_user_cache.get(id, None)
-    if not user:
-        user = await fetch_user_by_id(app, id, channel)
-    if not user:
-        user = User(id=id, name=id, team=TEAM_UNKNOWN, real_name='')
-    return user
-
-async def get_user_by_name(app: AsyncApp, name: str) -> User:
-    await update_user_cache(app)
-    user = user_id_cache.get(name, None)
-    if not user:
-        user = User(id=None, name=name, team=TEAM_UNKNOWN, real_name='')
-    return user
-
-async def get_user_by_email(app: AsyncApp, email: str) -> User:
-    await update_user_cache(app)
-    normalized_email = normalize_id(email)
-    user = user_email_cache.get(normalized_email, None)
-    if user:
-        return user
-
-    user_alias = normalized_email.split('@')[0]
-    return await get_user_by_name(app, user_alias)
-
-async def get_usergroup_by_id(app: AsyncApp, id: str) -> Usergroup:
-    await update_usergroup_cache(app)
-    usergroup = id_usergroup_cache.get(id, None)
-    if not usergroup:
-        usergroup = Usergroup(id=id, handle=id, name=id)
-    return usergroup
-
-async def get_usergroup_by_handle(app: AsyncApp, handle: str) -> Usergroup:
-    await update_usergroup_cache(app)
-    usergroup = usergroup_id_cache.get(handle, None)
-    if not usergroup:
-        usergroup = Usergroup(id=None, handle=handle, name=handle)
-    return usergroup
-
-def is_work_day() -> bool:
-    today = datetime.date.today()
-    # TODO: add holidays
-    return today.weekday() < 5
-
-def is_work_time(start_time_str: str, end_time_str: str) -> bool:
-    now = datetime.datetime.now()
-    start = parse_time(start_time_str)
-    end = parse_time(end_time_str)
-    if not start or not end:
-        log_error(f"Invalid time format {start_time_str} - {end_time_str}")
-        return True
-    start_today = datetime.datetime.combine(now.date(), start)
-    end_today = datetime.datetime.combine(now.date(), end)
-    return start_today < now < end_today
-
-def is_command(text: str) -> bool:
-    return f"<@{bot_user_id}>" in text
-
-async def parse_and_execute_command(app: AsyncApp, command_text: str, channel: Channel, config_name: str, user: User, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> bool:
-    """Parses and executes a command, returns True if a command was matched."""
-    if (match := (TEST_WITH_MESSAGE_PATTERN if allow_test_message else TEST_PATTERN).match(command_text)):
-        test_message = match.group("message") if allow_test_message and match.groupdict().get("message") is not None else ""
-        await test_reply_message(app, opsgenie_token, channel, config_name, user, test_message, command_ts, thread_ts)
-    elif (match := SET_WAIT_TIME_PATTERN.match(command_text)):
-        wait_time_minutes = int(strip_quotes(match.group("wait_time")))
-        await set_wait_time(app, channel, config_name, wait_time_minutes, user, thread_ts)
-    elif (match := SET_REPLY_MESSAGE_PATTERN.match(command_text)):
-        message = strip_quotes(match.group("message"))
-        await set_reply_message(app, channel, config_name, message, user, thread_ts)
-    elif (match := SET_OPSGENIE_SCHEDULE_PATTERN.match(command_text)):
-        schedule_name = strip_quotes(match.group("schedule"))
-        await set_opsgenie_schedule_name(app, channel, config_name, schedule_name, user, thread_ts)
-    elif (match := SET_OPSGENIE_PRIORITY_PATTERN.match(command_text)):
-        priority = strip_quotes(match.group("priority"))
-        await set_opsgenie_priority(app, channel, config_name, priority, user, thread_ts)
-    elif (match := SET_DATETIME_FORMAT_PATTERN.match(command_text)):
-        await set_datetime_format(app, channel, config_name, match.group("values"), user, thread_ts)
-    elif (match := SET_PATTERN_PATTERN.match(command_text)):
-        pattern = match.group("pattern")
-        case_sensitive = match.group("case_sensitive")
-        await set_pattern(app, channel, config_name, pattern, case_sensitive, user, thread_ts)
-    elif (match := ENABLE_OPSGENIE_PATTERN.match(command_text)):
-        await set_opsgenie(app, channel, config_name, True, user, thread_ts)
-    elif (match := DISABLE_OPSGENIE_PATTERN.match(command_text)):
-        await set_opsgenie(app, channel, config_name, False, user, thread_ts)
-    elif (match := ENABLE_BOTS_PATTERN.match(command_text)):
-        await set_bots(app, channel, config_name, True, user, thread_ts)
-    elif (match := DISABLE_BOTS_PATTERN.match(command_text)):
-        await set_bots(app, channel, config_name, False, user, thread_ts)
-    elif (match := ENABLE_ONLY_WORK_DAYS_PATTERN.match(command_text)):
-        await set_only_work_days(app, channel, config_name, True, user, thread_ts)
-    elif (match := DISABLE_ONLY_WORK_DAYS_PATTERN.match(command_text)):
-        await set_only_work_days(app, channel, config_name, False, user, thread_ts)
-    elif (match := SET_WORK_HOURS_PATTERN.match(command_text)):
-        start = strip_quotes(match.group("start"))
-        end = strip_quotes(match.group("end"))
-        await set_work_hours(app, channel, config_name, start, end, user, thread_ts)
-    elif LIST_TEAMS_PATTERN.match(command_text):
-        await list_teams(app, channel, user, thread_ts)
-    elif LIST_OPSGENIE_SCHEDULES_PATTERN.match(command_text):
-        await list_opsgenie_schedules(app, channel, user, thread_ts)
-    elif (match := ON_CALL_PATTERN.match(command_text)):
-        schedule_name = strip_quotes(match.group("schedule") or "")
-        await send_current_on_call(app, opsgenie_token, channel, config_name, schedule_name, user, thread_ts)
-    elif (match := EMPLOYEE_TEAM_PATTERN.match(command_text)):
-        username = strip_quotes(match.group("user"))
-        await get_team_of(app, channel, username, user, thread_ts)
-    elif (match := ADD_EXCLUDED_TEAM_PATTERN.match(command_text)):
-        team = strip_quotes(match.group("team"))
-        await add_excluded_team(app, channel, config_name, team, user, thread_ts)
-    elif (match := CLEAR_EXCLUDED_TEAM_PATTERN.match(command_text)):
-        await clear_excluded_team(app, channel, config_name, user, thread_ts)
-    elif (match := ADD_INCLUDED_TEAM_PATTERN.match(command_text)):
-        team = strip_quotes(match.group("team"))
-        await add_included_team(app, channel, config_name, team, user, thread_ts)
-    elif (match := CLEAR_INCLUDED_TEAM_PATTERN.match(command_text)):
-        await clear_included_team(app, channel, config_name, user, thread_ts)
-    elif (match := SET_FORWARD_CHANNEL_PATTERN.match(command_text)):
-        channel_ref = strip_quotes(match.group("channel"))
-        await set_forward_channel(app, channel, config_name, channel_ref, user, thread_ts)
-    elif CLEAR_FORWARD_CHANNEL_PATTERN.match(command_text):
-        await clear_forward_channel(app, channel, config_name, user, thread_ts)
-    elif ENABLE_REPLIES_PATTERN.match(command_text):
-        await set_replies_enabled(app, channel, config_name, True, user, thread_ts)
-    elif DISABLE_REPLIES_PATTERN.match(command_text):
-        await set_replies_enabled(app, channel, config_name, False, user, thread_ts)
-    elif (match := DELETE_CONFIG_PATTERN.match(command_text)):
-        name = strip_quotes(match.group("name"))
-        await delete_config(app, channel, name, user, thread_ts)
-    elif SHOW_CONFIG_PATTERN.match(command_text):
-        await show_config(app, channel, user, thread_ts)
-    elif HELP_PATTERN.match(command_text):
-        await send_help_message(app, channel, user, thread_ts)
-    elif WHATSNEW_PATTERN.match(command_text):
-        await send_news_message(app, channel, user, thread_ts)
-    else:
-        return False
-    return True
-
-async def process_command(app: AsyncApp, text: str, channel: Channel, user: User, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
-    text = text.replace(f"<@{bot_user_id}>", "").strip()
-    log_debug(channel, f"Received command for channel #{channel.name}: {text}")
-    command_ts = command_ts or thread_ts
-
-    # First, try to parse the command with the default config.
-    if await parse_and_execute_command(app, text, channel, DEFAULT_CONFIG_NAME, user, thread_ts, opsgenie_token, allow_test_message, command_ts):
-        return
-
-    # If that fails, assume the first part is a config name.
-    parts = text.split()
-    if len(parts) > 1:
-        config_name = parts[0]
-        command_text = " ".join(parts[1:])
-
-        if not CONFIG_NAME_PATTERN.match(config_name):
-            await send_message(app, channel, user, f"Invalid config name: `{config_name}`. Only characters `A-Z`, `a-z`, `0-9`, `.`, `:`, `/`, `-`, `_` are allowed.", thread_ts)
-            return
-
-        if await parse_and_execute_command(app, command_text, channel, config_name, user, thread_ts, opsgenie_token, allow_test_message, command_ts):
-            return
-
-    await send_message(app, channel, user, "Huh? :thinking_face: Maybe type `/hutbot help` for a list of commands.", thread_ts)
-
-async def set_bots(app: AsyncApp, channel: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['include_bots'] = enabled
-    await save_configuration()
-    await send_message(app, channel, user, f"*Bot messages* will {'also be *handled*' if enabled else 'be *ignored*'} in configuration `{config_name}`.", thread_ts)
-
-async def set_only_work_days(app: AsyncApp, channel: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['only_work_days'] = enabled
-    await save_configuration()
-    await send_message(app, channel, user, f"Messages will be handled {'*only on work days*' if enabled else '*on all days*'} in configuration `{config_name}`.", thread_ts)
-
-async def set_replies_enabled(app: AsyncApp, channel: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['enabled'] = enabled
-    await save_configuration()
-    await send_message(app, channel, user, f"Replies are now *{'enabled' if enabled else 'disabled'}* in configuration `{config_name}`.", thread_ts)
-
-def parse_time(time_str) -> datetime.time | None:
-    if TIME_HOUR_PATTERN.match(time_str):
-        time_str = f"{time_str}:00"
-
-    time = None
-    try:
-        time = datetime.datetime.strptime(time_str, "%H:%M").time()
-    except ValueError:
-        pass
-
-    return time
-
-async def set_work_hours(app: AsyncApp, channel: Channel, config_name: str, start: str, end: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    start_time = parse_time(start)
-    end_time = parse_time(end)
-    if not start_time:
-        await send_message(app, channel, user, f"Invalid time format `{start}`.", thread_ts)
-        return
-    if not end_time:
-        await send_message(app, channel, user, f"Invalid time format `{end}`.", thread_ts)
-        return
-    hours = [start_time.strftime("%H:%M"), end_time.strftime("%H:%M")]
-    if hours[0] == "00:00" and hours[1] == "00:00":
-        hours = []
-    channel.configs[config_name]['hours'] = hours
-    await save_configuration()
-    await send_message(app, channel, user, f"*Work hours* set to {f'`{hours[0]}` - `{hours[1]}`' if len(hours) == 2 else 'all day'} in configuration `{config_name}`", thread_ts)
-
-async def set_forward_channel(app: AsyncApp, channel: Channel, config_name: str, channel_ref: str, user: User, thread_ts: str = "") -> None:
-    channel_id = None
-    for match in ID_PATTERN.finditer(channel_ref):
-        id = match.group(1)
-        if id and id[0] == '#':
-            channel_id = id[1:]
-            break
-    if not channel_id:
-        stripped = channel_ref.strip()
-        if re.match(r'^C[A-Z0-9]+$', stripped):
-            channel_id = stripped
-
-    if not channel_id:
-        await send_message(app, channel, user, f"Invalid channel: `{channel_ref}`. Use a #channel mention.", thread_ts)
-        return
-
-    try:
-        confirmation = (
-            f"Reply messages from #{channel.name} (config `{config_name}`) "
-            f"will now be forwarded here by Hutbot :palm_up_hand::tophat:"
-        )
-        await app.client.chat_postMessage(channel=channel_id, text=confirmation, mrkdwn=True)
-    except SlackApiError as e:
-        await send_message(app, channel, user, f"Cannot post to <#{channel_id}>: `{e.response['error']}`.", thread_ts)
-        return
-
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['forward_channel'] = channel_id
-    await save_configuration()
-    await send_message(app, channel, user, f"*Forward channel* set to <#{channel_id}> in configuration `{config_name}`.", thread_ts)
-
-async def clear_forward_channel(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    if config_name in channel.configs:
-        channel.configs[config_name].pop('forward_channel', None)
-        await save_configuration()
-    await send_message(app, channel, user, f"*Forward channel* cleared in configuration `{config_name}`.", thread_ts)
-
-async def set_opsgenie(app: AsyncApp, channel: Channel, config_name: str, enabled: bool, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['opsgenie'] = enabled
-    await save_configuration()
-    await send_message(app, channel, user, f"*OpsGenie integration* {'*enabled*' if enabled else '*disabled*'}{', but not configured' if enabled and not opsgenie_configured else ''} in configuration `{config_name}`.", thread_ts)
-
-async def set_opsgenie_schedule_name(app: AsyncApp, channel: Channel, config_name: str, schedule_name: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    if not schedule_name.strip():
-        await send_message(app, channel, user, "Invalid *OpsGenie schedule name*. Must be non-empty.", thread_ts)
-        return
-
-    schedule_name = schedule_name.strip()
-    channel.configs[config_name]['opsgenie_schedule_name'] = schedule_name
-    await save_configuration()
-    await send_message(app, channel, user, f"*OpsGenie schedule* set to `{schedule_name}` in configuration `{config_name}`.", thread_ts)
-
-async def set_opsgenie_priority(app: AsyncApp, channel: Channel, config_name: str, priority: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-
-    priority = priority.strip().upper()
-    if priority not in OPSGENIE_PRIORITIES:
-        supported = ", ".join(f"`{p}`" for p in sorted(OPSGENIE_PRIORITIES))
-        await send_message(app, channel, user, f"Invalid *OpsGenie priority*. Must be one of {supported}.", thread_ts)
-        return
-
-    channel.configs[config_name]['opsgenie_priority'] = priority
-    await save_configuration()
-    await send_message(app, channel, user, f"*OpsGenie priority* set to `{priority}` in configuration `{config_name}`.", thread_ts)
-
-async def set_datetime_format(app: AsyncApp, channel: Channel, config_name: str, values: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-
-    tokens, error = parse_quoted_tokens(values)
-    if error:
-        await send_message(app, channel, user, f"Invalid *date/time format*: {error}.", thread_ts)
-        return
-    if len(tokens) < 2 or len(tokens) > 4:
-        await send_message(app, channel, user, "Invalid *date/time format*. Use `/hutbot [config] set datetime-format <date> <time> [<timezone> <locale>]`.", thread_ts)
-        return
-
-    date_format = tokens[0]
-    time_format = tokens[1]
-    if not date_format.strip() or not time_format.strip():
-        await send_message(app, channel, user, "Invalid *date/time format*. Date and time formats must be non-empty.", thread_ts)
-        return
-
-    timezone_name = tokens[2] if len(tokens) >= 3 else ""
-    locale_name = tokens[3] if len(tokens) >= 4 else ""
-    normalized_locale = ""
-    if timezone_name:
-        try:
-            validate_timezone_name(timezone_name)
-        except ValueError as e:
-            await send_message(app, channel, user, f"Invalid *date/time format*: {e}.", thread_ts)
-            return
-    if locale_name:
-        try:
-            normalized_locale = normalize_locale_name(locale_name)
-        except ValueError as e:
-            await send_message(app, channel, user, f"Invalid *date/time format*: {e}.", thread_ts)
-            return
-
-    config = channel.configs[config_name]
-    config["date_format"] = date_format
-    config["time_format"] = time_format
-    config["datetime_timezone"] = timezone_name
-    config["datetime_locale"] = normalized_locale
-
-    await save_configuration()
-
-    details = f"*Date/time format* set to date `{date_format}` and time `{time_format}`"
-    if timezone_name:
-        details += f", timezone `{timezone_name}`"
-    if locale_name:
-        details += f", locale `{normalized_locale}`"
-    details += f" in configuration `{config_name}`."
-    await send_message(app, channel, user, details, thread_ts)
-
-async def set_wait_time(app: AsyncApp, channel: Channel, config_name: str, wait_time_minutes: int, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    # check if number and in range 0-1440
-    if not wait_time_minutes or wait_time_minutes < 0 or wait_time_minutes > 1440:
-        await send_message(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
-        return
-
-    channel.configs[config_name]['wait_time'] = wait_time_minutes * 60  # Convert to seconds
-    log_debug(channel, f"Wait time for #{channel.name} set to {wait_time_minutes} minutes for configuration `{config_name}`")
-    await save_configuration()
-    await send_message(app, channel, user, f"*Wait time* set to `{wait_time_minutes}` minutes in configuration `{config_name}`.", thread_ts)
-
-def find_unknown_template_variables(message: str) -> list[str]:
-    try:
-        variables = {expr.variable for expr in parse_template_expressions(message)}
-    except TemplateExpressionError:
-        return []
-    return sorted(variable for variable in variables if variable not in SUPPORTED_TEMPLATE_VARIABLES)
-
-def find_template_variables(message: str) -> set[str]:
-    try:
-        return {expr.variable for expr in parse_template_expressions(message)}
-    except TemplateExpressionError:
-        return set()
-
-def render_reply_message_template(message: str, variables: dict[str, str], config: dict | None = None) -> str:
-    try:
-        spans = list(iter_template_expression_parts(message))
-    except TemplateExpressionError:
-        return message
-
-    rendered = []
-    last_index = 0
-    for start, end, content in spans:
-        rendered.append(message[last_index:start])
-        try:
-            expr = parse_template_expression(content)
-        except TemplateExpressionError:
-            rendered.append(message[start:end])
-            last_index = end
-            continue
-
-        if expr.variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
-            raw_value = variables.get(f"__{expr.variable}_raw", "")
-            if raw_value or expr.args:
-                rendered.append(format_opsgenie_template_datetime(raw_value, expr.variable, config, expr.args))
-            else:
-                rendered.append(variables.get(expr.variable, UNKNOWN_ONCALL_PERIOD_PLACEHOLDER))
-        else:
-            rendered.append(variables.get(expr.variable, message[start:end]))
-        last_index = end
-
-    rendered.append(message[last_index:])
-    return "".join(rendered)
-
-async def build_reply_template_variables(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, user: User, text: str, ts: str, permalink: str, include_opsgenie: bool = False) -> dict[str, str]:
-    wait_time = config.get('wait_time')
-    opsgenie_template_variables = {}
-    if include_opsgenie:
-        opsgenie_template_variables = await get_opsgenie_template_variables(app, opsgenie_token, config)
-
-    return {
-        "channel": f"#{channel.name}",
-        "channel_name": channel.name,
-        "config": config_name,
-        "message": text,
-        "message_link": permalink,
-        **opsgenie_template_variables,
-        "team": user.team if user.team else TEAM_UNKNOWN,
-        "timestamp": ts,
-        "user": f"<@{user.id}>",
-        "user_name": user.real_name if user.real_name else user.name,
-        "wait_minutes": str(wait_time // 60),
-    }
-
-async def set_reply_message(app: AsyncApp, channel: Channel, config_name: str, message: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    # check message
-    if not message or message.strip() == "":
-        await send_message(app, channel, user, "Invalid *reply message*. Must be non-empty.", thread_ts)
-        return
-    ok, error, message = await process_mentions(app, message)
-    if not ok:
-        await send_message(app, channel, user, "Invalid *reply message*: " + error + ".", thread_ts)
-        return
-
-    validation_error = validate_template_expressions(message)
-    if validation_error:
-        await send_message(
-            app,
-            channel,
-            user,
-            "Invalid *reply message*: " + validation_error,
-            thread_ts
-        )
-        return
-
-    channel.configs[config_name]['reply_message'] = message
-    await save_configuration()
-    await send_message(app, channel, user, f"*Reply message* set to: {message} in configuration `{config_name}`.", thread_ts)
-
-async def test_reply_message(app: AsyncApp, opsgenie_token: str, channel: Channel, config_name: str, user: User, text: str = "", ts: str = "", thread_ts: str = "") -> None:
-    config = channel.configs.get(config_name, DEFAULT_CONFIG.copy())
-    reply_message_template = config.get('reply_message')
-    permalink = await get_message_permalink(app, channel, ts) if ts else ""
-    template_variables = await build_reply_template_variables(
-        app,
-        opsgenie_token,
-        channel,
-        config,
-        config_name,
-        user,
-        text,
-        ts,
-        permalink,
-        include_opsgenie=True,
-    )
-    reply_message = render_reply_message_template(reply_message_template, template_variables, config)
-    variable_lines = [
-        f"`{{{{{variable}}}}}`: {template_variables.get(variable, '')}"
-        for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES)
-    ]
-    message = (
-        f"*Reply preview for configuration `{config_name}`:*\n"
-        f"{reply_message}\n\n"
-        "*Template variables:*\n"
-        + "\n".join(variable_lines)
-    )
-    await send_message(app, channel, user, message, thread_ts)
-
-async def set_pattern(app: AsyncApp, channel: Channel, config_name: str, pattern_str: str, case_sensitive_str: str | None, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-
-    pattern_str = strip_quotes(pattern_str)
-
-    # Validate the regex pattern
-    try:
-        re.compile(pattern_str)
-    except re.error as e:
-        await send_message(app, channel, user, f"Invalid pattern: `{e}`", thread_ts)
-        return
+#!/usr/bin/env python3
+"""Backward-compatible launcher for the former ``python bot.py`` entry point."""
 
-    case_sensitive = case_sensitive_str is not None and case_sensitive_str.lower() in ['true', '1']
-
-    channel.configs[config_name]['pattern'] = pattern_str
-    channel.configs[config_name]['pattern_case_sensitive'] = case_sensitive
-    await save_configuration()
-
-    message = f"Pattern set to `{pattern_str}` for configuration `{config_name}`."
-    if case_sensitive:
-        message += " (case-sensitive)"
-    else:
-        message += " (case-insensitive)"
-    await send_message(app, channel, user, message, thread_ts)
-
-async def delete_config(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    if config_name == DEFAULT_CONFIG_NAME:
-        await send_message(app, channel, user, f"The `{DEFAULT_CONFIG_NAME}` configuration cannot be deleted.", thread_ts)
-        return
-
-    if config_name not in channel.configs:
-        await send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
-        return
-
-    del channel.configs[config_name]
-    await save_configuration()
-    await send_message(app, channel, user, f"Configuration `{config_name}` has been deleted.", thread_ts)
-
-async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]:
-    # Regular expression to find @username patterns
-    matches = MENTION_PATTERN.findall(message)
-    if matches:
-        for user_match in matches:
-            user = await get_user_by_name(app, user_match)
-            if user.id:
-                message = message.replace(f"@{user_match}", f"<@{user.id}>")
-            else:
-                log_error(f"Invalid *reply message*: username `{user_match}` not found")
-                return False, f"{user_match} not found", ""
-    return True, "", message
-
-async def add_excluded_team(app: AsyncApp, channel: Channel, config_name: str, team: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    config = channel.configs[config_name]
-    await update_user_cache(app)
-    if team not in team_cache:
-        await send_message(app, channel, user, f"Unknown team: `{team}`.", thread_ts)
-        return
-    if team in config['excluded_teams']:
-        await send_message(app, channel, user, f"`{team}` is already excluded in configuration `{config_name}`.", thread_ts)
-        return
-
-    if len(config['included_teams']) > 0:
-        await send_message(app, channel, user, f"Either set *included teams* or *excluded teams*, not both, in configuration `{config_name}`.", thread_ts)
-        return
-
-    config['excluded_teams'].append(team)
-    await save_configuration()
-    await send_message(app, channel, user, f"Added `{team}` to *excluded teams* in configuration `{config_name}`.", thread_ts)
-
-async def clear_excluded_team(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['excluded_teams'] = []
-    await save_configuration()
-    await send_message(app, channel, user, f"Cleared *excluded teams* in configuration `{config_name}`.", thread_ts)
-
-async def add_included_team(app: AsyncApp, channel: Channel, config_name: str, team: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    config = channel.configs[config_name]
-    await update_user_cache(app)
-    if team not in team_cache:
-        await send_message(app, channel, user, f"Unknown team: `{team}`.", thread_ts)
-        return
-    if team in config['included_teams']:
-        await send_message(app, channel, user, f"`{team}` is already included in configuration `{config_name}`.", thread_ts)
-        return
-
-    if len(config['excluded_teams']) > 0:
-        await send_message(app, channel, user, f"Either set *included teams* or *excluded teams*, not both, in configuration `{config_name}`.", thread_ts)
-        return
-
-    config['included_teams'].append(team)
-    await save_configuration()
-    await send_message(app, channel, user, f"Added `{team}` to *included teams* in configuration `{config_name}`.", thread_ts)
-
-async def clear_included_team(app: AsyncApp, channel: Channel, config_name: str, user: User, thread_ts: str = "") -> None:
-    if config_name not in channel.configs:
-        channel.configs[config_name] = DEFAULT_CONFIG.copy()
-    channel.configs[config_name]['included_teams'] = []
-    await save_configuration()
-    await send_message(app, channel, user, f"Cleared *included teams* in configuration `{config_name}`.", thread_ts)
-
-async def list_teams(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
-    await update_user_cache(app)
-    message = f"*Available teams*:\n{'\n'.join(sorted(team_cache, key=lambda v: v.upper()))}"
-    await send_message(app, channel, user, message, thread_ts)
-
-async def list_opsgenie_schedules(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
-    opsgenie_token = get_env_var("OPSGENIE_TOKEN")
-    if not opsgenie_token:
-        await send_message(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
-        return
-
-    url = "https://api.opsgenie.com/v2/schedules"
-    headers = {
-        "Authorization": f"GenieKey {opsgenie_token}",
-    }
-
-    try:
-        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
-            async with session.get(url, headers=headers) as response:
-                if response.status != 200:
-                    log_error(f"Failed to list OpsGenie schedules: {response.status}")
-                    await send_message(app, channel, user, f"Failed to list OpsGenie schedules: HTTP {response.status}.", thread_ts)
-                    return
-
-                payload = await response.json()
-    except Exception as e:
-        log_error("Failed to list OpsGenie schedules:", e)
-        await send_message(app, channel, user, "Failed to list OpsGenie schedules.", thread_ts)
-        return
-
-    schedules = payload.get("data", [])
-    if not schedules:
-        await send_message(app, channel, user, "No OpsGenie schedules found.", thread_ts)
-        return
-
-    schedule_names = sorted(
-        (schedule.get("name", "").strip() for schedule in schedules if schedule.get("name")),
-        key=str.casefold
-    )
-    if not schedule_names:
-        await send_message(app, channel, user, "No OpsGenie schedules found.", thread_ts)
-        return
-
-    message = "*OpsGenie schedules*:\n" + "\n".join(f"`{name}`" for name in schedule_names)
-    await send_message(app, channel, user, message, thread_ts)
-
-async def get_team_of(app: AsyncApp, channel: Channel, username: str, user: User, thread_ts: str = "") -> None:
-    message = None
-    log_debug(channel, f"Looking up users from message `{username}`...")
-    for match in ID_PATTERN.finditer(username):
-        full_match = match.group(0)
-        log_debug(channel, f"Found ID match: {full_match}...")
-        id = match.group(1)
-        if id and id[0] == '@':
-            user_id = id[1:]
-            log_debug(channel, f"Looking up user with ID {user_id}...")
-            u = await get_user_by_id(app, user_id, channel)
-            if u.id:
-                log_debug(channel, f"Found user {u}")
-                display_name = u.real_name if u.real_name else u.name
-                msg = f"*{display_name}* (<@{u.id}>): `{u.team}`"
-                if message is None:
-                    message = msg
-                else:
-                    message += f"\n{msg}"
-            else:
-                log_error(f"Invalid request: username `{full_match}` not found")
-    if message:
-        await send_message(app, channel, user, message, thread_ts)
-    else:
-        await send_message(app, channel, user, f"Unknown user: `{username}`.", thread_ts)
-
-async def show_config(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
-    if not channel.configs:
-        message = f"There is no configuration for #{channel.name}."
-        await send_message(app, channel, user, message, thread_ts)
-        return
-
-    def format_table_value(value, key_width: int) -> str:
-        if isinstance(value, list):
-            if not value:
-                return '<None>'
-            return f"\n{' ' * (key_width + 2)}".join(value)
-        return value
-
-    message = f"This is the configuration for #{channel.name}:"
-    for config_name, config in sorted(channel.configs.items()):
-        opsgenie_enabled = config.get('opsgenie')
-        wait_time_minutes = config.get('wait_time') // 60
-        included_teams = config.get('included_teams')
-        excluded_teams = config.get('excluded_teams')
-        include_bots = config.get('include_bots')
-        only_work_days = config.get('only_work_days')
-        hours = config.get('hours')
-        pattern = config.get('pattern')
-        pattern_case_sensitive = config.get('pattern_case_sensitive')
-        reply_message = config.get('reply_message')
-        forward_channel_id = config.get('forward_channel') or ''
-        opsgenie_schedule_name = config.get('opsgenie_schedule_name')
-        date_format = config.get('date_format') or DEFAULT_DATE_FORMAT
-        time_format = config.get('time_format') or DEFAULT_TIME_FORMAT
-        datetime_timezone = config.get('datetime_timezone') or '<server local>'
-        datetime_locale = config.get('datetime_locale') or '<default>'
-        opsgenie_priority = get_opsgenie_priority(config)
-        replies_enabled = config.get('enabled', True)
-
-        rows = [
-            ("OpsGenie",           ('enabled' if opsgenie_enabled else 'disabled') + ('' if opsgenie_configured else ' (not configured)')),
-            ("OpsGenie schedule",  opsgenie_schedule_name),
-            ("OpsGenie priority",  opsgenie_priority),
-            ("Date format",        date_format),
-            ("Time format",        time_format),
-            ("Date/time timezone", datetime_timezone),
-            ("Date/time locale",   datetime_locale),
-            ("Wait time",          f"{wait_time_minutes} minutes"),
-            ("Included teams",     included_teams),
-            ("Excluded teams",     excluded_teams),
-            ("Include bots",       'enabled' if include_bots else 'disabled'),
-            ("Only work days",     'enabled' if only_work_days else 'disabled'),
-            ("Work hours",         f"{hours[0]} - {hours[1]}" if len(hours) == 2 else 'all day'),
-            ("Pattern",            f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<None>'),
-        ]
-        key_width = max(len(label) for label, _ in rows)
-        config_block = "\n".join(f"{label:<{key_width}}  {format_table_value(value, key_width)}" for label, value in rows)
-        forward_channel_line = f"*Forward channel*: {f'<#{forward_channel_id}>' if forward_channel_id else '<None>'}"
-        reply_line = f"*Reply message*:\n{reply_message}" if reply_message else "*Reply message*: <None>"
-        enabled_label = 'enabled' if replies_enabled else 'disabled'
-        quoted_block = (
-            f"> {reply_line.replace('\n', '\n> ')}\n"
-            f">\n"
-            f"> {forward_channel_line}\n"
-            f">\n"
-            f"> *Settings*:\n"
-        )
-        message += (
-            f"\n\n*Configuration*: `{config_name}` ({enabled_label})\n"
-            f"{quoted_block}"
-            f"```\n{config_block}\n```"
-        )
-    await send_message(app, channel, user, message, thread_ts)
-
-async def send_message(app: AsyncApp, channel: Channel, user: User, text: str, thread_ts: str = "") -> None:
-    log_debug(channel, f"Attempting to send message to #{channel.name}, user @{user.name}: {text.replace('\n', '\\n')}")
-    retries = 3
-    delay = 1
-    for attempt in range(retries):
-        try:
-            if thread_ts:
-                await app.client.chat_postMessage(
-                    channel=channel.id,
-                    thread_ts=thread_ts,
-                    text=text,
-                    mrkdwn=True
-                )
-            else:
-                await app.client.chat_postEphemeral(
-                    channel=channel.id,
-                    user=user.id,
-                    text=text,
-                    mrkdwn=True
-                )
-            log_debug(channel, f"Successfully sent message to #{channel.name}, user @{user.name}")
-            return  # Exit if successful
-        except SlackApiError as e:
-            if attempt < retries - 1:
-                log_warning(f"Failed to send message in channel #{channel.name}, user @{user.name}, retrying in {delay} seconds ({attempt + 1}/{retries})...", e)
-                await asyncio.sleep(delay)
-                delay *= 2  # Exponential backoff
-            else:
-                log_error(f"Failed to send message in channel #{channel.name}, user @{user.name} after {retries} attempts:", e)
-
-async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
-    update_text = (
-        "Hi! :wave: I am *Hutbot* :palm_up_hand::tophat: Here's what's :new::\n\n"
-        "> :calendar: *OpsGenie date/time template variables and defaults*\n>\n"
-        "> OpsGenie templates can now include current and next on-call start/end dates, times, and datetimes. Use `/hutbot [config] set datetime-format \"<date>\" \"<time>\" [<timezone> <locale>]` to set the defaults.\n>\n"
-        "> :pencil: *Customize reply messages with `{{placeholders}}`*\n>\n"
-        "> That means Hutbot can include details like the `{{user}}`, `{{team}}`, `{{channel}}` or `{{wait_minutes}}`, or even mention the person who is currently on-call `{{opsgenie_current_user}}` in the reply message :exploding_head:.\n>\n"
-        "> :sparkles: Just configure an Opsgenie schedule and you are good to go.\n>\n"
-        "> :list-item: *List available Opsgenie schedules*\n>\n"
-        "> :telephone_receiver: *Print the current on-call user*\n"
-        "> Use `/hutbot [config] on-call [schedule name]` to get the current OpsGenie on-call user as a Slack mention.\n>\n"
-        "> :test_tube: *Preview your configured reply*\n"
-        "> Use `/hutbot [config] test` or mention me with `@Hutbot [config] test <message>` to test reply templates and variables.\n>\n"
-        "> :bug: *Hutbot now ONLY cancels replying, when the _expected_ team(s) have already replied* :lightbulb:\n>\n"
-        "> Issue was:\n>\n"
-        "> 1. Team *A* sends a message intended for Team *B*\n"
-        "> 2. Someone else from Team *A* adds additional information\n"
-        "> 3. Hutbot cancels the reply and does NOT remind Team *B* anymore :fail:\n"
-    )
-    await send_message(app, channel, user, update_text, thread_ts)
-
-async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
-    supported_template_variables = ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
-    command_rows = [
-        ("/hutbot show config", "Show all configurations."),
-        ("/hutbot [config] enable opsgenie", "Enable OpsGenie alerts."),
-        ("/hutbot [config] disable opsgenie", "Disable OpsGenie alerts."),
-        ("/hutbot [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
-        ("/hutbot [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
-        ("/hutbot [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Set date/time formats."),
-        ("/hutbot [config] set wait-time <minutes>", "Set reminder delay."),
-        ("/hutbot list teams", "List available teams."),
-        ("/hutbot list opsgenie-schedules", "List OpsGenie schedules."),
-        ("/hutbot [config] on-call [schedule]", "Show current on-call user."),
-        ("/hutbot team of <@user>", "Show a user's team."),
-        ("/hutbot [config] add excluded-team <team>", "Add an ignored team."),
-        ("/hutbot [config] clear excluded-teams", "Clear ignored teams."),
-        ("/hutbot [config] add included-team <team>", "Add an allowed team."),
-        ("/hutbot [config] clear included-teams", "Clear allowed teams."),
-        ("/hutbot [config] enable bots", "Respond to bot messages."),
-        ("/hutbot [config] disable bots", "Ignore bot messages."),
-        ("/hutbot [config] enable only-work-days", "Respond only on work days."),
-        ("/hutbot [config] disable only-work-days", "Respond on all days."),
-        ("/hutbot [config] enable", "Enable sending replies for this config."),
-        ("/hutbot [config] disable", "Disable sending replies for this config."),
-        ("/hutbot [config] set work-hours <start> <end>", "Set active hours; 0:00 0:00 means all day."),
-        ("/hutbot [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
-        ("/hutbot [config] set message \"<reply message>\"", "Set reminder message."),
-        ("/hutbot [config] set forward-channel <#channel>", "Forward replies to another channel."),
-        ("/hutbot [config] clear forward-channel", "Remove the forward channel."),
-        ("/hutbot [config] test", "Preview configured reply."),
-        ("@Hutbot [config] test <message>", "Preview reply with <message> as {{message}}."),
-        ("/hutbot delete config <name>", "Delete a configuration."),
-        ("/hutbot news", "Show what's new."),
-        ("/hutbot help", "Show this help."),
-    ]
-    command_width = max(len(command) for command, _ in command_rows)
-    command_usage = "\n".join(f"{command:<{command_width}}  {description}" for command, description in command_rows)
-    help_text = (
-        "Hi! :wave: I am *Hutbot* :palm_up_hand::tophat: Here's what I can do:\n\n"
-        "*Show All Configurations:*\n"
-        "> Either use the command `/hutbot` or just `@Hutbot` me.\n"
-        "```/hutbot show config\n"
-        "@Hutbot show config```\n"
-        f"Displays all configurations for `#{channel.name}`.\n\n"
-        "*Commands:*\n"
-        f"```\n{command_usage}\n```\n\n"
-        "`[config]` is optional; omitted commands use `default`.\n\n"
-        f"Supported reply variables: {supported_template_variables}."
-    )
-    await send_message(app, channel, user, help_text, thread_ts)
-
-def get_opsgenie_placeholder_variables(config: dict | None = None) -> dict[str, str]:
-    schedule_name = (config or {}).get("opsgenie_schedule_name", "").strip()
-    variables = {
-        "opsgenie_schedule_name": schedule_name or UNKNOWN_OPSGENIE_SCHEDULE_PLACEHOLDER,
-        "opsgenie_current_email": UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
-        "opsgenie_current_name": UNKNOWN_NAME_ONCALL_PLACEHOLDER,
-        "opsgenie_current_user": UNKNOWN_USER_ONCALL_PLACEHOLDER,
-        "opsgenie_next_email": UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
-        "opsgenie_next_name": UNKNOWN_NAME_ONCALL_PLACEHOLDER,
-        "opsgenie_next_user": UNKNOWN_USER_ONCALL_PLACEHOLDER,
-    }
-    for variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
-        variables[variable] = UNKNOWN_ONCALL_PERIOD_PLACEHOLDER
-        variables[f"__{variable}_raw"] = ""
-    return variables
-
-def fill_opsgenie_period_variables(variables: dict[str, str], config: dict, prefix: str, period: OpsGeniePeriod) -> None:
-    if not period.recipient_email:
-        return
-
-    variables[f"opsgenie_{prefix}_email"] = period.recipient_email
-    variables[f"opsgenie_{prefix}_name"] = period.recipient_email
-    if period.slack_user:
-        variables[f"opsgenie_{prefix}_user"] = f"<@{period.slack_user.id}>"
-        variables[f"opsgenie_{prefix}_name"] = period.slack_user.real_name if period.slack_user.real_name else period.slack_user.name
-
-    for bound, value in (("start", period.start), ("end", period.end)):
-        for part in ("date", "time", "datetime"):
-            variable = f"opsgenie_{prefix}_{bound}_{part}"
-            variables[f"__{variable}_raw"] = value or ""
-            variables[variable] = format_opsgenie_template_datetime(value, variable, config)
-
-async def resolve_slack_user_for_opsgenie_recipient(app: AsyncApp, recipient_email: str) -> User | None:
-    slack_user = await get_user_by_email(app, recipient_email)
-    if not slack_user.id:
-        log_warning(f"Failed to map OpsGenie recipient '{recipient_email}' to a Slack user.")
-        return None
-    return slack_user
-
-async def resolve_opsgenie_on_call(app: AsyncApp, opsgenie_token: str, schedule_name: str) -> tuple[str, User | None]:
-    schedule_name = schedule_name.strip()
-    if not opsgenie_token:
-        log_warning(f"Cannot resolve OpsGenie schedule '{schedule_name}': missing token.")
-        return "", None
-
-    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
-    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/on-calls"
-    headers = {
-        "Authorization": f"GenieKey {opsgenie_token}",
-    }
-    params = {
-        "scheduleIdentifierType": "name",
-        "flat": "true",
-    }
-
-    try:
-        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
-            async with session.get(url, headers=headers, params=params) as response:
-                if response.status != 200:
-                    log_error(f"Failed to retrieve on-call recipients for OpsGenie schedule '{schedule_name}': {response.status}")
-                    return "", None
-                payload = await response.json()
-    except Exception as e:
-        log_error(f"Failed to retrieve on-call recipients for OpsGenie schedule '{schedule_name}':", e)
-        return "", None
-
-    recipients = payload.get("data", {}).get("onCallRecipients", [])
-    if not recipients:
-        log_warning(f"OpsGenie schedule '{schedule_name}' returned no current on-call recipients.")
-        return "", None
-
-    recipient_email = recipients[0].strip()
-    if not recipient_email:
-        return "", None
-
-    return recipient_email, await resolve_slack_user_for_opsgenie_recipient(app, recipient_email)
-
-def parse_opsgenie_datetime(value: str) -> datetime.datetime | None:
-    if not value:
-        return None
-    try:
-        parsed = datetime.datetime.fromisoformat(value.replace("Z", "+00:00"))
-    except ValueError:
-        return None
-    if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=datetime.timezone.utc)
-    return parsed
-
-def format_opsgenie_datetime(value: str, local_tz: datetime.tzinfo | None = None) -> str:
-    return format_datetime_value(value, "datetime", local_tz=local_tz)
-
-def merge_opsgenie_periods(periods: list[dict], current_index: int) -> tuple[str, str]:
-    current_period = periods[current_index]
-    recipient_name = current_period.get("recipient", {}).get("name", "").strip().casefold()
-    merged_start = parse_opsgenie_datetime(current_period.get("startDate", ""))
-    merged_end = parse_opsgenie_datetime(current_period.get("endDate", ""))
-    if not recipient_name or merged_start is None or merged_end is None:
-        return current_period.get("startDate", ""), current_period.get("endDate", "")
-
-    first_period = current_period
-    last_period = current_period
-
-    for period in reversed(periods[:current_index]):
-        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
-        period_start = parse_opsgenie_datetime(period.get("startDate", ""))
-        period_end = parse_opsgenie_datetime(period.get("endDate", ""))
-        if period_recipient != recipient_name or period_start is None or period_end is None or period_end != merged_start:
-            break
-        merged_start = period_start
-        first_period = period
-
-    for period in periods[current_index + 1:]:
-        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
-        period_start = parse_opsgenie_datetime(period.get("startDate", ""))
-        period_end = parse_opsgenie_datetime(period.get("endDate", ""))
-        if period_recipient != recipient_name or period_start is None or period_end is None or period_start != merged_end:
-            break
-        merged_end = period_end
-        last_period = period
-
-    return first_period.get("startDate", ""), last_period.get("endDate", "")
-
-def merge_opsgenie_periods_forward(periods: list[dict], current_index: int) -> tuple[str, str]:
-    current_period = periods[current_index]
-    recipient_name = current_period.get("recipient", {}).get("name", "").strip().casefold()
-    merged_end = parse_opsgenie_datetime(current_period.get("endDate", ""))
-    if not recipient_name or merged_end is None:
-        return current_period.get("startDate", ""), current_period.get("endDate", "")
-
-    last_period = current_period
-    for period in periods[current_index + 1:]:
-        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
-        period_start = parse_opsgenie_datetime(period.get("startDate", ""))
-        period_end = parse_opsgenie_datetime(period.get("endDate", ""))
-        if period_recipient != recipient_name or period_start is None or period_end is None or period_start != merged_end:
-            break
-        merged_end = period_end
-        last_period = period
-
-    return current_period.get("startDate", ""), last_period.get("endDate", "")
-
-def find_opsgenie_on_call_period(data: dict, recipient_email: str, now: datetime.datetime | None = None) -> tuple[str, str]:
-    now = now or datetime.datetime.now(datetime.timezone.utc)
-    if now.tzinfo is None:
-        now = now.replace(tzinfo=datetime.timezone.utc)
-
-    rotations = []
-    for timeline_name in ("finalTimeline", "baseTimeline"):
-        rotations.extend(data.get(timeline_name, {}).get("rotations", []))
-
-    periods = [period for rotation in rotations for period in rotation.get("periods", [])]
-    if not periods:
-        return "", ""
-
-    recipient_email = recipient_email.casefold()
-
-    for rotation in rotations:
-        rotation_periods = sorted(
-            rotation.get("periods", []),
-            key=lambda period: parse_opsgenie_datetime(period.get("startDate", "")) or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
-        )
-        for index, period in enumerate(rotation_periods):
-            start = parse_opsgenie_datetime(period.get("startDate", ""))
-            end = parse_opsgenie_datetime(period.get("endDate", ""))
-            is_current = start is not None and end is not None and start <= now < end
-            recipient_name = period.get("recipient", {}).get("name", "").strip().casefold()
-            matches_recipient = bool(recipient_email and recipient_name == recipient_email)
-            if is_current and matches_recipient:
-                return merge_opsgenie_periods(rotation_periods, index)
-
-    return "", ""
-
-def find_opsgenie_upcoming_on_call_period(data: dict, now: datetime.datetime | None = None) -> tuple[str, str, str]:
-    now = now or datetime.datetime.now(datetime.timezone.utc)
-    if now.tzinfo is None:
-        now = now.replace(tzinfo=datetime.timezone.utc)
-
-    best_candidate = None
-    for timeline_name in ("finalTimeline", "baseTimeline"):
-        rotations = data.get(timeline_name, {}).get("rotations", [])
-        for rotation in rotations:
-            rotation_periods = sorted(
-                rotation.get("periods", []),
-                key=lambda period: parse_opsgenie_datetime(period.get("startDate", "")) or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
-            )
-            threshold = now
-            include_threshold = False
-            for index, period in enumerate(rotation_periods):
-                start = parse_opsgenie_datetime(period.get("startDate", ""))
-                end = parse_opsgenie_datetime(period.get("endDate", ""))
-                if start is not None and end is not None and start <= now < end:
-                    _, merged_end = merge_opsgenie_periods(rotation_periods, index)
-                    threshold = parse_opsgenie_datetime(merged_end) or end
-                    include_threshold = True
-                    break
-
-            for index, period in enumerate(rotation_periods):
-                start = parse_opsgenie_datetime(period.get("startDate", ""))
-                end = parse_opsgenie_datetime(period.get("endDate", ""))
-                recipient_email = period.get("recipient", {}).get("name", "").strip()
-                if start is None or end is None or not recipient_email:
-                    continue
-                if start < threshold or (start == threshold and not include_threshold):
-                    continue
-
-                candidate = (start, rotation_periods, index, recipient_email)
-                if best_candidate is None or candidate[0] < best_candidate[0]:
-                    best_candidate = candidate
-
-    if best_candidate is None:
-        return "", "", ""
-
-    _, rotation_periods, index, recipient_email = best_candidate
-    start, end = merge_opsgenie_periods_forward(rotation_periods, index)
-    return recipient_email, start, end
-
-async def resolve_opsgenie_on_call_period(opsgenie_token: str, schedule_name: str, recipient_email: str) -> tuple[str, str]:
-    schedule_name = schedule_name.strip()
-    if not opsgenie_token:
-        return "", ""
-
-    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
-    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/timeline"
-    headers = {
-        "Authorization": f"GenieKey {opsgenie_token}",
-    }
-    timeline_start = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=90)
-    params = {
-        "identifierType": "name",
-        "date": timeline_start.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "interval": "6",
-        "intervalUnit": "months",
-    }
-
-    try:
-        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
-            async with session.get(url, headers=headers, params=params) as response:
-                if response.status != 200:
-                    log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}': {response.status}")
-                    return "", ""
-                payload = await response.json()
-    except Exception as e:
-        log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}':", e)
-        return "", ""
-
-    return find_opsgenie_on_call_period(payload.get("data", {}), recipient_email)
-
-async def resolve_opsgenie_upcoming_on_call_period(opsgenie_token: str, schedule_name: str) -> tuple[str, str, str]:
-    schedule_name = schedule_name.strip()
-    if not opsgenie_token:
-        return "", "", ""
-
-    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
-    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/timeline"
-    headers = {
-        "Authorization": f"GenieKey {opsgenie_token}",
-    }
-    timeline_start = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=90)
-    params = {
-        "identifierType": "name",
-        "date": timeline_start.strftime("%Y-%m-%dT%H:%M:%SZ"),
-        "interval": "6",
-        "intervalUnit": "months",
-    }
-
-    try:
-        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
-            async with session.get(url, headers=headers, params=params) as response:
-                if response.status != 200:
-                    log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}': {response.status}")
-                    return "", "", ""
-                payload = await response.json()
-    except Exception as e:
-        log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}':", e)
-        return "", "", ""
-
-    return find_opsgenie_upcoming_on_call_period(payload.get("data", {}))
-
-async def resolve_opsgenie_on_call_context(app: AsyncApp, opsgenie_token: str, schedule_name: str, include_next: bool = True) -> OpsGenieContext:
-    schedule_name = schedule_name.strip()
-    empty_period = OpsGeniePeriod("", None, "", "")
-    current_period = empty_period
-    next_period = empty_period
-
-    recipient_email, slack_user = await resolve_opsgenie_on_call(app, opsgenie_token, schedule_name)
-    if recipient_email:
-        start, end = await resolve_opsgenie_on_call_period(opsgenie_token, schedule_name, recipient_email)
-        current_period = OpsGeniePeriod(recipient_email, slack_user, start, end)
-
-    if include_next:
-        next_email, next_start, next_end = await resolve_opsgenie_upcoming_on_call_period(opsgenie_token, schedule_name)
-        next_slack_user = await resolve_slack_user_for_opsgenie_recipient(app, next_email) if next_email else None
-        next_period = OpsGeniePeriod(next_email, next_slack_user, next_start, next_end)
-
-    return OpsGenieContext(schedule_name, current_period, next_period)
-
-async def get_opsgenie_template_variables(app: AsyncApp, opsgenie_token: str, config: dict) -> dict[str, str]:
-    schedule_name = config.get("opsgenie_schedule_name", "").strip()
-    variables = get_opsgenie_placeholder_variables(config)
-    if not schedule_name:
-        return variables
-
-    context = await resolve_opsgenie_on_call_context(app, opsgenie_token, schedule_name, include_next=True)
-    fill_opsgenie_period_variables(variables, config, "current", context.current)
-    fill_opsgenie_period_variables(variables, config, "next", context.next)
-
-    return variables
-
-async def send_current_on_call(app: AsyncApp, opsgenie_token: str, channel: Channel, config_name: str, schedule_name: str, user: User, thread_ts: str = "") -> None:
-    config = channel.configs.get(config_name, DEFAULT_CONFIG.copy())
-    schedule_name = schedule_name.strip() or config.get("opsgenie_schedule_name", "").strip()
-    if not schedule_name:
-        await send_message(app, channel, user, "No OpsGenie schedule configured. Use `/hutbot [config] set opsgenie-schedule <name>` or `/hutbot [config] on-call <schedule name>`.", thread_ts)
-        return
-    if not opsgenie_token:
-        await send_message(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
-        return
-
-    recipient_email, slack_user = await resolve_opsgenie_on_call(app, opsgenie_token, schedule_name)
-    if recipient_email:
-        start, end = await resolve_opsgenie_on_call_period(opsgenie_token, schedule_name, recipient_email)
-    else:
-        recipient_email, start, end = await resolve_opsgenie_upcoming_on_call_period(opsgenie_token, schedule_name)
-        if recipient_email:
-            slack_user = await resolve_slack_user_for_opsgenie_recipient(app, recipient_email)
-
-    if not recipient_email:
-        await send_message(app, channel, user, f"Failed to resolve on-call user for OpsGenie schedule `{schedule_name}`.", thread_ts)
-        return
-
-    mention = f"<@{slack_user.id}>" if slack_user else recipient_email
-    message = (
-        f"*Schedule*: `{schedule_name}`\n"
-        f"*On-call*: {mention}\n"
-        f"*Start*: `{format_datetime_value(start, 'datetime', config)}`\n"
-        f"*End*: `{format_datetime_value(end, 'datetime', config)}`"
-    )
-    await send_message(app, channel, user, message, thread_ts)
-
-async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, user: User, text: str, ts: str, wait_time_override: float | None = None) -> None:
-    opsgenie_enabled = config.get('opsgenie')
-    wait_time = config.get('wait_time')
-    reply_message_template = config.get('reply_message')
-    scheduled_message_key = (channel.id, ts, config_name)
-    actual_wait = wait_time_override if wait_time_override is not None else wait_time
-    log(f"Scheduling reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, wait time {wait_time // 60} mins, opsgenie {'enabled' if opsgenie_enabled else 'disabled'}{', but not configured' if opsgenie_enabled and not opsgenie_configured else ''}")
-    try:
-        await asyncio.sleep(actual_wait)
-        permalink = await get_message_permalink(app, channel, ts)
-        template_variables = find_template_variables(reply_message_template)
-        reply_message = render_reply_message_template(
-            reply_message_template,
-            await build_reply_template_variables(
-                app,
-                opsgenie_token,
-                channel,
-                config,
-                config_name,
-                user,
-                text,
-                ts,
-                permalink,
-                include_opsgenie=bool(OPSGENIE_TEMPLATE_VARIABLES.intersection(template_variables)),
-            ),
-            config,
-        )
-        await send_message(app, channel, user, reply_message, ts)
-        forward_channel_id = config.get('forward_channel')
-        if forward_channel_id:
-            try:
-                forward_text = f"{reply_message}\n\n*Original message in #{channel.name}:* {permalink}"
-                await app.client.chat_postMessage(channel=forward_channel_id, text=forward_text, mrkdwn=True)
-            except SlackApiError as e:
-                log_error(f"Failed to forward reply to channel {forward_channel_id}:", e)
-        if opsgenie_configured and opsgenie_enabled:
-            log(f"Attempting to send OpsGenie alert for message {ts} in channel #{channel.name}, user @{user.name}...")
-            await post_opsgenie_alert(app, opsgenie_token, channel, config, user, text, ts, permalink)
-    except asyncio.CancelledError as e:
-        log(f"Cancelling scheduled reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}:", e)
-    except Exception as e:
-        log_error(f"Failed to send scheduled reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}:", e)
-    finally:
-        scheduled_messages.pop(scheduled_message_key, None)
-        _scheduled_replies_cache.pop(scheduled_message_key, None)
-        await flush_replies_cache()
-
-async def replace_ids(app: AsyncApp, channel: Channel | None, text: str) -> str:
-    for match in ID_PATTERN.finditer(text):
-        full_match = match.group(0)
-        log_debug(channel, f"Found ID match: {full_match}...")
-        id = match.group(1)
-        handled = False
-        if id and id[0] == '@':
-            user_id = id[1:]
-            log_debug(channel, f"Looking up user with ID {user_id}...")
-            user = await get_user_by_id(app, user_id)
-            if user.id:
-                log_debug(channel, f"Found user {user}")
-                text = text.replace(full_match, user.real_name)
-                handled = True
-        elif id and id[0] == '#':
-            ch_id = id[1:]
-            log_debug(channel, f"Looking up channel with ID {ch_id}...")
-            ch = await get_channel_by_id(app, ch_id)
-            if ch.id:
-                log_debug(channel, f"Found channel {ch}")
-                text = text.replace(full_match, f"#{ch.name}")
-                handled = True
-        elif id and id.startswith('!subteam^'):
-            ug_id = id[9:]
-            log_debug(channel, f"Looking up usergroup with ID {ug_id}...")
-            ug = await get_usergroup_by_id(app, ug_id)
-            if ug.id:
-                log_debug(channel, f"Found usergroup {ug}")
-                text = text.replace(full_match, f"@{ug.handle}")
-                handled = True
-        if not handled:
-            alias = match.group(3)
-            if alias:
-                log_debug(channel, f"Fallback, replacing {full_match} with alias {alias}.")
-                text = text.replace(full_match, alias)
-            else:
-                log_debug(channel, f"Fallback, replacing {full_match} with {id}.")
-                text = text.replace(full_match, id)
-    return text
-
-async def clean_slack_text(app: AsyncApp, channel: Channel, text: str):
-    # replace all kinds of <@ID> mentions
-    text = await replace_ids(app, channel, text)
-
-    # unescape any escaped formatting characters (like \*, \_, etc.)
-    text = re.sub(r'\\([*_~`])', r'\1', text)
-
-    # process all <...> elements to extract display text or URL
-    def replace_link(match):
-        parts = match.group(1).split('|', 1)
-        if len(parts) == 1 and parts[0].startswith('http'):
-            return "[URL]"
-        return parts[1] if len(parts) > 1 and len(parts[1]) > 0 else parts[0]
-
-    text = re.sub(r'<([^>]+)>', replace_link, text)
-
-    # remove all remaining formatting characters and new lines
-    text = re.sub(r'[*_~`]', '', text).replace('\n', ' ')
-
-    # reduce duplicate spaces and trim
-    text = re.sub(r'\s{2,}', ' ', text).strip()
-
-    return text
-
-def get_opsgenie_priority(config: dict | None) -> str:
-    priority = (config or {}).get('opsgenie_priority', DEFAULT_OPSGENIE_PRIORITY)
-    priority = priority.strip().upper() if isinstance(priority, str) else ""
-    return priority if priority in OPSGENIE_PRIORITIES else DEFAULT_OPSGENIE_PRIORITY
-
-async def post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict | None, user: User, text: str, ts: str, permalink: str) -> None:
-    log_debug(channel, f"> {text.replace('\n', '\\n')}")
-    text = await clean_slack_text(app, channel, text)
-    log_debug(channel, f"< {text}")
-    user_name = user.real_name if user.real_name else user.name
-    priority = get_opsgenie_priority(config)
-    url = 'https://api.opsgenie.com/v2/alerts'
-    headers = {
-        'Content-Type': 'application/json',
-        'Authorization': f'GenieKey {opsgenie_token}'
-    }
-    async with aiohttp.ClientSession() as session:
-        try:
-            data = {
-                "message": f"#{channel.name}: {text}",
-                "alias": f"hutbot: {user_name} in #{channel.name} {ts}",
-                "description": f"{user_name} in #{channel.name}: {text}",
-                "tags": ["Hutbot"],
-                "details": {
-                    "channel": f"#{channel.name}",
-                    "sender": user_name,
-                    "bot": "hutbot",
-                    "permalink": permalink,
-                },
-                "priority": priority,
-            }
-            async with session.post(url, headers=headers, data=json.dumps(data)) as response:
-                if response.status != 202:
-                    log_error(f"Failed to send alert for message {ts} in channel #{channel.name}, user @{user.name}: {response.status}")
-                else:
-                    log(f"Successfully sent OpsGenie alert for message {ts} in channel #{channel.name}, user @{user.name} with status code {response.status}")
-        except Exception as e:
-            log_error(f"Failed to send alert for message {ts} in channel #{channel.name}, user @{user.name}:", e)
-
-def extract_message_text(event: dict) -> str:
-    text = event.get('text', '')
-    if isinstance(text, str) and text.strip():
-        return text
-
-    attachment_texts = []
-    fallback_texts = []
-    for attachment in event.get('attachments', []):
-        if not isinstance(attachment, dict):
-            continue
-
-        for field in ('pretext', 'title', 'text'):
-            value = attachment.get(field, '')
-            if isinstance(value, str) and value.strip():
-                attachment_texts.append(value)
-
-        fallback = attachment.get('fallback', '')
-        if isinstance(fallback, str) and fallback.strip():
-            fallback_texts.append(fallback)
-
-    if attachment_texts:
-        return "\n".join(attachment_texts).strip()
-
-    return "\n".join(fallback_texts).strip()
-
-async def route_message(app: AsyncApp, opsgenie_token: str, event: dict) -> None:
-    subtype = event.get('subtype')
-    previous_message = event.get('previous_message', {})
-    channel_id = event.get('channel', '')
-    user_id = event.get('user', '')
-    bot_id = event.get('bot_id', '')
-    ts = event.get('ts', '')
-    thread_ts = event.get('thread_ts', '')
-    text = extract_message_text(event)
-
-    channel = await get_channel_by_id(app, channel_id)
-    log_debug(channel, f"Received message event from #{channel.name}: {json.dumps(event)}")
-
-    # Ignore messages from the bot itself
-    if user_id == bot_user_id or bot_id == bot_user_id:
-        log(f"Ignoring message from the bot from channel #{channel.name}.")
-        return
-
-    if subtype in IGNORED_MESSAGE_SUBTYPES:
-        log(f"Ignoring message with subtype '{subtype}' for channel #{channel.name}.")
-        return
-
-    actor_is_bot = False
-    user = None
-    if user_id:
-        user = await get_user_by_id(app, user_id)
-        actor_is_bot = user_id == 'USLACKBOT'
-    elif bot_id and (thread_ts or any(c.get('include_bots', False) for c in channel.configs.values())):
-        actor_is_bot = True
-        user = await get_user_by_id(app, bot_id)
-
-    if subtype == 'message_deleted' and previous_message:
-        # deleted message
-        previous_user = await get_user_by_id(app, previous_message.get('user'))
-        await handle_message_deletion(app, channel, previous_user, previous_message.get('ts'))
-    elif user and is_command(text):
-        # command
-        await process_command(app, text, channel, user, ts, opsgenie_token, allow_test_message=True, command_ts=ts)
-    elif user and thread_ts:
-        # thread
-        await handle_thread_response(app, channel, user, thread_ts, actor_is_bot)
-    elif user and ts:
-        # channel message
-        await handle_channel_message(app, opsgenie_token, channel, user, text, ts, actor_is_bot)
-
-def user_matches_actor_criteria(config: dict | None, user: User, actor_is_bot: bool = False) -> bool:
-    if not config:
-        return False
-
-    if actor_is_bot and not config.get('include_bots', False):
-        return False
-
-    included_teams = config.get('included_teams', [])
-    if included_teams and user.team not in included_teams:
-        return False
-
-    excluded_teams = config.get('excluded_teams', [])
-    if excluded_teams and user.team in excluded_teams:
-        return False
-
-    return True
-
-def get_actor_mismatch_reason(config: dict | None, user: User, actor_is_bot: bool = False) -> str:
-    if not config:
-        return "the configuration no longer exists"
-    if actor_is_bot and not config.get('include_bots', False):
-        return "bots are not included"
-    included_teams = config.get('included_teams', [])
-    if included_teams and user.team not in included_teams:
-        return f"team '{user.team}' is not included"
-    excluded_teams = config.get('excluded_teams', [])
-    if excluded_teams and user.team in excluded_teams:
-        return f"team '{user.team}' is excluded"
-    return "the actor does not match the configuration"
-
-async def handle_thread_response(app: AsyncApp, channel: Channel, reply_user: User, thread_ts: str, actor_is_bot: bool = False):
-    keys_to_cancel = []
-    for key, scheduled_reply in scheduled_messages.items():
-        if key[0] != channel.id or key[1] != thread_ts:
-            continue
-
-        config = channel.configs.get(key[2])
-        no_restrictions = (
-            config is not None
-            and not config.get('included_teams')
-            and not config.get('excluded_teams')
-            and (not actor_is_bot or not config.get('include_bots', False))
-        )
-        if no_restrictions or not user_matches_actor_criteria(config, reply_user, actor_is_bot):
-            keys_to_cancel.append(key)
-
-    if not keys_to_cancel:
-        return
-
-    message_user_id = scheduled_messages[keys_to_cancel[0]].user_id
-    message_user = await get_user_by_id(app, message_user_id)
-    log(f"Thread reply by user @{reply_user.name} detected. Cancelling {len(keys_to_cancel)} reminder(s) for message {thread_ts} in channel #{channel.name}, user @{message_user.name}")
-
-    for key in keys_to_cancel:
-        scheduled_messages[key].task.cancel()
-        del scheduled_messages[key]
-
-async def handle_channel_message(app: AsyncApp, opsgenie_token: str, channel: Channel, user: User, text: str, ts: str, actor_is_bot: bool = False):
-    for config_name, config in channel.configs.items():
-        if not config.get('enabled', True):
-            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because replies are disabled.")
-            continue
-
-        only_work_days = config.get('only_work_days')
-        hours = config.get('hours')
-        pattern = config.get('pattern')
-        pattern_case_sensitive = config.get('pattern_case_sensitive')
-
-        if only_work_days and not is_work_day():
-            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because of a non work day.")
-            continue
-        if len(hours) == 2 and not is_work_time(hours[0], hours[1]):
-            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because it was sent outside work time.")
-            continue
-        if not user_matches_actor_criteria(config, user, actor_is_bot):
-            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because {get_actor_mismatch_reason(config, user, actor_is_bot)}.")
-            continue
-
-        if pattern:
-            flags = 0 if pattern_case_sensitive else re.IGNORECASE
-            if not re.search(pattern, text, flags):
-                log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because it does not match pattern '{pattern}'.")
-                continue
-
-        task = asyncio.create_task(schedule_reply(app, opsgenie_token, channel, config, config_name, user, text, ts))
-        scheduled_messages[(channel.id, ts, config_name)] = ScheduledReply(task, user.id)
-        send_at = datetime.datetime.now() + datetime.timedelta(seconds=config['wait_time'])
-        _scheduled_replies_cache[(channel.id, ts, config_name)] = {
-            'channel_id': channel.id,
-            'ts': ts,
-            'config_name': config_name,
-            'user_id': user.id,
-            'text': text,
-            'send_at': send_at.isoformat(),
-        }
-        await flush_replies_cache()
-
-async def handle_reaction_added(app: AsyncApp, event):
-    item = event.get('item', {})
-    channel_id = item.get('channel', '')
-    user_id = event.get('user', '')
-    ts = item.get('ts')
-    channel = await get_channel_by_id(app, channel_id)
-    reaction_user = await get_user_by_id(app, user_id)
-
-    keys_to_cancel = []
-    for key, scheduled_reply in scheduled_messages.items():
-        if key[0] != channel_id or key[1] != ts:
-            continue
-
-        config = channel.configs.get(key[2])
-        no_restrictions = config is not None and not config.get('included_teams') and not config.get('excluded_teams')
-        if no_restrictions or not user_matches_actor_criteria(config, reaction_user):
-            keys_to_cancel.append(key)
-
-    if not keys_to_cancel:
-        return
-
-    message_user_id = scheduled_messages[keys_to_cancel[0]].user_id
-    message_user = await get_user_by_id(app, message_user_id)
-    log(f"Reaction added by user @{reaction_user.name}. Cancelling {len(keys_to_cancel)} reminder(s) for message {ts} in channel #{channel.name}, user @{message_user.name}")
-
-    for key in keys_to_cancel:
-        scheduled_messages[key].task.cancel()
-        del scheduled_messages[key]
-
-async def handle_message_deletion(app: AsyncApp, channel: Channel, previous_message_user: User, previous_message_ts: str):
-    if previous_message_user.id == bot_user_id:
-        log(f"Ignoring message deletion by bot from channel #{channel.name}.")
-        return
-
-    keys_to_cancel = []
-    for key in scheduled_messages.keys():
-        if key[0] == channel.id and key[1] == previous_message_ts:
-            keys_to_cancel.append(key)
-
-    if not keys_to_cancel:
-        return
-
-    log(f"Message deleted. Cancelling {len(keys_to_cancel)} reply/replies for message {previous_message_ts} in channel #{channel.name}, user @{previous_message_user.name}")
-    for key in keys_to_cancel:
-        scheduled_messages[key].task.cancel()
-        del scheduled_messages[key]
-
-async def handle_command_event(app: AsyncApp, command: dict, opsgenie_token: str = ""):
-    text = command.get('text', '')
-    channel_id = command.get('channel_id', '')
-    user_id = command.get('user_id', '')
-
-    channel = await get_channel_by_id(app, channel_id)
-    user = await get_user_by_id(app, user_id)
-    await process_command(app, text, channel, user, opsgenie_token=opsgenie_token)
-
-def register_app_handlers(app: AsyncApp, opsgenie_token: str = "") -> None:
-
-    @app.event("message")
-    async def handle_message_events(body, logger):
-        await route_message(app, opsgenie_token, body.get('event', {}) if body else {})
-
-    @app.event("reaction_added")
-    async def handle_reaction_added_events(body, logger):
-        await handle_reaction_added(app, body.get('event', {}) if body else {})
-
-    @app.command("/hutbot")
-    async def handle_command(ack, body, logger):
-        await ack()
-        await handle_command_event(app, body, opsgenie_token)
-
-async def restore_scheduled_replies(app: AsyncApp, opsgenie_token: str) -> None:
-    entries = list(_scheduled_replies_cache.items())
-    invalid_keys = []
-    restored = 0
-    log(f"Restoring {len(entries)} scheduled replies from cache...")
-    for key, entry in entries:
-        channel_id = entry['channel_id']
-        ts = entry['ts']
-        config_name = entry['config_name']
-        if channel_id not in channel_config or config_name not in channel_config[channel_id]:
-            log_warning(f"Skipping cached reply for message {ts}: channel {channel_id} / config '{config_name}' no longer configured.")
-            invalid_keys.append(key)
-            continue
-        config = channel_config[channel_id][config_name]
-        channel = await get_channel_by_id(app, channel_id)
-        user = await get_user_by_id(app, entry['user_id'])
-        send_at = datetime.datetime.fromisoformat(entry['send_at'])
-        remaining = max(0.0, (send_at - datetime.datetime.now()).total_seconds())
-        log(f"Restoring reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, remaining {remaining:.0f}s.")
-        task = asyncio.create_task(schedule_reply(app, opsgenie_token, channel, config, config_name, user, entry['text'], ts, wait_time_override=remaining))
-        scheduled_messages[(channel.id, ts, config_name)] = ScheduledReply(task, user.id)
-        restored += 1
-    for key in invalid_keys:
-        _scheduled_replies_cache.pop(key, None)
-    if invalid_keys:
-        await flush_replies_cache()
-    log(f"Restored {restored} scheduled replies.")
-
-async def send_heartbeat(opsgenie_token: str, opsgenie_heartbeat_name: str) -> None:
-    url = 'https://api.opsgenie.com/v2/heartbeats/' + opsgenie_heartbeat_name + '/ping'
-    headers = {
-        'Authorization': f'GenieKey {opsgenie_token}'
-    }
-    log(f"Starting to send heartbeat to {url}...")
-    async with aiohttp.ClientSession() as session:
-        while True:
-            try:
-                async with session.get(url, headers=headers) as response:
-                    if response.status != 202:
-                        log_error(f"Failed to send heartbeat: {response.status}")
-            except Exception as e:
-                log_error(f"Exception while sending heartbeat:", e)
-            await asyncio.sleep(60)
+import asyncio
 
-async def main() -> None:
-    load_env_file()
-    slack_app_token = get_env_var("SLACK_APP_TOKEN")
-    slack_bot_token = get_env_var("SLACK_BOT_TOKEN")
-    opsgenie_token = get_env_var("OPSGENIE_TOKEN")
-    opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
-    if slack_app_token is None or slack_bot_token is None:
-        log_error("Environment variables SLACK_APP_TOKEN and SLACK_BOT_TOKEN must be set to run this app")
-        exit(1)
+from hutbot.__main__ import main
 
-    handler = None
-    heartbeat_task = None
-    try:
-        app = AsyncApp(token=slack_bot_token)
-        await load_configuration(app)
-        global bot_user_id
-        bot_user_id = (await app.client.auth_test())["user_id"]
-        await update_user_cache(app)
-        await load_replies_cache()
-        await restore_scheduled_replies(app, opsgenie_token)
-        register_app_handlers(app, opsgenie_token=opsgenie_token)
-        handler = AsyncSocketModeHandler(app, slack_app_token)
-        if opsgenie_token and opsgenie_heartbeat_name:
-            global opsgenie_configured
-            opsgenie_configured = True
-            heartbeat_task = asyncio.create_task(send_heartbeat(opsgenie_token, opsgenie_heartbeat_name))
-        await handler.start_async()
-    except asyncio.CancelledError:
-        pass
-    except KeyboardInterrupt:
-        pass
-    except Exception as e:
-        log_error(e)
-        exit(1)
-    finally:
-        try:
-            if handler:
-                await handler.close_async()
-            if heartbeat_task:
-                heartbeat_task.cancel()
-                try:
-                    await heartbeat_task
-                except asyncio.CancelledError:
-                    pass
-        except BaseException as e:
-            pass
 
 if __name__ == "__main__":
     asyncio.run(main())
diff --git a/charts/hutbot/Chart.yaml b/charts/hutbot/Chart.yaml
index f64aaed..843d35d 100644
--- a/charts/hutbot/Chart.yaml
+++ b/charts/hutbot/Chart.yaml
@@ -2,5 +2,5 @@ apiVersion: v2
 name: hutbot
 description: A Helm chart for deploying the Hutbot Slack bot
 type: application
-version: 0.1.2
-appVersion: "latest"
\ No newline at end of file
+version: 0.3.0
+appVersion: "v1.0.9"
\ No newline at end of file
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 60bc75c..5bddaed 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -1,3 +1,7 @@
+{{- $imageTag := required "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' and 'main' are not allowed" .Values.image.tag -}}
+{{- if has (lower (toString $imageTag)) (list "latest" "main") -}}
+{{- fail "image.tag must be set to a specific image tag (e.g. v1.0.9); floating tags like 'latest' and 'main' are not allowed" -}}
+{{- end }}
 apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -20,21 +24,75 @@ spec:
       {{- end }}
       containers:
         - name: {{ .Release.Name }}
-          image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+          image: "{{ .Values.image.repository }}:{{ $imageTag }}"
           imagePullPolicy: {{ .Values.image.pullPolicy }}
           envFrom:
             - secretRef:
                 name: {{ .Release.Name }}-secret
-          {{- if .Values.persistence.enabled }}
+          {{- if .Values.ui.enabled }}
+          ports:
+            - name: http
+              containerPort: {{ .Values.ui.port }}
+          {{- end }}
           env:
+            # What `help` / `news` report as the running version.
+            - name: HUTBOT_VERSION
+              value: {{ $imageTag | quote }}
+            {{- if .Values.time.timezone }}
+            - name: TZ
+              value: {{ .Values.time.timezone | quote }}
+            {{- end }}
+            {{- if .Values.time.locale }}
+            - name: HUTBOT_DEFAULT_DATETIME_LOCALE
+              value: {{ .Values.time.locale | quote }}
+            {{- end }}
+            {{- if .Values.slack.slashCommand }}
+            - name: HUTBOT_SLASH_COMMAND
+              value: {{ .Values.slack.slashCommand | quote }}
+            {{- end }}
+            {{- if .Values.slack.botName }}
+            - name: HUTBOT_BOT_NAME
+              value: {{ .Values.slack.botName | quote }}
+            {{- end }}
+            {{- if .Values.persistence.enabled }}
             - name: HUTBOT_CONFIG_FILE
               value: {{ printf "%s/%s" .Values.persistence.mountPath "bot.json" }}
             - name: HUTBOT_EMPLOYEE_CACHE_FILE
               value: {{ printf "%s/%s" .Values.persistence.mountPath "employees.json" }}
+            - name: HUTBOT_SCHEDULED_REPLIES_CACHE_FILE
+              value: {{ printf "%s/%s" .Values.persistence.mountPath "scheduled_replies.json" }}
+            - name: HUTBOT_BUTTON_CACHE_FILE
+              value: {{ printf "%s/%s" .Values.persistence.mountPath "button_states.json" }}
+            {{- end }}
+            {{- if .Values.ui.enabled }}
+            - name: HUTBOT_UI_ENABLED
+              value: "true"
+            - name: HUTBOT_UI_PORT
+              value: {{ .Values.ui.port | quote }}
+            - name: HUTBOT_UI_HOST
+              value: {{ .Values.ui.host | quote }}
+            - name: HUTBOT_UI_USER_HEADER
+              value: {{ .Values.ui.userHeader | quote }}
+            {{- end }}
+          {{- if .Values.persistence.enabled }}
           volumeMounts:
             - name: config
               mountPath: {{ .Values.persistence.mountPath }}
           {{- end }}
+          {{- if .Values.ui.enabled }}
+          readinessProbe:
+            httpGet:
+              path: /healthz
+              port: {{ .Values.ui.port }}
+            initialDelaySeconds: 5
+            periodSeconds: 10
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: {{ .Values.ui.port }}
+            initialDelaySeconds: 15
+            periodSeconds: 20
+          {{- end }}
           {{- if .Values.resources }}
           resources:
             {{ toYaml .Values.resources | indent 12 }}
@@ -44,4 +102,4 @@ spec:
         - name: config
           persistentVolumeClaim:
             claimName: {{ .Release.Name }}-pvc
-      {{- end }}
\ No newline at end of file
+      {{- end }}
diff --git a/charts/hutbot/templates/ingress.yaml b/charts/hutbot/templates/ingress.yaml
new file mode 100644
index 0000000..a0a0757
--- /dev/null
+++ b/charts/hutbot/templates/ingress.yaml
@@ -0,0 +1,31 @@
+{{- if and .Values.ui.enabled .Values.ui.ingress.enabled }}
+apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: {{ .Release.Name }}
+  labels:
+    app: {{ .Release.Name }}
+  {{- with .Values.ui.ingress.annotations }}
+  annotations:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+spec:
+  {{- if .Values.ui.ingress.className }}
+  ingressClassName: {{ .Values.ui.ingress.className }}
+  {{- end }}
+  {{- with .Values.ui.ingress.tls }}
+  tls:
+    {{- toYaml . | nindent 4 }}
+  {{- end }}
+  rules:
+    - host: {{ .Values.ui.ingress.host | quote }}
+      http:
+        paths:
+          - path: /
+            pathType: Prefix
+            backend:
+              service:
+                name: {{ .Release.Name }}
+                port:
+                  number: 80
+{{- end }}
diff --git a/charts/hutbot/templates/networkpolicy.yaml b/charts/hutbot/templates/networkpolicy.yaml
index d14467b..e3ad542 100644
--- a/charts/hutbot/templates/networkpolicy.yaml
+++ b/charts/hutbot/templates/networkpolicy.yaml
@@ -13,6 +13,19 @@ spec:
       app: {{ .Release.Name }}
   policyTypes:
   - Egress
+  {{- if .Values.ui.enabled }}
+  - Ingress
+  {{- end }}
+  {{- if .Values.ui.enabled }}
+  ingress:
+  - ports:
+    - port: {{ .Values.ui.port }}
+      protocol: TCP
+    {{- with .Values.ui.allowedIngress }}
+    from:
+      {{- toYaml . | nindent 6 }}
+    {{- end }}
+  {{- end }}
   egress:
 {{- if $rules }}
 {{- range $rule := $rules }}
diff --git a/charts/hutbot/templates/service.yaml b/charts/hutbot/templates/service.yaml
new file mode 100644
index 0000000..782d1ba
--- /dev/null
+++ b/charts/hutbot/templates/service.yaml
@@ -0,0 +1,17 @@
+{{- if .Values.ui.enabled }}
+apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .Release.Name }}
+  labels:
+    app: {{ .Release.Name }}
+spec:
+  type: {{ .Values.ui.service.type }}
+  selector:
+    app: {{ .Release.Name }}
+  ports:
+    - name: http
+      port: 80
+      targetPort: {{ .Values.ui.port }}
+      protocol: TCP
+{{- end }}
diff --git a/charts/hutbot/values.yaml b/charts/hutbot/values.yaml
index 33750ef..9d20f85 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -4,12 +4,31 @@ replicaCount: 1
 
 image:
   repository: hutbot
-  tag: "latest"
-  pullPolicy: Always
+  # Must be set to a specific, immutable tag (e.g. v1.0.9). Rendering fails if empty.
+  # Floating tags (latest, main) are intentionally not used for deployments.
+  tag: ""
+  pullPolicy: IfNotPresent
 
 slack:
   appToken: ""
   botToken: ""
+  # Slash command this instance listens on. Must match the command configured in
+  # the Slack app backing these tokens. Empty = the bot's default (/hutbot).
+  slashCommand: ""
+  # Name the bot calls itself in user-facing text, e.g. "Hutbot (DEV)".
+  # Empty = the bot's default ("Hutbot").
+  botName: ""
+
+# Timezone and date/time locale the whole instance runs in.
+time:
+  # IANA zone name forced into the container as TZ, e.g. "Europe/Berlin". This is
+  # the server local timezone: configs that set no timezone of their own format
+  # date/times in it and have their work days/work hours counted in it. Empty =
+  # the image default, UTC.
+  timezone: ""
+  # Fallback date/time locale for configs that set none, e.g. "de_DE". Only `de`
+  # has translations; every other locale renders English day/month names.
+  locale: ""
 
 opsgenie:
   token: ""
@@ -22,6 +41,31 @@ employeeList:
 
 resources: {}
 
+# Web UI served by the bot over HTTP
+ui:
+  enabled: false
+  port: 8080
+  host: "0.0.0.0"
+  # Trusted reverse-proxy header carrying the authenticated user's email.
+  userHeader: "X-Forwarded-Email"
+  # NetworkPolicy ingress sources allowed to reach the UI port. Each entry is a
+  # NetworkPolicy peer (e.g. namespaceSelector / podSelector / ipBlock) and is
+  # rendered verbatim into the ingress rule's `from:`. STRONGLY recommended: the UI
+  # trusts a proxy-set email header, so any pod that can reach the port can spoof it.
+  # Empty list = allow all sources (back-compat, insecure). Example:
+  #   allowedIngress:
+  #     - namespaceSelector:
+  #         matchLabels: { kubernetes.io/metadata.name: ingress-nginx }
+  allowedIngress: []
+  service:
+    type: ClusterIP
+  ingress:
+    enabled: false
+    className: ""
+    host: ""
+    annotations: {}
+    tls: []   # list of {secretName, hosts: []}
+
 # Persistence configuration for storing the bot config file on a PersistentVolumeClaim
 persistence:
   enabled: true
diff --git a/deploy-dev.sh b/deploy-dev.sh
new file mode 100755
index 0000000..f49abac
--- /dev/null
+++ b/deploy-dev.sh
@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Deploy the hutbot dev instance (release "hutbot-dev") with an explicit image tag.
+# Loads .env-dev from the repository root and runs helmfile in the "dev" environment.
+set -euo pipefail
+
+readonly HELM_ENV="dev"
+readonly ENV_FILE=".env-dev"
+
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() {
+  cat <<EOF
+Usage: ${0##*/} <image-tag> [helmfile-args...]
+
+Deploys the "${HELM_ENV}" environment using ${ENV_FILE}.
+Extra arguments replace the default helmfile command ("sync").
+
+Examples:
+  ${0##*/} v1.1.0
+  ${0##*/} v1.1.0 diff
+EOF
+}
+
+case "${1:-}" in
+  -h|--help)
+    usage
+    exit 0
+    ;;
+  "")
+    echo "error: image tag is required" >&2
+    usage >&2
+    exit 1
+    ;;
+esac
+
+image_tag="$1"
+shift
+
+if [[ "${image_tag,,}" == "latest" || "${image_tag,,}" == "main" ]]; then
+  echo "error: image tags must be pinned to a release, '${image_tag}' is not allowed" >&2
+  exit 1
+fi
+
+helmfile_args=("$@")
+if [[ ${#helmfile_args[@]} -eq 0 ]]; then
+  helmfile_args=(sync)
+fi
+
+if ! command -v helmfile >/dev/null 2>&1; then
+  echo "error: helmfile not found in PATH" >&2
+  exit 1
+fi
+
+env_path="${root_dir}/${ENV_FILE}"
+if [[ ! -f "$env_path" ]]; then
+  echo "error: ${env_path} not found" >&2
+  exit 1
+fi
+
+set -a
+# shellcheck source=/dev/null
+source "$env_path"
+set +a
+
+export IMAGE_TAG="$image_tag"
+
+echo "==> environment: ${HELM_ENV}"
+echo "==> env file:    ${ENV_FILE}"
+echo "==> image tag:   ${IMAGE_TAG}"
+echo "==> namespace:   ${NAMESPACE:-mw-internal}"
+
+cd "$root_dir"
+exec helmfile -e "$HELM_ENV" "${helmfile_args[@]}"
diff --git a/deploy-prod.sh b/deploy-prod.sh
new file mode 100755
index 0000000..1549a9c
--- /dev/null
+++ b/deploy-prod.sh
@@ -0,0 +1,92 @@
+#!/usr/bin/env bash
+# Deploy the hutbot production instance (release "hutbot") with an explicit image tag.
+# Loads .env from the repository root and runs helmfile in the "default" environment.
+set -euo pipefail
+
+readonly HELM_ENV="default"
+readonly ENV_FILE=".env"
+
+root_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+usage() {
+  cat <<EOF
+Usage: ${0##*/} [-y] <image-tag> [helmfile-args...]
+
+Deploys the "${HELM_ENV}" (production) environment using ${ENV_FILE}.
+Extra arguments replace the default helmfile command ("sync").
+
+Options:
+  -y, --yes   Skip the confirmation prompt.
+
+Examples:
+  ${0##*/} v1.1.0
+  ${0##*/} v1.1.0 diff
+  ${0##*/} -y v1.1.0
+EOF
+}
+
+assume_yes=0
+if [[ "${1:-}" == "-y" || "${1:-}" == "--yes" ]]; then
+  assume_yes=1
+  shift
+fi
+
+case "${1:-}" in
+  -h|--help)
+    usage
+    exit 0
+    ;;
+  "")
+    echo "error: image tag is required" >&2
+    usage >&2
+    exit 1
+    ;;
+esac
+
+image_tag="$1"
+shift
+
+if [[ "${image_tag,,}" == "latest" || "${image_tag,,}" == "main" ]]; then
+  echo "error: image tags must be pinned to a release, '${image_tag}' is not allowed" >&2
+  exit 1
+fi
+
+helmfile_args=("$@")
+if [[ ${#helmfile_args[@]} -eq 0 ]]; then
+  helmfile_args=(sync)
+fi
+
+if ! command -v helmfile >/dev/null 2>&1; then
+  echo "error: helmfile not found in PATH" >&2
+  exit 1
+fi
+
+env_path="${root_dir}/${ENV_FILE}"
+if [[ ! -f "$env_path" ]]; then
+  echo "error: ${env_path} not found" >&2
+  exit 1
+fi
+
+set -a
+# shellcheck source=/dev/null
+source "$env_path"
+set +a
+
+export IMAGE_TAG="$image_tag"
+
+echo "==> environment: ${HELM_ENV} (production)"
+echo "==> env file:    ${ENV_FILE}"
+echo "==> image tag:   ${IMAGE_TAG}"
+echo "==> namespace:   ${NAMESPACE:-mw-internal}"
+echo "==> command:     helmfile -e ${HELM_ENV} ${helmfile_args[*]}"
+
+if [[ "$assume_yes" -ne 1 && "${helmfile_args[0]}" != "diff" ]]; then
+  read -r -p "Deploy to PRODUCTION? [y/N] " answer
+  if [[ "$answer" != "y" && "$answer" != "Y" ]]; then
+    echo "aborted"
+    exit 1
+  fi
+fi
+
+cd "$root_dir"
+exec helmfile -e "$HELM_ENV" "${helmfile_args[@]}"
diff --git a/helmfile.yaml.gotmpl b/helmfile.yaml.gotmpl
index fdf0a44..d0c2067 100644
--- a/helmfile.yaml.gotmpl
+++ b/helmfile.yaml.gotmpl
@@ -1,17 +1,49 @@
+# Image tags are pinned to specific releases on purpose: no floating `latest`.
+# Bump `imageTag` here (or override with IMAGE_TAG) to roll out a new version.
+environments:
+  default:
+    values:
+      - releaseName: hutbot
+        namespace: mw-internal
+        imageTag: v1.0.9
+        slashCommand: /hutbot
+        botName: Hutbot
+        # Timezone and date/time locale of the instance; set them in the env file
+        # (HUTBOT_TIMEZONE / HUTBOT_DEFAULT_DATETIME_LOCALE). Empty means the
+        # image default: UTC and English day/month names.
+        timezone: ""
+        datetimeLocale: ""
+  dev:
+    values:
+      - releaseName: hutbot-dev
+        namespace: mw-internal
+        imageTag: v1.0.9
+        # The dev instance runs behind its own Slack app, which registers its own
+        # slash command. Must match the command configured there.
+        slashCommand: /hutbot_dev
+        botName: Hutbot (DEV)
+        timezone: ""
+        datetimeLocale: ""
+---
 repositories: []
 
 releases:
-  - name: hutbot
-    namespace: mw-internal
+  - name: {{ .Values.releaseName }}
+    namespace: {{ env "NAMESPACE" | default .Values.namespace }}
     chart: ./charts/hutbot
     values:
       - image:
-          repository: ghcr.io/mittwald/hutbot
-          tag: "latest"
+          repository: {{ env "IMAGE_REPOSITORY" | default "ghcr.io/mittwald/hutbot" | quote }}
+          tag: {{ env "IMAGE_TAG" | default .Values.imageTag | quote }}
         replicaCount: 1
       - slack:
           appToken: {{ requiredEnv "SLACK_APP_TOKEN" | quote }}
           botToken: {{ requiredEnv "SLACK_BOT_TOKEN" | quote }}
+          slashCommand: {{ env "HUTBOT_SLASH_COMMAND" | default .Values.slashCommand | quote }}
+          botName: {{ env "HUTBOT_BOT_NAME" | default .Values.botName | quote }}
+      - time:
+          timezone: {{ env "HUTBOT_TIMEZONE" | default .Values.timezone | quote }}
+          locale: {{ env "HUTBOT_DEFAULT_DATETIME_LOCALE" | default .Values.datetimeLocale | quote }}
       - opsgenie:
           token: {{ env "OPSGENIE_TOKEN" | quote }}
           heartbeatName: {{ env "OPSGENIE_HEARTBEAT_NAME" | quote }}
diff --git a/hutbot/__init__.py b/hutbot/__init__.py
new file mode 100644
index 0000000..458f9bd
--- /dev/null
+++ b/hutbot/__init__.py
@@ -0,0 +1,10 @@
+"""Hutbot — a Slack reminder/rule bot.
+
+This package is the result of splitting the former monolithic ``bot.py`` into
+cohesive modules. See ``hutbot/__main__.py`` for the entry point
+(``python -m hutbot``).
+"""
+
+# Fallback version, used when HUTBOT_VERSION is unset (running from a checkout).
+# Deployments get the real one from the chart, which passes the image tag.
+__version__ = "1.0.0"
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
new file mode 100644
index 0000000..87055b2
--- /dev/null
+++ b/hutbot/__main__.py
@@ -0,0 +1,92 @@
+"""Entry point: ``python -m hutbot``."""
+
+import asyncio
+
+from slack_bolt.async_app import AsyncApp
+from slack_bolt.adapter.socket_mode.aiohttp import AsyncSocketModeHandler
+
+from employee_list import get_env_var, load_env_file, log_error
+
+from . import __version__
+from . import state
+from . import datetimefmt
+from .constants import DEFAULT_BOT_NAME, normalize_slash_command, normalize_version
+from . import persistence
+from . import slackcache
+from . import scheduling
+from . import buttons
+from . import routing
+from . import opsgenie
+from . import webui_backend
+
+
+async def main() -> None:
+    load_env_file()
+    slack_app_token = get_env_var("SLACK_APP_TOKEN")
+    slack_bot_token = get_env_var("SLACK_BOT_TOKEN")
+    opsgenie_token = get_env_var("OPSGENIE_TOKEN")
+    opsgenie_heartbeat_name = get_env_var("OPSGENIE_HEARTBEAT_NAME")
+    state.slash_command = normalize_slash_command(get_env_var("HUTBOT_SLASH_COMMAND"))
+    state.bot_name = get_env_var("HUTBOT_BOT_NAME").strip() or DEFAULT_BOT_NAME
+    # The deployed image tag, so `help` / `news` name the version actually running.
+    state.version = normalize_version(get_env_var("HUTBOT_VERSION")) or normalize_version(__version__)
+    # Locale for configs that set none. The timezone counterpart is the container's
+    # TZ: a config without its own timezone uses server local time anyway.
+    state.default_datetime_locale = datetimefmt.resolve_default_locale(get_env_var("HUTBOT_DEFAULT_DATETIME_LOCALE"))
+    if slack_app_token is None or slack_bot_token is None:
+        log_error("Environment variables SLACK_APP_TOKEN and SLACK_BOT_TOKEN must be set to run this app")
+        exit(1)
+
+    handler = None
+    heartbeat_task = None
+    scheduler_task = None
+    web_runner = None
+    try:
+        app = AsyncApp(token=slack_bot_token)
+        await persistence.load_configuration(app)
+        auth = await app.client.auth_test()
+        state.bot_user_id = auth["user_id"]
+        # The Slack handle differs per app (Hutbot vs. Hutbot_DEV), so the help
+        # text's `@mention` examples have to come from the workspace, not a constant.
+        # The profile display name is the handle people type; auth.test only knows
+        # the flattened username ("hutbotdev").
+        state.bot_user_name = await slackcache.fetch_bot_handle(app, state.bot_user_id) or auth.get("user") or DEFAULT_BOT_NAME
+        await slackcache.update_user_cache(app)
+        await persistence.load_replies_cache()
+        await scheduling.restore_scheduled_replies(app, opsgenie_token)
+        await persistence.load_button_cache()
+        await buttons.restore_pending_buttons(app, opsgenie_token)
+        routing.register_app_handlers(app, opsgenie_token=opsgenie_token)
+        handler = AsyncSocketModeHandler(app, slack_app_token)
+        if opsgenie_token and opsgenie_heartbeat_name:
+            state.opsgenie_configured = True
+            heartbeat_task = asyncio.create_task(opsgenie.send_heartbeat(opsgenie_token, opsgenie_heartbeat_name))
+        scheduler_task = asyncio.create_task(scheduling.run_scheduler(app, opsgenie_token))
+        web_runner = await webui_backend.maybe_start_web_ui(app)
+        await handler.start_async()
+    except asyncio.CancelledError:
+        pass
+    except KeyboardInterrupt:
+        pass
+    except Exception as e:
+        log_error(e)
+        exit(1)
+    finally:
+        try:
+            if web_runner:
+                await web_runner.cleanup()
+            if handler:
+                await handler.close_async()
+            for background_task in (heartbeat_task, scheduler_task):
+                if background_task:
+                    background_task.cancel()
+                    try:
+                        await background_task
+                    except asyncio.CancelledError:
+                        pass
+        except BaseException as e:
+            pass
+
+
+if __name__ == "__main__":
+    asyncio.run(main())
diff --git a/hutbot/actions.py b/hutbot/actions.py
new file mode 100644
index 0000000..c1b7bc0
--- /dev/null
+++ b/hutbot/actions.py
@@ -0,0 +1,205 @@
+"""The action engine: render text, run an action, fire OpsGenie, evaluate conditions.
+
+``run_action`` and ``buttons`` reference each other (a config can carry buttons,
+and a button runs a config); both sides use module-qualified access so the
+import cycle is resolved lazily and monkeypatching stays visible.
+"""
+
+import outlook
+from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
+
+from employee_list import log, log_error, log_warning
+
+from . import state
+from . import slackcache
+from . import messaging
+from . import templating
+from . import opsgenie
+from . import targets
+from . import buttons
+from .constants import (
+    ACTION_DM_USER,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
+    ACTION_REPLY,
+    ACTIONS_REQUIRING_TARGET,
+    ACTION_TARGET_HINTS,
+    CONDITION_NONE,
+    CONDITION_OUTLOOK,
+    OPSGENIE_TEMPLATE_VARIABLES,
+    TEAM_UNKNOWN,
+)
+from .models import Channel, User
+
+
+async def _render_template(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None, template: str) -> str:
+    template = template or ''
+    context = context or {}
+    user = context.get('user')
+    if user is None:
+        user = User(id=state.bot_user_id or '', name=state.bot_user_name, real_name=state.bot_name, team=TEAM_UNKNOWN)
+    text = context.get('text', '')
+    ts = context.get('ts', '')
+    permalink = context.get('permalink')
+    if permalink is None:
+        permalink = await slackcache.get_message_permalink(app, channel, ts) if ts else ""
+    template_variables = templating.find_template_variables(template)
+    variables = await templating.build_reply_template_variables(
+        app, opsgenie_token, channel, config, config_name, user, text, ts, permalink,
+        include_opsgenie=bool(OPSGENIE_TEMPLATE_VARIABLES.intersection(template_variables)),
+    )
+    return templating.render_reply_message_template(template, variables, config)
+
+
+async def render_template_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None, template: str) -> str:
+    """Render any template with a config's variables — a button's message, say."""
+    return await _render_template(app, opsgenie_token, channel, config, config_name, context, template)
+
+
+async def render_action_text(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None) -> str:
+    return await _render_template(app, opsgenie_token, channel, config, config_name, context, config.get('reply_message') or '')
+
+
+async def maybe_post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None, posted_ts: str = '') -> None:
+    """Fire an OpsGenie alert when a config that just ran has OpsGenie enabled.
+
+    The alert text defaults to the (original) message in context; a non-empty
+    `opsgenie_message` template overrides it. This makes OpsGenie a property of
+    any config — buttons/timeouts that run an OpsGenie-enabled config alert, with
+    no OpsGenie-specific escalation machinery.
+    """
+    if not (state.opsgenie_configured and config.get('opsgenie')):
+        return
+    context = context or {}
+    user = context.get('user') or User(id='', name=state.bot_user_name, real_name=state.bot_name, team=TEAM_UNKNOWN)
+    template = config.get('opsgenie_message') or ''
+    alert_text = await _render_template(app, opsgenie_token, channel, config, config_name, context, template) if template else context.get('text', '')
+    log(f"Sending OpsGenie alert for config '{config_name}' in #{channel.name}.")
+    # Scheduled/manual runs have no original-message ts, which would give every
+    # recurrence the same OpsGenie alias and collapse them via dedup. Fall back to
+    # the just-posted message ts so each run is a distinct alert. Used for the alias
+    # only — not threaded into context/template variables.
+    alert_ts = context.get('ts', '') or posted_ts
+    await opsgenie.post_opsgenie_alert(app, opsgenie_token, channel, config, user, alert_text, alert_ts, context.get('permalink', ''))
+
+
+async def action_reply(app: AsyncApp, channel: Channel, config: dict, context: dict | None, text: str, blocks: list | None) -> dict | None:
+    context = context or {}
+    candidate = context.get('thread_ts', '') or context.get('message_ts', '')
+    # Only thread when the timestamp belongs to the channel we post to. A button
+    # on a message sent to another conversation (DM/mpim/other channel) carries a
+    # message_ts that is invalid as a thread_ts here, and Slack would reject it.
+    ctx_channel = context.get('channel_id')
+    thread_ts = candidate if candidate and (ctx_channel is None or ctx_channel == channel.id) else ""
+    return await messaging._post_message(app, channel.id, text, blocks, thread_ts)
+
+
+async def action_dm_user(app: AsyncApp, channel: Channel, config: dict, text: str, blocks: list | None) -> dict | None:
+    target = (config.get('action_target') or '').strip()
+    user = await targets.resolve_user_target(app, target)
+    if not user or not user.id:
+        log_error(f"Action dm_user: cannot resolve user target '{target}'.")
+        return None
+    try:
+        opened = await app.client.conversations_open(users=[user.id])
+        dm_id = opened['channel']['id']
+    except SlackApiError as e:
+        log_error(f"Action dm_user: failed to open DM with {target}:", e)
+        return None
+    return await messaging._post_message(app, dm_id, text, blocks)
+
+
+async def action_group_dm(app: AsyncApp, channel: Channel, config: dict, text: str, blocks: list | None) -> dict | None:
+    target = (config.get('action_target') or '').strip()
+    usergroup = await targets.resolve_usergroup_target(app, target)
+    if not usergroup or not usergroup.id:
+        log_error(f"Action group_dm: cannot resolve usergroup '{target}'.")
+        return None
+    members = await slackcache.get_usergroup_members(app, usergroup.id)
+    if not members:
+        log_error(f"Action group_dm: usergroup '{target}' has no members.")
+        return None
+    # Slack multi-person DMs allow at most 8 members besides the bot.
+    if len(members) > 8:
+        log_warning(f"Action group_dm: usergroup '{target}' has {len(members)} members; using first 8 (Slack mpim limit).")
+        members = members[:8]
+    try:
+        opened = await app.client.conversations_open(users=members)
+        mpim_id = opened['channel']['id']
+    except SlackApiError as e:
+        log_error(f"Action group_dm: failed to open group DM for '{target}':", e)
+        return None
+    return await messaging._post_message(app, mpim_id, text, blocks)
+
+
+async def action_post_channel(app: AsyncApp, channel: Channel, config: dict, text: str, blocks: list | None) -> dict | None:
+    target = (config.get('action_target') or '').strip()
+    channel_id = targets.parse_channel_ref(target)
+    if not channel_id:
+        log_error(f"Action post_channel: invalid channel target '{target}'.")
+        return None
+    return await messaging._post_message(app, channel_id, text, blocks)
+
+
+def missing_target_reason(config: dict) -> str:
+    """Why this config's action cannot run, or "" when it can.
+
+    Every action except `reply` sends somewhere else and needs a target; a config
+    that has none would only fail deep inside the action with an empty target.
+    """
+    action = config.get('action', ACTION_REPLY)
+    if action not in ACTIONS_REQUIRING_TARGET:
+        return ""
+    target = (config.get('action_target') or '').strip()
+    if not target:
+        return f"action `{action}` has no target"
+    if action == ACTION_POST_CHANNEL and not targets.parse_channel_ref(target):
+        return f"action `{action}` target `{target}` is not a channel"
+    return ""
+
+
+async def run_action(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, context: dict | None = None, _depth: int = 0) -> dict | None:
+    if _depth > 5:
+        log_warning(f"Action chain too deep at config '{config_name}'; aborting to avoid loops.")
+        return None
+    action = config.get('action', ACTION_REPLY)
+    reason = missing_target_reason(config)
+    if reason:
+        log_error(f"Config '{config_name}' in #{channel.name} cannot run: {reason}; set one with `set action {action.replace('_', '-')} {ACTION_TARGET_HINTS[action]}`.")
+        return None
+    text = await render_action_text(app, opsgenie_token, channel, config, config_name, context)
+    blocks = buttons.build_button_blocks(config, channel.id, config_name, text)
+    log(f"Running action '{action}' for config '{config_name}' in #{channel.name}.")
+    if action == ACTION_REPLY:
+        posted = await action_reply(app, channel, config, context, text, blocks)
+    elif action == ACTION_DM_USER:
+        posted = await action_dm_user(app, channel, config, text, blocks)
+    elif action == ACTION_GROUP_DM:
+        posted = await action_group_dm(app, channel, config, text, blocks)
+    elif action == ACTION_POST_CHANNEL:
+        posted = await action_post_channel(app, channel, config, text, blocks)
+    else:
+        log_error(f"Unknown action '{action}' for config '{config_name}'.")
+        return None
+    if posted and posted.get('ts') and config.get('buttons'):
+        await buttons.register_escalation(app, opsgenie_token, posted['channel'], posted['ts'], channel.id, config_name, config, context, posted_text=text)
+    # OpsGenie is just a config property: any config that runs and has it enabled alerts.
+    await maybe_post_opsgenie_alert(app, opsgenie_token, channel, config, config_name, context, (posted or {}).get('ts', ''))
+    if not posted:
+        return None
+    return {**posted, 'text': text}
+
+
+async def evaluate_condition(app: AsyncApp, config: dict) -> bool:
+    condition = config.get('condition', CONDITION_NONE)
+    if not condition:
+        return True
+    if condition == CONDITION_OUTLOOK:
+        return await outlook.calendar_condition_met(
+            config.get('outlook_subject_pattern', ''),
+            config.get('outlook_body_pattern', ''),
+            bool(config.get('condition_negate', False)),
+        )
+    log_warning(f"Unknown condition '{condition}'; treating as met.")
+    return True
diff --git a/hutbot/buttons.py b/hutbot/buttons.py
new file mode 100644
index 0000000..bfdab4d
--- /dev/null
+++ b/hutbot/buttons.py
@@ -0,0 +1,418 @@
+"""Interactive buttons + timeout escalation (mirrors scheduled-reply persistence)."""
+
+import json
+import asyncio
+import datetime
+
+from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
+
+from employee_list import log, log_error, log_warning
+
+from . import state
+from . import slackcache
+from . import messaging
+from . import persistence
+from . import actions
+from .buttonutil import normalize_button, _find_button_index
+from .constants import (
+    BUTTON_ACTION_ACK,
+    BUTTON_ACTION_CONFIG,
+    BUTTON_ACTION_DELAY,
+    BUTTON_ACTION_PREFIX,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
+)
+from .models import User
+
+
+SLACK_SECTION_TEXT_LIMIT = 3000
+SLACK_ACTIONS_ELEMENT_LIMIT = 25
+
+
+def _section_blocks(text: str) -> list[dict]:
+    """Split message text into Slack-valid section blocks."""
+    text = text or ' '
+    return [
+        {"type": "section", "text": {"type": "mrkdwn", "text": text[offset:offset + SLACK_SECTION_TEXT_LIMIT]}}
+        for offset in range(0, len(text), SLACK_SECTION_TEXT_LIMIT)
+    ]
+
+
+def build_button_blocks(config: dict, def_channel_id: str, config_name: str, text: str) -> list | None:
+    buttons = config.get('buttons') or []
+    if not buttons:
+        return None
+    elements = []
+    for i, button in enumerate(buttons):
+        label = (button.get('label') or f'Button {i + 1}')[:75]
+        # The button definition is resolved server-side from the originating config
+        # by index, so the payload only needs to locate it (avoids Slack's 2000-char
+        # value cap for long inline-message buttons).
+        value = json.dumps({"channel": def_channel_id, "config": config_name, "index": i})
+        elements.append({
+            "type": "button",
+            "text": {"type": "plain_text", "text": label, "emoji": True},
+            "action_id": f"{BUTTON_ACTION_PREFIX}:{i}",
+            "value": value[:2000],
+        })
+    action_blocks = []
+    for offset in range(0, len(elements), SLACK_ACTIONS_ELEMENT_LIMIT):
+        chunk_number = offset // SLACK_ACTIONS_ELEMENT_LIMIT
+        suffix = f":{chunk_number}"
+        block_id = f"{BUTTON_ACTION_PREFIX}:{config_name}"[:255 - len(suffix)] + suffix
+        action_blocks.append({
+            "type": "actions",
+            "block_id": block_id,
+            "elements": elements[offset:offset + SLACK_ACTIONS_ELEMENT_LIMIT],
+        })
+    return _section_blocks(text) + action_blocks
+
+
+def _escalation_kind(config: dict) -> tuple[str, str]:
+    """What a buttoned message escalates to if no button is pressed in time.
+
+    Stored as set: `set escalation` writes the kind and target together and
+    rejects a target it cannot resolve, so there is nothing to decide here.
+    """
+    kind = config.get('escalation_kind') or ESCALATION_NONE
+    target = config.get('escalation_target') or ''
+    if kind in (ESCALATION_BUTTON, ESCALATION_CONFIG) and target:
+        return kind, target
+    return ESCALATION_NONE, ''
+
+
+async def register_escalation(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, def_channel_id: str, config_name: str, config: dict, context: dict | None = None, posted_text: str = '') -> None:
+    """Record a buttoned message so ack/delay/timeout can act on it later.
+
+    A record is stored for every buttoned message (it carries the original message
+    context that buttons/timeout pass on to the config they run); an escalation
+    timer is started only when a timeout is set and there is something to escalate to.
+    """
+    if not message_ts or not posted_channel_id:
+        return
+    context = context or {}
+    user = context.get('user')
+    timeout = config.get('escalation_timeout') or 0
+    kind, target = _escalation_kind(config)
+    key = (posted_channel_id, message_ts)
+    has_timer = timeout > 0 and kind != ESCALATION_NONE
+    entry = {
+        'posted_channel_id': posted_channel_id,
+        'message_ts': message_ts,
+        'def_channel_id': def_channel_id,
+        'config_name': config_name,
+        # Snapshot the button defs + rendered text with the posted message, so a press
+        # is resolved against what was posted (not a since-edited config) and the
+        # message can be de-buttoned once handled.
+        'buttons': [dict(b) for b in (config.get('buttons') or [])],
+        'posted_text': posted_text,
+        'escalation_kind': kind,
+        'escalation_target': target,
+        'timeout': timeout,
+        'run_at': (datetime.datetime.now() + datetime.timedelta(seconds=timeout)).isoformat() if has_timer else '',
+        'orig': {
+            'user_id': user.id if user else context.get('user_id', ''),
+            'text': context.get('text', ''),
+            'ts': context.get('ts', ''),
+            'permalink': context.get('permalink', ''),
+        },
+    }
+    task = asyncio.create_task(_escalation_task(app, opsgenie_token, key, timeout)) if has_timer else None
+    state.pending_buttons[key] = {'task': task, **entry}
+    state._button_states_cache[key] = entry
+    await persistence.flush_button_cache()
+
+
+async def _escalation_context(app: AsyncApp, entry: dict | None, posted_channel_id: str, message_ts: str, presser: User | None = None) -> dict:
+    """Build a run_action context from the stored original-message context.
+
+    A config run by a button/timeout sees the *original* message (text/ts/permalink/
+    sender), so its templates and any OpsGenie alert reference it; the target's reply
+    threads under the buttoned message.
+    """
+    orig = (entry or {}).get('orig', {})
+    user = presser
+    if user is None and orig.get('user_id'):
+        user = await slackcache.get_user_by_id(app, orig['user_id'])
+    return {
+        'channel_id': posted_channel_id,
+        'thread_ts': message_ts,
+        'user': user,
+        'text': orig.get('text', ''),
+        'ts': orig.get('ts', ''),
+        'permalink': orig.get('permalink', ''),
+    }
+
+
+async def dispatch_button_action(app: AsyncApp, opsgenie_token: str, channel, posted_channel_id: str, message_ts: str, button: dict, run_context: dict, src_config: dict | None = None, src_config_name: str = '') -> None:
+    """Run a button's action. Shared by a real press and an auto-press on timeout.
+
+    `delay` is handled by the caller (it is only meaningful for a live press).
+    """
+    action, value = normalize_button(button)
+    if action == BUTTON_ACTION_CONFIG:
+        target_config = channel.configs.get(value)
+        if not target_config:
+            log_warning(f"Button target config '{value}' not found in #{channel.name}.")
+            return
+        await actions.run_action(app, opsgenie_token, channel, target_config, value, context=run_context)
+    elif action == BUTTON_ACTION_ACK:
+        # Dismissing posts the ack text when there is one. The text is a template
+        # like a config's reply message, rendered against the original message with
+        # the defining config's date/time settings.
+        if value:
+            text = await actions.render_template_text(app, opsgenie_token, channel, src_config or {}, src_config_name, run_context, value)
+            await messaging._post_message(app, posted_channel_id, text, None, message_ts)
+    else:
+        log_warning(f"Unsupported button action '{action}' in #{channel.name}.")
+
+
+async def _run_escalation(app: AsyncApp, opsgenie_token: str, entry: dict) -> None:
+    kind = entry.get('escalation_kind', ESCALATION_NONE)
+    channel = await slackcache.get_channel_by_id(app, entry['def_channel_id'])
+    posted_channel_id, message_ts = entry['posted_channel_id'], entry['message_ts']
+    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts)
+    if kind == ESCALATION_BUTTON:
+        # Auto-press the configured default button, resolved against the snapshot
+        # taken when the message was posted (falling back to the live config).
+        snapshot = entry.get('buttons')
+        src_config = channel.configs.get(entry.get('config_name'))
+        lookup = {'buttons': snapshot} if snapshot is not None else src_config
+        idx = _find_button_index(lookup, entry.get('escalation_target', ''))
+        if idx is None:
+            log_warning(f"Default button '{entry.get('escalation_target')}' not found in #{channel.name}.")
+            return
+        buttons = snapshot if snapshot is not None else (src_config or {}).get('buttons') or []
+        log(f"No button pressed on message {message_ts}: auto-pressing '{entry.get('escalation_target')}' in #{channel.name}.")
+        await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[idx], run_context, src_config, entry.get('config_name', ''))
+        await _strip_buttons(app, posted_channel_id, message_ts, entry, _timeout_note(entry.get('timeout', 0), _ran_config(buttons[idx])))
+    elif kind == ESCALATION_CONFIG:
+        target = entry.get('escalation_target', '')
+        target_config = channel.configs.get(target)
+        if target_config:
+            log(f"Escalating message {message_ts}: running '{target}' in #{channel.name}.")
+            await actions.run_action(app, opsgenie_token, channel, target_config, target, context=run_context)
+            await _strip_buttons(app, posted_channel_id, message_ts, entry, _timeout_note(entry.get('timeout', 0), target))
+        else:
+            log_warning(f"Escalation target '{target}' not found in #{channel.name}.")
+
+
+async def _escalation_task(app: AsyncApp, opsgenie_token: str, key: tuple, timeout: float) -> None:
+    try:
+        await asyncio.sleep(timeout)
+        entry = _claim_pending_button(key, owner=asyncio.current_task())
+        if entry:
+            await persistence.flush_button_cache()
+            log(f"No button pressed on message {key[1]} within timeout; escalating.")
+            await _run_escalation(app, opsgenie_token, entry)
+    except asyncio.CancelledError:
+        # Cancellation alone means shutdown or timer replacement. The caller that
+        # explicitly consumed/replaced this record owns cache updates; shutdown must
+        # leave the persisted entry available for restoration in the next process.
+        return
+    except Exception as e:
+        log_error(f"Escalation task failed for message {key[1]}:", e)
+
+
+def _claim_pending_button(key: tuple, owner: asyncio.Task | None = None) -> dict | None:
+    """Synchronously claim a pending record so only one consumer can dispatch it."""
+    entry = state.pending_buttons.get(key)
+    if entry is None:
+        return None
+    task = entry.get('task')
+    if owner is not None and task is not None and task is not owner and not task.done():
+        return None
+    state.pending_buttons.pop(key, None)
+    state._button_states_cache.pop(key, None)
+    if task is not None and task is not asyncio.current_task():
+        task.cancel()
+    return entry
+
+
+async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None:
+    key = (posted_channel_id, message_ts)
+    entry = _claim_pending_button(key)
+    if entry:
+        await persistence.flush_button_cache()
+
+
+async def cancel_channel_pending_buttons(channel_id: str) -> int:
+    """Drop every pending button record tied to a channel; returns how many were dropped.
+
+    Used when the bot is removed from a channel: a message posted there can no
+    longer be updated or replied to, and a record defined by one of that
+    channel's (now disabled) configs would escalate into a config the bot is no
+    longer running.
+    """
+    if not channel_id:
+        return 0
+
+    def belongs(entry: dict) -> bool:
+        return entry.get('posted_channel_id') == channel_id or entry.get('def_channel_id') == channel_id
+
+    keys = {key for key, entry in state.pending_buttons.items() if belongs(entry)}
+    keys |= {key for key, entry in state._button_states_cache.items() if belongs(entry)}
+    for key in keys:
+        # Cancels the escalation timer and drops the live record; the pop also
+        # covers a cached record that has no live counterpart.
+        _claim_pending_button(key)
+        state._button_states_cache.pop(key, None)
+    if keys:
+        await persistence.flush_button_cache()
+    return len(keys)
+
+
+async def reschedule_escalation(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, minutes: int, *, _entry: dict | None = None) -> bool:
+    key = (posted_channel_id, message_ts)
+    entry = _entry if _entry is not None else _claim_pending_button(key)
+    if not entry:
+        log_warning(f"No pending escalation to delay for message {message_ts}.")
+        return False
+    record = {k: v for k, v in entry.items() if k != 'task'}
+    if record.get('escalation_kind', ESCALATION_NONE) == ESCALATION_NONE:
+        # Nothing to postpone. Put the record back (unchanged, no timer) so the
+        # other buttons on the message keep working.
+        log_warning(f"Nothing to delay for message {message_ts}: this config has no escalation.")
+        state.pending_buttons[key] = {'task': None, **record}
+        state._button_states_cache[key] = record
+        await persistence.flush_button_cache()
+        return False
+    extra = minutes * 60
+    record['timeout'] = extra
+    record['run_at'] = (datetime.datetime.now() + datetime.timedelta(seconds=extra)).isoformat()
+    task = asyncio.create_task(_escalation_task(app, opsgenie_token, key, extra))
+    state.pending_buttons[key] = {'task': task, **record}
+    state._button_states_cache[key] = record
+    await persistence.flush_button_cache()
+    return True
+
+
+async def restore_pending_buttons(app: AsyncApp, opsgenie_token: str) -> None:
+    entries = list(state._button_states_cache.items())
+    invalid_keys = []
+    restored = 0
+    log(f"Restoring {len(entries)} pending button escalations from cache...")
+    for key, entry in entries:
+        def_channel_id = entry.get('def_channel_id')
+        if not def_channel_id or def_channel_id not in state.channel_config:
+            log_warning(f"Skipping cached button state for message {entry.get('message_ts')}: channel {def_channel_id} no longer configured.")
+            invalid_keys.append(key)
+            continue
+        run_at = entry.get('run_at')
+        if run_at:
+            remaining = max(0.0, (datetime.datetime.fromisoformat(run_at) - datetime.datetime.now()).total_seconds())
+            task = asyncio.create_task(_escalation_task(app, opsgenie_token, key, remaining))
+        else:
+            task = None
+        state.pending_buttons[key] = {'task': task, **entry}
+        restored += 1
+    for key in invalid_keys:
+        state._button_states_cache.pop(key, None)
+    if invalid_keys:
+        await persistence.flush_button_cache()
+    log(f"Restored {restored} pending button escalations.")
+
+
+def _ran_config(button: dict) -> str:
+    """The config a button runs, if it runs one."""
+    action, value = normalize_button(button)
+    return value if action == BUTTON_ACTION_CONFIG and value else ""
+
+
+def _ran_suffix(ran: str) -> str:
+    """The config a press or a timeout ran, if any."""
+    return f" ▶︎ {ran}" if ran else ""
+
+
+def _press_note(button: dict, presser: User | None) -> str:
+    """What the message says in place of its buttons after somebody pressed one."""
+    who = (presser.real_name or presser.name or '?') if presser else 'Someone'
+    return f"_{who}: [{button.get('label') or '?'}]{_ran_suffix(_ran_config(button))}_"
+
+
+def _timeout_note(timeout: float, ran: str = "") -> str:
+    """…and what it says when the escalation acted instead of a person."""
+    return f"_⌛︎ {int((timeout or 0) // 60)}m{_ran_suffix(ran)}_"
+
+
+async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None, note: str = "") -> None:
+    """Remove the interactive buttons from a handled message so a stale later click
+    can't fire an action against a since-edited config, leaving a note of what was
+    done in their place (already formatted by `_press_note`/`_timeout_note`).
+    Best-effort."""
+    posted_text = (entry or {}).get('posted_text')
+    if not posted_text or not posted_channel_id or not message_ts:
+        return
+    # A plain rule separates the note from the message it belongs to.
+    text = f"{posted_text}\n\n---\n{note}" if note else posted_text
+    try:
+        await app.client.chat_update(
+            channel=posted_channel_id,
+            ts=message_ts,
+            text=text,
+            blocks=_section_blocks(text),
+        )
+    except SlackApiError as e:
+        log_warning(f"Failed to remove buttons from message {message_ts} in {posted_channel_id}:", e)
+
+
+async def handle_button_press(app: AsyncApp, opsgenie_token: str, body: dict, action: dict) -> None:
+    container = body.get('container', {}) or {}
+    message = body.get('message', {}) or {}
+    posted_channel_id = (body.get('channel', {}) or {}).get('id') or container.get('channel_id', '')
+    message_ts = container.get('message_ts') or message.get('ts', '')
+
+    payload = {}
+    raw_value = action.get('value', '')
+    if raw_value:
+        try:
+            payload = json.loads(raw_value)
+        except json.JSONDecodeError:
+            payload = {}
+    def_channel_id = payload.get('channel') or posted_channel_id
+    src_config_name = payload.get('config') or ''
+    index = payload.get('index')
+
+    key = (posted_channel_id, message_ts)
+    entry = _claim_pending_button(key)
+    if entry is None:
+        log_warning(f"Ignoring button press for message {message_ts}: no pending button record.")
+        return
+    # Persist the claim before any dispatch-related await. A concurrent handler now
+    # sees no entry, and a restart cannot resurrect an already-consumed button.
+    await persistence.flush_button_cache()
+
+    presser_id = (body.get('user', {}) or {}).get('id', '')
+    presser = await slackcache.get_user_by_id(app, presser_id) if presser_id else None
+    presser_name = presser.name if presser else '?'
+
+    channel = await slackcache.get_channel_by_id(app, def_channel_id)
+    src_config = channel.configs.get(src_config_name)
+    # Resolve the pressed button from the snapshot taken when the message was posted
+    # (falling back to the live config for messages predating the snapshot), so an
+    # edit to the config after posting can't make an old click run the wrong action.
+    snapshot = (entry or {}).get('buttons')
+    buttons = snapshot if snapshot is not None else ((src_config or {}).get('buttons') or [])
+    if index is None or not isinstance(index, int) or index < 0 or index >= len(buttons):
+        log_warning(f"Button pressed by @{presser_name} could not be resolved (config '{src_config_name}', index {index}).")
+        return
+    btn_action, btn_value = normalize_button(buttons[index])
+    log(f"Button '{buttons[index].get('label')}' ({btn_action}) pressed by @{presser_name} in #{channel.name}.")
+
+    if btn_action == BUTTON_ACTION_DELAY:
+        try:
+            minutes = int(btn_value)
+        except ValueError:
+            minutes = 0
+        if minutes > 0:
+            await reschedule_escalation(app, opsgenie_token, posted_channel_id, message_ts, minutes, _entry=entry)
+        return
+
+    # Every other button has already claimed the pending record, then runs its action. A config
+    # run is attributed to the *original* author (presser=None ⇒ orig.user_id), matching
+    # the timeout-escalation path; the presser is only used for the log line above.
+    run_context = await _escalation_context(app, entry, posted_channel_id, message_ts)
+    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context, src_config, src_config_name)
+    await _strip_buttons(app, posted_channel_id, message_ts, entry, _press_note(buttons[index], presser))
diff --git a/hutbot/buttonutil.py b/hutbot/buttonutil.py
new file mode 100644
index 0000000..7998e1e
--- /dev/null
+++ b/hutbot/buttonutil.py
@@ -0,0 +1,23 @@
+"""Pure helpers over button/config dicts.
+
+Kept as a leaf (depends only on constants) so both ``persistence`` (config
+migration) and ``buttons`` can use them without an import cycle.
+"""
+
+from .constants import BUTTON_ACTION_CONFIG
+
+
+def normalize_button(button: dict) -> tuple[str, str]:
+    """Return (action, value) for a button, defaulting a missing action to `config`."""
+    return button.get('action') or BUTTON_ACTION_CONFIG, button.get('value', '') or ''
+
+
+def _find_button_index(config: dict | None, label: str) -> int | None:
+    """Index of the first button matching `label` (case-insensitive), or None."""
+    if not config or not label:
+        return None
+    target = label.strip().casefold()
+    for i, button in enumerate(config.get('buttons') or []):
+        if (button.get('label') or '').strip().casefold() == target:
+            return i
+    return None
diff --git a/hutbot/commands/__init__.py b/hutbot/commands/__init__.py
new file mode 100644
index 0000000..4dbc9e9
--- /dev/null
+++ b/hutbot/commands/__init__.py
@@ -0,0 +1,9 @@
+"""Slash-command parsing and handlers.
+
+``process_command`` / ``parse_and_execute_command`` are the public entry points
+used by ``hutbot.routing``.
+"""
+
+from .dispatch import parse_and_execute_command, process_command
+
+__all__ = ["parse_and_execute_command", "process_command"]
diff --git a/hutbot/commands/dispatch.py b/hutbot/commands/dispatch.py
new file mode 100644
index 0000000..8944a02
--- /dev/null
+++ b/hutbot/commands/dispatch.py
@@ -0,0 +1,193 @@
+"""Command dispatch: match a slash-command string and run the matching handler."""
+
+import re
+import traceback
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log_error
+
+from .. import state
+from .. import messaging
+from .. import opsgenie
+from ..constants import CONFIG_NAME_PATTERN, DEFAULT_CONFIG_NAME, RESERVED_CONFIG_NAMES
+from ..textutil import log_debug, strip_quotes
+
+from . import patterns
+from . import setters
+from . import info
+
+
+async def parse_and_execute_command(app: AsyncApp, command_text: str, channel, config_name: str, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> bool:
+    """Parses and executes a command, returns True if a command was matched."""
+    if (match := (patterns.TEST_WITH_MESSAGE_PATTERN if allow_test_message else patterns.TEST_PATTERN).match(command_text)):
+        test_message = match.group("message") if allow_test_message and match.groupdict().get("message") is not None else ""
+        await setters.test_reply_message(app, opsgenie_token, channel, config_name, user, test_message, command_ts, thread_ts)
+    elif (match := patterns.SET_WAIT_TIME_PATTERN.match(command_text)):
+        await setters.set_wait_time(app, channel, config_name, match.group("wait_time"), user, thread_ts)
+    elif (match := patterns.SET_REPLY_MESSAGE_PATTERN.match(command_text)):
+        message = strip_quotes(match.group("message"))
+        await setters.set_reply_message(app, channel, config_name, message, user, thread_ts)
+    elif (match := patterns.SET_OPSGENIE_SCHEDULE_PATTERN.match(command_text)):
+        schedule_name = strip_quotes(match.group("schedule"))
+        await setters.set_opsgenie_schedule_name(app, channel, config_name, schedule_name, user, thread_ts)
+    elif (match := patterns.SET_OPSGENIE_PRIORITY_PATTERN.match(command_text)):
+        priority = strip_quotes(match.group("priority"))
+        await setters.set_opsgenie_priority(app, channel, config_name, priority, user, thread_ts)
+    elif patterns.CLEAR_OPSGENIE_MESSAGE_PATTERN.match(command_text):
+        await setters.clear_opsgenie_message(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_OPSGENIE_MESSAGE_PATTERN.match(command_text)):
+        await setters.set_opsgenie_message(app, channel, config_name, strip_quotes(match.group("message")), user, thread_ts)
+    elif (match := patterns.SET_DATETIME_FORMAT_PATTERN.match(command_text)):
+        await setters.set_datetime_format(app, channel, config_name, match.group("values"), user, thread_ts)
+    elif patterns.CLEAR_PATTERN_PATTERN.match(command_text):
+        await setters.clear_pattern(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_PATTERN_PATTERN.match(command_text)):
+        pattern = match.group("pattern")
+        case_sensitive = match.group("case_sensitive")
+        await setters.set_pattern(app, channel, config_name, pattern, case_sensitive, user, thread_ts)
+    elif (match := patterns.ENABLE_OPSGENIE_PATTERN.match(command_text)):
+        await setters.set_opsgenie(app, channel, config_name, True, user, thread_ts)
+    elif (match := patterns.DISABLE_OPSGENIE_PATTERN.match(command_text)):
+        await setters.set_opsgenie(app, channel, config_name, False, user, thread_ts)
+    elif (match := patterns.ENABLE_BOTS_PATTERN.match(command_text)):
+        await setters.set_bots(app, channel, config_name, True, user, thread_ts)
+    elif (match := patterns.DISABLE_BOTS_PATTERN.match(command_text)):
+        await setters.set_bots(app, channel, config_name, False, user, thread_ts)
+    elif (match := patterns.ENABLE_ONLY_WORK_DAYS_PATTERN.match(command_text)):
+        await setters.set_only_work_days(app, channel, config_name, True, user, thread_ts)
+    elif (match := patterns.DISABLE_ONLY_WORK_DAYS_PATTERN.match(command_text)):
+        await setters.set_only_work_days(app, channel, config_name, False, user, thread_ts)
+    elif patterns.CLEAR_WORK_HOURS_PATTERN.match(command_text):
+        await setters.clear_work_hours(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_WORK_HOURS_PATTERN.match(command_text)):
+        start = strip_quotes(match.group("start"))
+        end = strip_quotes(match.group("end"))
+        await setters.set_work_hours(app, channel, config_name, start, end, user, thread_ts)
+    elif patterns.LIST_TEAMS_PATTERN.match(command_text):
+        await info.list_teams(app, channel, user, thread_ts)
+    elif patterns.LIST_OPSGENIE_SCHEDULES_PATTERN.match(command_text):
+        await info.list_opsgenie_schedules(app, channel, user, thread_ts)
+    elif (match := patterns.ON_CALL_PATTERN.match(command_text)):
+        schedule_name = strip_quotes(match.group("schedule") or "")
+        await opsgenie.send_current_on_call(app, opsgenie_token, channel, config_name, schedule_name, user, thread_ts)
+    elif (match := patterns.EMPLOYEE_TEAM_PATTERN.match(command_text)):
+        username = strip_quotes(match.group("user"))
+        await info.get_team_of(app, channel, username, user, thread_ts)
+    elif (match := patterns.ADD_EXCLUDED_TEAM_PATTERN.match(command_text)):
+        team = strip_quotes(match.group("team"))
+        await setters.add_excluded_team(app, channel, config_name, team, user, thread_ts)
+    elif (match := patterns.CLEAR_EXCLUDED_TEAM_PATTERN.match(command_text)):
+        await setters.clear_excluded_team(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.ADD_INCLUDED_TEAM_PATTERN.match(command_text)):
+        team = strip_quotes(match.group("team"))
+        await setters.add_included_team(app, channel, config_name, team, user, thread_ts)
+    elif (match := patterns.CLEAR_INCLUDED_TEAM_PATTERN.match(command_text)):
+        await setters.clear_included_team(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_TRIGGER_PATTERN.match(command_text)):
+        await setters.set_trigger(app, channel, config_name, match.group("trigger"), match.group("expression"), user, thread_ts)
+    elif (match := patterns.SET_CONDITION_PATTERN.match(command_text)):
+        await setters.set_condition(app, channel, config_name, match.group("condition"), user, thread_ts)
+    elif (match := patterns.SET_OUTLOOK_SUBJECT_PATTERN.match(command_text)):
+        await setters.set_outlook_pattern(app, channel, config_name, "outlook_subject_pattern", match.group("pattern"), user, thread_ts)
+    elif (match := patterns.SET_OUTLOOK_BODY_PATTERN.match(command_text)):
+        await setters.set_outlook_pattern(app, channel, config_name, "outlook_body_pattern", match.group("pattern"), user, thread_ts)
+    elif patterns.ENABLE_CONDITION_NEGATE_PATTERN.match(command_text):
+        await setters.set_condition_negate(app, channel, config_name, True, user, thread_ts)
+    elif patterns.DISABLE_CONDITION_NEGATE_PATTERN.match(command_text):
+        await setters.set_condition_negate(app, channel, config_name, False, user, thread_ts)
+    elif (match := patterns.SET_ACTION_PATTERN.match(command_text)):
+        await setters.set_action(app, channel, config_name, match.group("action"), match.group("target"), user, thread_ts)
+    elif (match := patterns.ADD_BUTTON_PATTERN.match(command_text)):
+        await setters.add_button(app, channel, config_name, match.group("label"), match.group("spec"), user, thread_ts)
+    elif patterns.CLEAR_BUTTONS_PATTERN.match(command_text):
+        await setters.clear_buttons(app, channel, config_name, user, thread_ts)
+    elif patterns.CLEAR_ESCALATION_PATTERN.match(command_text):
+        await setters.clear_escalation(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_ESCALATION_PATTERN.match(command_text)):
+        await setters.set_escalation(app, channel, config_name, match.group("minutes"), match.group("kind"), match.group("target"), user, thread_ts)
+    elif patterns.RUN_PATTERN.match(command_text):
+        await setters.run_config_now(app, opsgenie_token, channel, config_name, user, thread_ts)
+    elif patterns.ENABLE_REPLIES_PATTERN.match(command_text):
+        await setters.set_replies_enabled(app, channel, config_name, True, user, thread_ts)
+    elif patterns.DISABLE_REPLIES_PATTERN.match(command_text):
+        await setters.set_replies_enabled(app, channel, config_name, False, user, thread_ts)
+    elif (match := patterns.DELETE_CONFIG_PATTERN.match(command_text)):
+        name = strip_quotes(match.group("name"))
+        await setters.delete_config(app, channel, name, user, thread_ts)
+    elif patterns.SHOW_CONFIG_PATTERN.match(command_text):
+        await info.show_config(app, channel, user, thread_ts)
+    elif patterns.HELP_PATTERN.match(command_text):
+        await messaging.send_help_message(app, channel, user, thread_ts)
+    elif patterns.WHATSNEW_PATTERN.match(command_text):
+        await messaging.send_news_message(app, channel, user, thread_ts)
+    else:
+        return False
+    return True
+
+
+def matches_a_command(command_text: str, allow_test_message: bool = False) -> bool:
+    """Whether `command_text` is a command in its own right.
+
+    Used to tell `<config> <command>` from a `<command>` whose first word happens
+    to look like a config name. Every regex in `patterns` is tried, so this cannot
+    drift out of step with what `parse_and_execute_command` accepts.
+    """
+    for name, pattern in vars(patterns).items():
+        if not name.endswith("_PATTERN") or not isinstance(pattern, re.Pattern):
+            continue
+        if name == "TEST_WITH_MESSAGE_PATTERN" and not allow_test_message:
+            continue
+        if pattern.match(command_text):
+            return True
+    return False
+
+
+async def process_command(app: AsyncApp, text: str, channel, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
+    try:
+        await _process_command(app, text, channel, user, thread_ts, opsgenie_token, allow_test_message, command_ts)
+    except Exception as e:
+        # Never let a bad command take down the listener: log it and tell the user.
+        log_error(f"Failed to process command in #{getattr(channel, 'name', '?')}: {text}", e)
+        log_error(traceback.format_exc())
+        try:
+            await messaging.send_message(app, channel, user, "Sorry, something went wrong while running that command. :confused: Please check the syntax with `" + state.slash_command + " help`.", thread_ts)
+        except Exception as send_error:
+            log_error("Failed to report command error to the user:", send_error)
+
+
+async def _process_command(app: AsyncApp, text: str, channel, user, thread_ts: str = "", opsgenie_token: str = "", allow_test_message: bool = False, command_ts: str = "") -> None:
+    text = text.replace(f"<@{state.bot_user_id}>", "").strip()
+    log_debug(channel, f"Received command for channel #{channel.name}: {text}")
+    command_ts = command_ts or thread_ts
+
+    async def run(command_text: str, config_name: str) -> bool:
+        return await parse_and_execute_command(app, command_text, channel, config_name, user, thread_ts, opsgenie_token, allow_test_message, command_ts)
+
+    parts = text.split(None, 1)
+    leading_word, remainder = (parts[0], parts[1]) if len(parts) > 1 else ("", "")
+
+    # `<config> <command>` and `<command>` can both fit the same text — say a config
+    # named `trigger` and the command `trigger cron "…"`. An existing config wins
+    # that tie, because naming one is deliberate; otherwise the text is a command
+    # for the default config.
+    if remainder and leading_word in channel.configs and matches_a_command(remainder, allow_test_message):
+        if await run(remainder, leading_word):
+            return
+
+    if await run(text, DEFAULT_CONFIG_NAME):
+        return
+
+    # Nothing matched as a command, so a leading word can only be a config name —
+    # including one that does not exist yet, which is how configs are created.
+    if remainder and matches_a_command(remainder, allow_test_message):
+        if leading_word.lower() in RESERVED_CONFIG_NAMES:
+            await messaging.send_message(app, channel, user, f"`{leading_word}` cannot be a configuration name; it starts a command. Check the syntax with `{state.slash_command} help`.", thread_ts)
+            return
+        if not CONFIG_NAME_PATTERN.match(leading_word):
+            await messaging.send_message(app, channel, user, f"Invalid config name: `{leading_word}`. Only characters `A-Z`, `a-z`, `0-9`, `.`, `:`, `/`, `-`, `_` are allowed.", thread_ts)
+            return
+        if await run(remainder, leading_word):
+            return
+
+    await messaging.send_message(app, channel, user, f"Huh? :thinking_face: Maybe type `{state.slash_command} help` for a list of commands.", thread_ts)
diff --git a/hutbot/commands/info.py b/hutbot/commands/info.py
new file mode 100644
index 0000000..3e511e4
--- /dev/null
+++ b/hutbot/commands/info.py
@@ -0,0 +1,294 @@
+"""Read-only slash-command handlers: lists, team lookup, and config display."""
+
+import re
+
+import aiohttp
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import get_env_var, log_error
+
+from .. import state
+from .. import messaging
+from .. import slackcache
+from .. import opsgenie
+from .. import buttons
+from .. import datetimefmt
+from .. import templating
+from ..buttonutil import normalize_button
+from .. import targets
+from ..constants import (
+    ACTION_DM_USER,
+    DATETIME_TEMPLATE_VARIABLES,
+    OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
+    ACTION_REPLY,
+    DEFAULT_DATE_FORMAT,
+    DEFAULT_TIME_FORMAT,
+    DISABLED_REASON_REMOVED,
+    ESCALATION_BUTTON,
+    ESCALATION_NONE,
+    ID_PATTERN,
+    TRIGGER_MESSAGE,
+    TRIGGER_CRON,
+)
+from ..textutil import log_debug
+
+
+async def list_teams(app: AsyncApp, channel, user, thread_ts: str = "") -> None:
+    await slackcache.update_user_cache(app)
+    message = f"*Available teams*:\n{'\n'.join(sorted(state.team_cache, key=lambda v: v.upper()))}"
+    await messaging.send_message(app, channel, user, message, thread_ts)
+
+
+async def list_opsgenie_schedules(app: AsyncApp, channel, user, thread_ts: str = "") -> None:
+    opsgenie_token = get_env_var("OPSGENIE_TOKEN")
+    if not opsgenie_token:
+        await messaging.send_message(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
+        return
+
+    url = "https://api.opsgenie.com/v2/schedules"
+    headers = {
+        "Authorization": f"GenieKey {opsgenie_token}",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                if response.status != 200:
+                    log_error(f"Failed to list OpsGenie schedules: {response.status}")
+                    await messaging.send_message(app, channel, user, f"Failed to list OpsGenie schedules: HTTP {response.status}.", thread_ts)
+                    return
+
+                payload = await response.json()
+    except Exception as e:
+        log_error("Failed to list OpsGenie schedules:", e)
+        await messaging.send_message(app, channel, user, "Failed to list OpsGenie schedules.", thread_ts)
+        return
+
+    schedules = payload.get("data", [])
+    if not schedules:
+        await messaging.send_message(app, channel, user, "No OpsGenie schedules found.", thread_ts)
+        return
+
+    schedule_names = sorted(
+        (schedule.get("name", "").strip() for schedule in schedules if schedule.get("name")),
+        key=str.casefold
+    )
+    if not schedule_names:
+        await messaging.send_message(app, channel, user, "No OpsGenie schedules found.", thread_ts)
+        return
+
+    message = "*OpsGenie schedules*:\n" + "\n".join(f"`{name}`" for name in schedule_names)
+    await messaging.send_message(app, channel, user, message, thread_ts)
+
+
+async def get_team_of(app: AsyncApp, channel, username: str, user, thread_ts: str = "") -> None:
+    message = None
+    log_debug(channel, f"Looking up users from message `{username}`...")
+    for match in ID_PATTERN.finditer(username):
+        full_match = match.group(0)
+        log_debug(channel, f"Found ID match: {full_match}...")
+        id = match.group(1)
+        if id and id[0] == '@':
+            user_id = id[1:]
+            log_debug(channel, f"Looking up user with ID {user_id}...")
+            u = await slackcache.get_user_by_id(app, user_id, channel)
+            if u.id:
+                log_debug(channel, f"Found user {u}")
+                display_name = u.real_name if u.real_name else u.name
+                msg = f"*{display_name}* (<@{u.id}>): `{u.team}`"
+                if message is None:
+                    message = msg
+                else:
+                    message += f"\n{msg}"
+            else:
+                log_error(f"Invalid request: username `{full_match}` not found")
+    if message:
+        await messaging.send_message(app, channel, user, message, thread_ts)
+    else:
+        await messaging.send_message(app, channel, user, f"Unknown user: `{username}`.", thread_ts)
+
+
+async def show_config(app: AsyncApp, channel, user, thread_ts: str = "") -> None:
+    if not channel.configs:
+        message = f"There is no configuration for #{channel.name}."
+        await messaging.send_message(app, channel, user, message, thread_ts)
+        return
+
+    def format_table_value(value, key_width: int) -> str:
+        if isinstance(value, list):
+            if not value:
+                return '<none>'
+            return f"\n{' ' * (key_width + 2)}".join(value)
+        return value
+
+    def format_target(target: str) -> str:
+        """Render an action target as a Slack mention when it looks like an id."""
+        target = (target or '').strip()
+        if not target:
+            return '<none>'
+        channel_id = targets.parse_channel_ref(target)
+        if channel_id:
+            return f"<#{channel_id}>"
+        if ID_PATTERN.fullmatch(target) or re.fullmatch(r'<!subteam\^[A-Z0-9]+(\|[^>]*)?>', target):
+            return target
+        if re.fullmatch(r'[UW][A-Z0-9]+', target):
+            return f"<@{target}>"
+        if re.fullmatch(r'S[A-Z0-9]+', target):
+            return f"<!subteam^{target}>"
+        return f"`{target}`"
+
+    def destination_lines(config: dict, action: str, trigger: str) -> list[str]:
+        """Where the message ends up, phrased per action instead of as raw fields."""
+        action_target = config.get('action_target') or ''
+        if action == ACTION_REPLY:
+            # A reply threads on the triggering message; schedule/manual runs have
+            # no message to thread on and land in the channel itself.
+            thread = ' (in thread)' if trigger == TRIGGER_MESSAGE else ''
+            return [f"*Replied in* <#{channel.id}>{thread}"]
+        if action == ACTION_POST_CHANNEL:
+            return [f"*Posted in* {format_target(action_target)}"]
+        if action == ACTION_DM_USER:
+            return [f"*Sent to* {format_target(action_target)} (direct message)"]
+        if action == ACTION_GROUP_DM:
+            return [f"*Sent to* {format_target(action_target)} (group message)"]
+        return [f"*Action* `{action}`, target {format_target(action_target)}"]
+
+    message = f"This is the configuration for #{channel.name}:"
+    config_sections = []
+    for config_name, config in sorted(channel.configs.items()):
+        opsgenie_enabled = config.get('opsgenie')
+        wait_time_minutes = config.get('wait_time') // 60
+        included_teams = config.get('included_teams')
+        excluded_teams = config.get('excluded_teams')
+        include_bots = config.get('include_bots')
+        only_work_days = config.get('only_work_days')
+        hours = config.get('hours')
+        pattern = config.get('pattern')
+        pattern_case_sensitive = config.get('pattern_case_sensitive')
+        reply_message = config.get('reply_message')
+        opsgenie_schedule_name = config.get('opsgenie_schedule_name')
+        date_format = config.get('date_format') or DEFAULT_DATE_FORMAT
+        time_format = config.get('time_format') or DEFAULT_TIME_FORMAT
+        datetime_timezone = datetimefmt.describe_timezone(config.get('datetime_timezone') or '')
+        datetime_locale = datetimefmt.describe_locale(config.get('datetime_locale') or '')
+        opsgenie_priority = opsgenie.get_opsgenie_priority(config)
+        replies_enabled = config.get('enabled', True)
+        trigger = config.get('trigger', TRIGGER_MESSAGE)
+        action = config.get('action', ACTION_REPLY)
+
+        # Settings are grouped by topic, in the order a rule runs: when it fires,
+        # what gates it, what it matches, timing, buttons, alerting, formatting.
+        # Each group becomes a blank-line-separated block in the code block.
+        #
+        # A group is printed only where it has an effect: message matching and the
+        # reminder delay mean nothing to a `cron`/`manual` rule, a condition gates
+        # only a cron, and the date/time settings matter only to something that
+        # renders a date. Printing them anyway invites configuring a field that is
+        # never read.
+        groups: list[list[tuple]] = []
+        reacts_to_messages = trigger == TRIGGER_MESSAGE
+        template_variables = templating.find_template_variables(reply_message or '') | templating.find_template_variables(config.get('opsgenie_message') or '')
+        renders_datetime = bool(template_variables & (DATETIME_TEMPLATE_VARIABLES | OPSGENIE_DATETIME_TEMPLATE_VARIABLES))
+
+        condition = config.get('condition') or ''
+        if condition and trigger == TRIGGER_CRON:
+            negate = ' (negated)' if config.get('condition_negate') else ''
+            condition_rows = [("Condition", f"{condition}{negate}")]
+            if config.get('outlook_subject_pattern'):
+                condition_rows.append(("Outlook subject", config.get('outlook_subject_pattern')))
+            if config.get('outlook_body_pattern'):
+                condition_rows.append(("Outlook body", config.get('outlook_body_pattern')))
+            groups.append(condition_rows)
+
+        if reacts_to_messages:
+            groups.append([
+                ("Pattern",        f"{pattern} ({'case-sensitive' if pattern_case_sensitive else 'case-insensitive'})" if pattern else '<none>'),
+                ("Included teams", included_teams),
+                ("Excluded teams", excluded_teams),
+                ("Include bots",   'enabled' if include_bots else 'disabled'),
+            ])
+
+            groups.append([
+                ("Wait time",      f"{wait_time_minutes} minutes"),
+                ("Only work days", 'enabled' if only_work_days else 'disabled'),
+                ("Work hours",     f"{hours[0]} - {hours[1]}" if len(hours) == 2 else 'any hour'),
+            ])
+
+        config_buttons = config.get('buttons') or []
+        if config_buttons:
+            def _button_label(b):
+                button_action, value = normalize_button(b)
+                return f"{b.get('label')} → {button_action}" + (f":{value}" if value else "")
+            button_rows = [("Buttons", [_button_label(b) for b in config_buttons])]
+            escalation_minutes = (config.get('escalation_timeout') or 0) // 60
+            kind, target = buttons._escalation_kind(config)
+            if escalation_minutes and kind != ESCALATION_NONE:
+                escalates_to = f"auto-press `{target}`" if kind == ESCALATION_BUTTON else f"run `{target}`"
+                button_rows.append(("Escalation", f"after {escalation_minutes} minutes, {escalates_to}"))
+            else:
+                button_rows.append(("Escalation", "none, buttons stay open until pressed"))
+            groups.append(button_rows)
+
+        opsgenie_rows = [("OpsGenie", ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)'))]
+        if opsgenie_enabled:
+            opsgenie_rows += [
+                ("OpsGenie schedule", opsgenie_schedule_name or '<none>'),
+                ("OpsGenie priority", opsgenie_priority),
+                ("OpsGenie message",  config.get('opsgenie_message') or '<original message>'),
+            ]
+        groups.append(opsgenie_rows)
+
+        # The timezone also decides when a cron fires and when work hours are, so it
+        # is shown for those even when nothing renders a date.
+        timezone_matters = trigger == TRIGGER_CRON or (reacts_to_messages and (only_work_days or len(hours) == 2))
+        if renders_datetime:
+            groups.append([
+                ("Date format",        date_format),
+                ("Time format",        time_format),
+                ("Date/time timezone", datetime_timezone),
+                ("Date/time locale",   datetime_locale),
+            ])
+        elif timezone_matters:
+            groups.append([("Date/time timezone", datetime_timezone)])
+
+        key_width = max(len(label) for group in groups for label, _ in group)
+        config_block = "\n\n".join(
+            "\n".join(f"{label:<{key_width}}  {format_table_value(value, key_width)}" for label, value in group)
+            for group in groups
+        )
+        message_label = 'Reply message' if action == ACTION_REPLY else 'Message'
+        reply_line = f"*{message_label}*:\n{reply_message}" if reply_message else f"*{message_label}*: <none>"
+        destinations = "\n".join(destination_lines(config, action, trigger))
+        if replies_enabled:
+            enabled_label = 'enabled'
+        elif config.get('disabled_reason') == DISABLED_REASON_REMOVED:
+            enabled_label = f'disabled, because {state.bot_name} was removed from this channel'
+        else:
+            enabled_label = 'disabled'
+        trigger_line = f"*Trigger*: `{trigger}`"
+        if trigger == TRIGGER_CRON:
+            # The expression is part of the trigger, and it fires in the
+            # Date/time timezone printed with the settings below.
+            trigger_line += f" `{config.get('cron') or '<none>'}`"
+        quoted_block = (
+            f"> {trigger_line}\n"
+            f">\n"
+            f"> {reply_line.replace('\n', '\n> ')}\n"
+            f">\n"
+            f"> {destinations.replace('\n', '\n> ')}\n"
+            f">\n"
+            f"> *Settings*:\n"
+        )
+        config_sections.append(
+            f"*Configuration*: `{config_name}` ({enabled_label})\n"
+            f"{quoted_block}"
+            f"```\n{config_block}\n```"
+        )
+    # Say that the print is filtered, so a missing row does not read as a lost setting.
+    footer = "_Only the settings that apply to each configuration are shown._"
+    # Slack splits an oversized message wherever the break lands, cutting the code
+    # fence in half, so a channel with several configs is sent as several messages.
+    for chunk in messaging.pack_message_chunks([message, *config_sections, footer]):
+        await messaging.send_message(app, channel, user, chunk, thread_ts)
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
new file mode 100644
index 0000000..c1a5b6a
--- /dev/null
+++ b/hutbot/commands/patterns.py
@@ -0,0 +1,62 @@
+"""Compiled regexes for slash-command parsing."""
+
+import re
+
+
+def create_command_pattern(command_regex: str) -> re.Pattern:
+    return re.compile(f'^{command_regex}', re.IGNORECASE)
+
+
+# Every command that sets something takes an optional leading `set`, so
+# `set wait-time 5` and `wait-time 5` are the same command.
+
+
+HELP_PATTERN = re.compile(r'help', re.IGNORECASE)
+WHATSNEW_PATTERN = re.compile(r'news', re.IGNORECASE)
+TEST_PATTERN = re.compile(r'^test$', re.IGNORECASE)
+TEST_WITH_MESSAGE_PATTERN = re.compile(r'^test(?:\s+(?P<message>.*))?$', re.IGNORECASE)
+SET_WAIT_TIME_PATTERN = create_command_pattern(r'(set\s+)?wait([_ -]?time)?\s+(?P<wait_time>.+)')
+SET_REPLY_MESSAGE_PATTERN = create_command_pattern(r'(set\s+)?(message|reply)\s+(?P<message>.+)')
+SET_OPSGENIE_SCHEDULE_PATTERN = create_command_pattern(r'(set\s+)?opsgenie[_ -]?schedule\s+(?P<schedule>.+)')
+SET_OPSGENIE_PRIORITY_PATTERN = create_command_pattern(r'(set\s+)?opsgenie[_ -]?priority\s+(?P<priority>.+)')
+CLEAR_OPSGENIE_MESSAGE_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+opsgenie[_ -]?message')
+SET_OPSGENIE_MESSAGE_PATTERN = create_command_pattern(r'(set\s+)?opsgenie[_ -]?message\s+(?P<message>.+)')
+SET_DATETIME_FORMAT_PATTERN = create_command_pattern(r'(set\s+)?(datetime[_ -]?format|date[_ -]?format|datefmt)\s+(?P<values>.+)')
+CLEAR_PATTERN_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+pattern')
+SET_PATTERN_PATTERN = create_command_pattern(r'(set\s+)?pattern\s+(?P<pattern>"[^"]*"|\'[^\']*\'|[^\r\n\t\f\v\s"\']+)(?:\s+(?P<case_sensitive>true|false|1|0))?')
+ADD_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'(add\s+)?excluded?([_ -]?teams?)?\s+(?P<team>.+)')
+CLEAR_EXCLUDED_TEAM_PATTERN = create_command_pattern(r'clear\s+excluded?([_ -]?teams?)?')
+ADD_INCLUDED_TEAM_PATTERN = create_command_pattern(r'(add\s+)?included?([_ -]?teams?)?\s+(?P<team>.+)')
+CLEAR_INCLUDED_TEAM_PATTERN = create_command_pattern(r'clear\s+included?([_ -]?teams?)?')
+LIST_TEAMS_PATTERN = re.compile(r'^(list\s+)?teams?$', re.IGNORECASE)
+EMPLOYEE_TEAM_PATTERN = re.compile(r'^team(\s+of)?\s+(?P<user>.+)$', re.IGNORECASE)
+LIST_OPSGENIE_SCHEDULES_PATTERN = re.compile(r'^list\s+opsgenie[_ -]?schedules$', re.IGNORECASE)
+ON_CALL_PATTERN = create_command_pattern(r'on[_ -]?call(?:\s+(?P<schedule>.+))?$')
+ENABLE_OPSGENIE_PATTERN = create_command_pattern(r'enable\s+(opsgenie|alerts?)')
+DISABLE_OPSGENIE_PATTERN = create_command_pattern(r'disable\s+(opsgenie|alerts?)')
+ENABLE_BOTS_PATTERN = create_command_pattern(r'(enable|include|set)?\s+bots?')
+DISABLE_BOTS_PATTERN = create_command_pattern(r'(disable|exclude)\s+bots?')
+CLEAR_WORK_HOURS_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+(work[_ -]?)?hours')
+SET_WORK_HOURS_PATTERN = create_command_pattern(r'(set\s+)?(work[_ -]?)?hours\s+(?P<start>.+)\s+(?P<end>.+)')
+ENABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'enable\s+(only[_ -]?)?work[_ -]?days')
+DISABLE_ONLY_WORK_DAYS_PATTERN = create_command_pattern(r'disable\s+(only[_ -]?)?work[_ -]?days')
+SHOW_CONFIG_PATTERN = re.compile(r'^(show\s+)?config(uration)?$', re.IGNORECASE)
+DELETE_CONFIG_PATTERN = create_command_pattern(r'delete\s+config\s+(?P<name>.+)')
+ENABLE_REPLIES_PATTERN = create_command_pattern(r'enable$')
+DISABLE_REPLIES_PATTERN = create_command_pattern(r'disable$')
+# The cron expression belongs to the `cron` trigger, so both arrive together.
+SET_TRIGGER_PATTERN = create_command_pattern(r'(set\s+)?trigger\s+(?P<trigger>\S+)(?:\s+(?P<expression>.+))?$')
+SET_CONDITION_PATTERN = create_command_pattern(r'(set\s+)?condition\s+(?P<condition>.+)')
+SET_OUTLOOK_SUBJECT_PATTERN = create_command_pattern(r'(set\s+)?outlook[_ -]?subject\s+(?P<pattern>.+)')
+SET_OUTLOOK_BODY_PATTERN = create_command_pattern(r'(set\s+)?outlook[_ -]?body\s+(?P<pattern>.+)')
+ENABLE_CONDITION_NEGATE_PATTERN = create_command_pattern(r'enable\s+(condition[_ -]?)?negate')
+DISABLE_CONDITION_NEGATE_PATTERN = create_command_pattern(r'disable\s+(condition[_ -]?)?negate')
+# The target belongs to the action, so both arrive in one command. `set` is
+# optional, like it is for `wait-time` and `message`.
+SET_ACTION_PATTERN = create_command_pattern(r'(set\s+)?action\s+(?P<action>\S+)(?:\s+(?P<target>.+))?$')
+ADD_BUTTON_PATTERN = create_command_pattern(r'(add\s+)?button\s+(?P<label>"[^"]*"|\'[^\']*\'|\S+)\s+(?P<spec>.+)')
+CLEAR_BUTTONS_PATTERN = create_command_pattern(r'clear\s+buttons?')
+# `<minutes> <kind> <target>`: the timeout and what it escalates to are one setting.
+CLEAR_ESCALATION_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+escalation')
+SET_ESCALATION_PATTERN = create_command_pattern(r'(set\s+)?escalation\s+(?P<minutes>\S+)(?:\s+(?P<kind>\S+)(?:\s+(?P<target>.+))?)?$')
+RUN_PATTERN = re.compile(r'^(run|fire)$', re.IGNORECASE)
diff --git a/hutbot/commands/setters.py b/hutbot/commands/setters.py
new file mode 100644
index 0000000..92a49d5
--- /dev/null
+++ b/hutbot/commands/setters.py
@@ -0,0 +1,650 @@
+"""Slash-command handlers that mutate configuration (and run/test commands)."""
+
+import re
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
+
+from .. import state
+from .. import messaging
+from .. import persistence
+from .. import templating
+from .. import datetimefmt
+from .. import slackcache
+from .. import actions
+from .. import targets
+from ..buttonutil import _find_button_index, normalize_button
+from ..constants import (
+    ACTION_POST_CHANNEL,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
+    BUTTON_ACTION_ACK,
+    ACTION_REPLY,
+    ACTION_TARGET_HINTS,
+    ACTIONS,
+    BUTTON_ACTION_CONFIG,
+    BUTTON_ACTION_DELAY,
+    BUTTON_ACTIONS,
+    CONDITION_NONE,
+    CONDITION_OUTLOOK,
+    CONDITIONS,
+    DEFAULT_CONFIG,
+    DEFAULT_CONFIG_NAME,
+    ID_PATTERN,
+    OPSGENIE_PRIORITIES,
+    SUPPORTED_TEMPLATE_VARIABLES,
+    TRIGGER_MESSAGE,
+    TRIGGER_CRON,
+    TRIGGERS,
+)
+from ..textutil import log_debug, parse_quoted_tokens, strip_quotes
+
+try:
+    from croniter import croniter
+except ImportError:  # pragma: no cover - dependency optional at runtime
+    croniter = None
+
+
+def _ensure_config(channel, config_name: str) -> dict:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    return channel.configs[config_name]
+
+
+def _set_action_hint(config_name: str, config: dict) -> str:
+    """The command that gives this config's action a usable target."""
+    action = config.get('action', ACTION_REPLY)
+    hint = ACTION_TARGET_HINTS.get(action, '<target>')
+    return f"`{state.slash_command} {config_name} set action {action.replace('_', '-')} {hint}`"
+
+
+async def set_bots(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['include_bots'] = enabled
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Bot messages* will {'also be *handled*' if enabled else 'be *ignored*'} in configuration `{config_name}`.", thread_ts)
+
+
+async def set_only_work_days(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['only_work_days'] = enabled
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Messages will be handled {'*only on work days*' if enabled else '*on all days*'} in configuration `{config_name}`.", thread_ts)
+
+
+async def set_replies_enabled(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['enabled'] = enabled
+    # An explicit enable/disable supersedes an automatic one (see DISABLED_REASON_REMOVED).
+    channel.configs[config_name]['disabled_reason'] = ""
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Replies are now *{'enabled' if enabled else 'disabled'}* in configuration `{config_name}`.", thread_ts)
+
+
+async def clear_work_hours(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['hours'] = []
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Work hours* cleared in configuration `{config_name}`; messages are handled at any hour.", thread_ts)
+
+
+async def set_work_hours(app: AsyncApp, channel, config_name: str, start: str, end: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    if f"{start} {end}".strip().lower().replace('-', ' ') == "all day":
+        await messaging.send_message(app, channel, user, f"To handle messages at any hour, use `{state.slash_command} {config_name} clear work-hours`.", thread_ts)
+        return
+    start_time = datetimefmt.parse_time(start)
+    end_time = datetimefmt.parse_time(end)
+    if not start_time:
+        await messaging.send_message(app, channel, user, f"Invalid time format `{start}`.", thread_ts)
+        return
+    if not end_time:
+        await messaging.send_message(app, channel, user, f"Invalid time format `{end}`.", thread_ts)
+        return
+    hours = [start_time.strftime("%H:%M"), end_time.strftime("%H:%M")]
+    if hours[0] == "00:00" and hours[1] == "00:00":
+        hours = []
+    channel.configs[config_name]['hours'] = hours
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Work hours* set to {f'`{hours[0]}` - `{hours[1]}`' if len(hours) == 2 else 'all day'} in configuration `{config_name}`", thread_ts)
+
+
+async def set_opsgenie(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['opsgenie'] = enabled
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*OpsGenie integration* {'*enabled*' if enabled else '*disabled*'}{', but not configured' if enabled and not state.opsgenie_configured else ''} in configuration `{config_name}`.", thread_ts)
+
+
+async def set_opsgenie_schedule_name(app: AsyncApp, channel, config_name: str, schedule_name: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    if not schedule_name.strip():
+        await messaging.send_message(app, channel, user, "Invalid *OpsGenie schedule name*. Must be non-empty.", thread_ts)
+        return
+
+    schedule_name = schedule_name.strip()
+    channel.configs[config_name]['opsgenie_schedule_name'] = schedule_name
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*OpsGenie schedule* set to `{schedule_name}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_opsgenie_priority(app: AsyncApp, channel, config_name: str, priority: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+
+    priority = priority.strip().upper()
+    if priority not in OPSGENIE_PRIORITIES:
+        supported = ", ".join(f"`{p}`" for p in sorted(OPSGENIE_PRIORITIES))
+        await messaging.send_message(app, channel, user, f"Invalid *OpsGenie priority*. Must be one of {supported}.", thread_ts)
+        return
+
+    channel.configs[config_name]['opsgenie_priority'] = priority
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*OpsGenie priority* set to `{priority}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_opsgenie_message(app: AsyncApp, channel, config_name: str, message: str, user, thread_ts: str = "") -> None:
+    message = message.strip()
+    validation_error = templating.validate_template_expressions(message)
+    if validation_error:
+        await messaging.send_message(app, channel, user, "Invalid *OpsGenie message*: " + validation_error, thread_ts)
+        return
+    _ensure_config(channel, config_name)['opsgenie_message'] = message
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*OpsGenie message* set to: {message} in configuration `{config_name}`.", thread_ts)
+
+
+async def clear_opsgenie_message(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['opsgenie_message'] = ''
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*OpsGenie message* cleared (using the original message) in configuration `{config_name}`.", thread_ts)
+
+
+async def set_datetime_format(app: AsyncApp, channel, config_name: str, values: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+
+    tokens, error = parse_quoted_tokens(values)
+    if error:
+        await messaging.send_message(app, channel, user, f"Invalid *date/time format*: {error}.", thread_ts)
+        return
+    if len(tokens) < 2 or len(tokens) > 4:
+        await messaging.send_message(app, channel, user, f"Invalid *date/time format*. Use `{state.slash_command} [config] set datetime-format <date> <time> [<timezone> <locale>]`.", thread_ts)
+        return
+
+    date_format = tokens[0]
+    time_format = tokens[1]
+    if not date_format.strip() or not time_format.strip():
+        await messaging.send_message(app, channel, user, "Invalid *date/time format*. Date and time formats must be non-empty.", thread_ts)
+        return
+
+    timezone_name = tokens[2] if len(tokens) >= 3 else ""
+    locale_name = tokens[3] if len(tokens) >= 4 else ""
+    normalized_locale = ""
+    if timezone_name:
+        try:
+            datetimefmt.validate_timezone_name(timezone_name)
+        except ValueError as e:
+            await messaging.send_message(app, channel, user, f"Invalid *date/time format*: {e}.", thread_ts)
+            return
+    if locale_name:
+        try:
+            normalized_locale = datetimefmt.normalize_locale_name(locale_name)
+        except ValueError as e:
+            await messaging.send_message(app, channel, user, f"Invalid *date/time format*: {e}.", thread_ts)
+            return
+
+    config = channel.configs[config_name]
+    config["date_format"] = date_format
+    config["time_format"] = time_format
+    config["datetime_timezone"] = timezone_name
+    config["datetime_locale"] = normalized_locale
+
+    await persistence.save_configuration()
+
+    details = f"*Date/time format* set to date `{date_format}` and time `{time_format}`"
+    if timezone_name:
+        details += f", timezone `{timezone_name}`"
+    if locale_name:
+        details += f", locale `{normalized_locale}`"
+    details += f" in configuration `{config_name}`."
+    await messaging.send_message(app, channel, user, details, thread_ts)
+
+
+async def set_wait_time(app: AsyncApp, channel, config_name: str, wait_time_str: str, user, thread_ts: str = "") -> None:
+    # check if number and in range 0-1440
+    try:
+        wait_time_minutes = int(strip_quotes(wait_time_str or "").strip())
+    except (TypeError, ValueError):
+        await messaging.send_message(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
+        return
+    if not wait_time_minutes or wait_time_minutes < 0 or wait_time_minutes > 1440:
+        await messaging.send_message(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
+        return
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+
+    channel.configs[config_name]['wait_time'] = wait_time_minutes * 60  # Convert to seconds
+    log_debug(channel, f"Wait time for #{channel.name} set to {wait_time_minutes} minutes for configuration `{config_name}`")
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Wait time* set to `{wait_time_minutes}` minutes in configuration `{config_name}`.", thread_ts)
+
+
+async def set_reply_message(app: AsyncApp, channel, config_name: str, message: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    # check message
+    if not message or message.strip() == "":
+        await messaging.send_message(app, channel, user, "Invalid *reply message*. Must be non-empty.", thread_ts)
+        return
+    ok, error, message = await messaging.process_mentions(app, message)
+    if not ok:
+        await messaging.send_message(app, channel, user, "Invalid *reply message*: " + error + ".", thread_ts)
+        return
+
+    validation_error = templating.validate_template_expressions(message)
+    if validation_error:
+        await messaging.send_message(
+            app,
+            channel,
+            user,
+            "Invalid *reply message*: " + validation_error,
+            thread_ts
+        )
+        return
+
+    channel.configs[config_name]['reply_message'] = message
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Reply message* set to: {message} in configuration `{config_name}`.", thread_ts)
+
+
+async def test_reply_message(app: AsyncApp, opsgenie_token: str, channel, config_name: str, user, text: str = "", ts: str = "", thread_ts: str = "") -> None:
+    config = channel.configs.get(config_name, DEFAULT_CONFIG.copy())
+    reply_message_template = config.get('reply_message')
+    permalink = await slackcache.get_message_permalink(app, channel, ts) if ts else ""
+    template_variables = await templating.build_reply_template_variables(
+        app,
+        opsgenie_token,
+        channel,
+        config,
+        config_name,
+        user,
+        text,
+        ts,
+        permalink,
+        include_opsgenie=True,
+    )
+    reply_message = templating.render_reply_message_template(reply_message_template, template_variables, config)
+    variable_lines = [
+        f"`{{{{{variable}}}}}`: {template_variables.get(variable, '')}"
+        for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES)
+    ]
+    message = (
+        f"*Reply preview for configuration `{config_name}`:*\n"
+        f"{reply_message}\n\n"
+        "*Template variables:*\n"
+        + "\n".join(variable_lines)
+    )
+    await messaging.send_message(app, channel, user, message, thread_ts)
+
+
+async def clear_pattern(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    config = _ensure_config(channel, config_name)
+    config['pattern'] = None
+    config['pattern_case_sensitive'] = False
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Pattern* cleared in configuration `{config_name}`; every message matches now.", thread_ts)
+
+
+async def set_pattern(app: AsyncApp, channel, config_name: str, pattern_str: str, case_sensitive_str: str | None, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+
+    pattern_str = strip_quotes(pattern_str)
+
+    # Validate the regex pattern
+    try:
+        re.compile(pattern_str)
+    except re.error as e:
+        await messaging.send_message(app, channel, user, f"Invalid pattern: `{e}`", thread_ts)
+        return
+
+    case_sensitive = case_sensitive_str is not None and case_sensitive_str.lower() in ['true', '1']
+
+    channel.configs[config_name]['pattern'] = pattern_str
+    channel.configs[config_name]['pattern_case_sensitive'] = case_sensitive
+    await persistence.save_configuration()
+
+    message = f"Pattern set to `{pattern_str}` for configuration `{config_name}`."
+    if case_sensitive:
+        message += " (case-sensitive)"
+    else:
+        message += " (case-insensitive)"
+    await messaging.send_message(app, channel, user, message, thread_ts)
+
+
+async def delete_config(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    if config_name == DEFAULT_CONFIG_NAME:
+        await messaging.send_message(app, channel, user, f"The `{DEFAULT_CONFIG_NAME}` configuration cannot be deleted.", thread_ts)
+        return
+
+    if config_name not in channel.configs:
+        await messaging.send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
+        return
+
+    del channel.configs[config_name]
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Configuration `{config_name}` has been deleted.", thread_ts)
+
+
+async def set_trigger(app: AsyncApp, channel, config_name: str, value: str, expression: str, user, thread_ts: str = "") -> None:
+    """`set trigger <trigger> [<expression>]` — the cron trigger carries its cron.
+
+    A cron trigger without an expression never fires and the scheduler skips it
+    without a word, so the expression is part of choosing the trigger.
+    """
+    value = strip_quotes(value).strip().lower()
+    value = {'msg': TRIGGER_MESSAGE, 'schedule': TRIGGER_CRON, 'scheduled': TRIGGER_CRON}.get(value, value)
+    if value not in TRIGGERS:
+        supported = ", ".join(f"`{t}`" for t in sorted(TRIGGERS))
+        await messaging.send_message(app, channel, user, f"Invalid *trigger*. Must be one of {supported}.", thread_ts)
+        return
+    expression = strip_quotes(expression or "").strip()
+
+    if value == TRIGGER_CRON:
+        if not expression:
+            await messaging.send_message(app, channel, user, f"Trigger `{TRIGGER_CRON}` needs an expression: `{state.slash_command} {config_name} set trigger cron \"0 9 * * 1-5\"`.", thread_ts)
+            return
+        if croniter is not None and not croniter.is_valid(expression):
+            await messaging.send_message(app, channel, user, f"Invalid *cron* expression: `{expression}`. Use 5-field cron, e.g. `0 9 * * 1-5`.", thread_ts)
+            return
+    elif expression:
+        await messaging.send_message(app, channel, user, f"Trigger `{value}` takes no expression; only `{TRIGGER_CRON}` does.", thread_ts)
+        return
+
+    config = _ensure_config(channel, config_name)
+    config['trigger'] = value
+    config['cron'] = expression
+    await persistence.save_configuration()
+    if value == TRIGGER_CRON:
+        note = "" if croniter is not None else " (not validated — `croniter` not installed)"
+        await messaging.send_message(app, channel, user, f"*Trigger* set to `{value}` running `{expression}` in configuration `{config_name}`{note}.", thread_ts)
+    else:
+        await messaging.send_message(app, channel, user, f"*Trigger* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_condition(app: AsyncApp, channel, config_name: str, value: str, user, thread_ts: str = "") -> None:
+    value = strip_quotes(value).strip().lower()
+    value = {'none': CONDITION_NONE, 'off': CONDITION_NONE, '': CONDITION_NONE,
+             'outlook': CONDITION_OUTLOOK, 'calendar': CONDITION_OUTLOOK, 'outlook_calendar': CONDITION_OUTLOOK}.get(value, value)
+    if value not in CONDITIONS:
+        await messaging.send_message(app, channel, user, "Invalid *condition*. Must be `none` or `outlook`.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['condition'] = value
+    await persistence.save_configuration()
+    label = value or 'none'
+    await messaging.send_message(app, channel, user, f"*Condition* set to `{label}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_outlook_pattern(app: AsyncApp, channel, config_name: str, field: str, pattern_str: str, user, thread_ts: str = "") -> None:
+    pattern_str = strip_quotes(pattern_str)
+    try:
+        re.compile(pattern_str)
+    except re.error as e:
+        await messaging.send_message(app, channel, user, f"Invalid pattern: `{e}`", thread_ts)
+        return
+    _ensure_config(channel, config_name)[field] = pattern_str
+    await persistence.save_configuration()
+    which = "subject" if field == "outlook_subject_pattern" else "body"
+    await messaging.send_message(app, channel, user, f"*Outlook {which} pattern* set to `{pattern_str}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_condition_negate(app: AsyncApp, channel, config_name: str, enabled: bool, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['condition_negate'] = enabled
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Condition negation* {'*enabled*' if enabled else '*disabled*'} in configuration `{config_name}`.", thread_ts)
+
+
+async def set_action(app: AsyncApp, channel, config_name: str, value: str, target: str, user, thread_ts: str = "") -> None:
+    """`set action <action> [<target>]` — the target is part of choosing the action.
+
+    Every action except `reply` sends somewhere else, so it is only a complete
+    instruction together with its recipient. Requiring both in one command means a
+    config can never be left in a state that fails when the rule fires.
+    """
+    value = strip_quotes(value).strip().lower().replace('-', '_')
+    if value not in ACTIONS:
+        supported = ", ".join(f"`{a}`" for a in sorted(ACTIONS))
+        await messaging.send_message(app, channel, user, f"Invalid *action*. Must be one of {supported}.", thread_ts)
+        return
+    target = strip_quotes(target or "").strip()
+
+    if value == ACTION_REPLY:
+        if target:
+            await messaging.send_message(app, channel, user, f"Action `{ACTION_REPLY}` posts in this channel and takes no target.", thread_ts)
+            return
+    elif not target:
+        await messaging.send_message(app, channel, user, f"Action `{value}` needs a target: `{state.slash_command} {config_name} set action {value.replace('_', '-')} {ACTION_TARGET_HINTS[value]}`.", thread_ts)
+        return
+    elif value == ACTION_POST_CHANNEL and not targets.parse_channel_ref(target):
+        await messaging.send_message(app, channel, user, f"Invalid *target* `{target}` for action `{value}`. Pick the channel from Slack's autocomplete so it becomes a link, or pass its `C…` id.", thread_ts)
+        return
+
+    config = _ensure_config(channel, config_name)
+    config['action'] = value
+    config['action_target'] = target
+    await persistence.save_configuration()
+    if target:
+        await messaging.send_message(app, channel, user, f"*Action* set to `{value}` sending to `{target}` in configuration `{config_name}`.", thread_ts)
+    else:
+        await messaging.send_message(app, channel, user, f"*Action* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+
+async def add_button(app: AsyncApp, channel, config_name: str, label: str, spec: str, user, thread_ts: str = "") -> None:
+    label = strip_quotes(label).strip()
+    if not label:
+        await messaging.send_message(app, channel, user, "Invalid *button label*. Must be non-empty.", thread_ts)
+        return
+
+    # spec is "<action> [arg]". The action keyword is required: without it a config
+    # named after one (`ack`, `message`, `delay`) could never be attached.
+    parts = spec.strip().split(None, 1)
+    action = parts[0].lower() if parts else ""
+    if action not in BUTTON_ACTIONS:
+        supported = ", ".join(f"`{a}`" for a in sorted(BUTTON_ACTIONS))
+        await messaging.send_message(app, channel, user, f"Invalid *button action* `{parts[0] if parts else ''}`. Must be one of {supported}.", thread_ts)
+        return
+    value = strip_quotes(parts[1]).strip() if len(parts) > 1 else ""
+
+    if action == BUTTON_ACTION_CONFIG and not value:
+        await messaging.send_message(app, channel, user, f"Invalid *button*. `{action}` needs a configuration name.", thread_ts)
+        return
+    if action == BUTTON_ACTION_ACK and value:
+        # A button's text is a template too, so it gets the same treatment as
+        # `set message`: @mentions resolved to ids, variables checked.
+        ok, mention_error, value = await messaging.process_mentions(app, value)
+        if not ok:
+            await messaging.send_message(app, channel, user, f"Invalid *button* message: {mention_error}.", thread_ts)
+            return
+        template_error = templating.validate_template_expressions(value)
+        if template_error:
+            await messaging.send_message(app, channel, user, f"Invalid *button* message: {template_error}", thread_ts)
+            return
+    if action == BUTTON_ACTION_DELAY:
+        # A delay button postpones the escalation, so there has to be one to postpone.
+        existing = channel.configs.get(config_name) or {}
+        if not (existing.get('escalation_timeout') and (existing.get('escalation_kind') or ESCALATION_NONE) != ESCALATION_NONE):
+            await messaging.send_message(app, channel, user, f"A `delay` button needs an escalation to postpone. Set one first with `{state.slash_command} {config_name} set escalation <minutes> <button \"<label>\"|config <name>>`.", thread_ts)
+            return
+        try:
+            minutes = int(value)
+        except ValueError:
+            await messaging.send_message(app, channel, user, "Invalid *button*. `delay` needs a number of minutes.", thread_ts)
+            return
+        if minutes <= 0 or minutes > 1440:
+            await messaging.send_message(app, channel, user, "Invalid *button*. `delay` minutes must be between 1 and 1440.", thread_ts)
+            return
+        value = str(minutes)
+
+    config = _ensure_config(channel, config_name)
+    # Copy-on-write so we never mutate a shared default list.
+    config['buttons'] = list(config.get('buttons') or []) + [{'label': label, 'action': action, 'value': value}]
+    await persistence.save_configuration()
+
+    warning = ""
+    if action == BUTTON_ACTION_CONFIG and value not in channel.configs:
+        warning = f" :warning: (configuration `{value}` does not exist yet)"
+    descriptor = f"`{action}`" + (f" → `{value}`" if value else "")
+    await messaging.send_message(app, channel, user, f"Added button `{label}` ({descriptor}) in configuration `{config_name}`{warning}.", thread_ts)
+
+
+async def clear_buttons(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['buttons'] = []
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Cleared *buttons* in configuration `{config_name}`.", thread_ts)
+
+
+async def clear_escalation(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    config = _ensure_config(channel, config_name)
+    config['escalation_timeout'] = 0
+    config['escalation_kind'] = ESCALATION_NONE
+    config['escalation_target'] = ''
+    await persistence.save_configuration()
+    delay_buttons = [b.get('label') for b in (config.get('buttons') or []) if normalize_button(b)[0] == BUTTON_ACTION_DELAY]
+    warning = ""
+    if delay_buttons:
+        labels = ", ".join(f"`{label}`" for label in delay_buttons)
+        warning = f" :warning: ({labels} now has nothing to postpone)"
+    await messaging.send_message(app, channel, user, f"*Escalation* cleared in configuration `{config_name}`; buttons stay open until pressed{warning}.", thread_ts)
+
+
+async def set_escalation(app: AsyncApp, channel, config_name: str, minutes_str: str, kind: str | None, target: str | None, user, thread_ts: str = "") -> None:
+    """`set escalation <minutes> <button|config> <target>` — one setting, not three.
+
+    A timeout with nothing to escalate to silently does nothing, and a target with
+    no timeout never fires, so both halves are set together or not at all.
+    """
+    minutes_str = strip_quotes(minutes_str or "").strip().lower()
+    kind = strip_quotes(kind or "").strip().lower()
+    target = strip_quotes(target or "").strip()
+    usage = f'`{state.slash_command} {config_name} set escalation <minutes> <button "<label>"|config <name>>`, or `set escalation none`'
+
+    if minutes_str in ("none", "off", "no", "0"):
+        await messaging.send_message(app, channel, user, f"To switch escalation off, use `{state.slash_command} {config_name} clear escalation`.", thread_ts)
+        return
+
+    try:
+        minutes = int(minutes_str)
+    except ValueError:
+        await messaging.send_message(app, channel, user, f"Invalid *escalation*. Use {usage}.", thread_ts)
+        return
+    if minutes < 1 or minutes > 1440:
+        await messaging.send_message(app, channel, user, "Invalid *escalation*. Minutes must be between 1 and 1440, or `none`.", thread_ts)
+        return
+
+    if kind not in (ESCALATION_BUTTON, ESCALATION_CONFIG):
+        await messaging.send_message(app, channel, user, f"*Escalation* needs what to escalate to: {usage}.", thread_ts)
+        return
+    if not target:
+        what = "a button label" if kind == ESCALATION_BUTTON else "a configuration name"
+        await messaging.send_message(app, channel, user, f"*Escalation* `{kind}` needs {what}: {usage}.", thread_ts)
+        return
+
+    config = _ensure_config(channel, config_name)
+    warning = ""
+    if kind == ESCALATION_BUTTON:
+        # An unknown label would otherwise only surface as a warning at escalation time.
+        if _find_button_index(config, target) is None:
+            labels = ", ".join(f"`{b.get('label')}`" for b in (config.get('buttons') or [])) or "none yet"
+            await messaging.send_message(app, channel, user, f"No button labelled `{target}` in configuration `{config_name}` (buttons: {labels}).", thread_ts)
+            return
+    elif target not in channel.configs:
+        # A target config is often created afterwards, so this is only a warning.
+        warning = f" :warning: (configuration `{target}` does not exist yet)"
+
+    config['escalation_timeout'] = minutes * 60
+    config['escalation_kind'] = kind
+    config['escalation_target'] = target
+    await persistence.save_configuration()
+    does = f"auto-press `{target}`" if kind == ESCALATION_BUTTON else f"run `{target}`"
+    await messaging.send_message(app, channel, user, f"*Escalation* set: after `{minutes}` minutes without a press, {does} in configuration `{config_name}`{warning}.", thread_ts)
+
+
+async def run_config_now(app: AsyncApp, opsgenie_token: str, channel, config_name: str, user, thread_ts: str = "") -> None:
+    config = channel.configs.get(config_name)
+    if not config:
+        await messaging.send_message(app, channel, user, f"Configuration `{config_name}` not found.", thread_ts)
+        return
+    reason = actions.missing_target_reason(config)
+    if reason:
+        await messaging.send_message(app, channel, user, f"Cannot run configuration `{config_name}`: {reason}. Set one with {_set_action_hint(config_name, config)}.", thread_ts)
+        return
+    await messaging.send_message(app, channel, user, f"Running configuration `{config_name}` now…", thread_ts)
+    posted = await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
+    if not posted:
+        await messaging.send_message(app, channel, user, f"Configuration `{config_name}` did not send anything. Check its action and target with `{state.slash_command} show config`.", thread_ts)
+
+
+async def add_excluded_team(app: AsyncApp, channel, config_name: str, team: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    config = channel.configs[config_name]
+    await slackcache.update_user_cache(app)
+    if team not in state.team_cache:
+        await messaging.send_message(app, channel, user, f"Unknown team: `{team}`.", thread_ts)
+        return
+    if team in config['excluded_teams']:
+        await messaging.send_message(app, channel, user, f"`{team}` is already excluded in configuration `{config_name}`.", thread_ts)
+        return
+
+    if len(config['included_teams']) > 0:
+        await messaging.send_message(app, channel, user, f"Either set *included teams* or *excluded teams*, not both, in configuration `{config_name}`.", thread_ts)
+        return
+
+    config['excluded_teams'].append(team)
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Added `{team}` to *excluded teams* in configuration `{config_name}`.", thread_ts)
+
+
+async def clear_excluded_team(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['excluded_teams'] = []
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Cleared *excluded teams* in configuration `{config_name}`.", thread_ts)
+
+
+async def add_included_team(app: AsyncApp, channel, config_name: str, team: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    config = channel.configs[config_name]
+    await slackcache.update_user_cache(app)
+    if team not in state.team_cache:
+        await messaging.send_message(app, channel, user, f"Unknown team: `{team}`.", thread_ts)
+        return
+    if team in config['included_teams']:
+        await messaging.send_message(app, channel, user, f"`{team}` is already included in configuration `{config_name}`.", thread_ts)
+        return
+
+    if len(config['excluded_teams']) > 0:
+        await messaging.send_message(app, channel, user, f"Either set *included teams* or *excluded teams*, not both, in configuration `{config_name}`.", thread_ts)
+        return
+
+    config['included_teams'].append(team)
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Added `{team}` to *included teams* in configuration `{config_name}`.", thread_ts)
+
+
+async def clear_included_team(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    if config_name not in channel.configs:
+        channel.configs[config_name] = DEFAULT_CONFIG.copy()
+    channel.configs[config_name]['included_teams'] = []
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Cleared *included teams* in configuration `{config_name}`.", thread_ts)
diff --git a/hutbot/constants.py b/hutbot/constants.py
new file mode 100644
index 0000000..0dda1b2
--- /dev/null
+++ b/hutbot/constants.py
@@ -0,0 +1,216 @@
+"""Constants, defaults, and the non-command regexes.
+
+Command-parsing regexes live in ``hutbot/commands/patterns.py`` because only the
+commands sub-package consumes them.
+"""
+
+import os
+import re
+
+DEFAULT_CONFIG_NAME = 'default'
+# Slash command the bot registers with Slack. A second instance (e.g. the dev
+# deployment) runs behind its own Slack app and therefore its own command, so
+# this is configurable via HUTBOT_SLASH_COMMAND. The live value is kept in
+# ``state.slash_command`` because the environment is only loaded at startup.
+DEFAULT_SLASH_COMMAND = '/hutbot'
+# Name the bot calls itself in user-facing text. A second instance (e.g. the dev
+# deployment) sets HUTBOT_BOT_NAME to something like "Hutbot (DEV)" so users can
+# tell the two apart. The live value is in ``state.bot_name``.
+DEFAULT_BOT_NAME = 'Hutbot'
+DEFAULT_DATE_FORMAT = "%a, %d %b %Y"
+DEFAULT_TIME_FORMAT = "%H:%M"
+DEFAULT_OPSGENIE_PRIORITY = "P4"
+OPSGENIE_PRIORITIES = {"P1", "P2", "P3", "P4", "P5"}
+
+TRIGGER_MESSAGE = "message"
+TRIGGER_CRON = "cron"
+TRIGGER_MANUAL = "manual"
+TRIGGERS = {TRIGGER_MESSAGE, TRIGGER_CRON, TRIGGER_MANUAL}
+
+CONDITION_NONE = ""
+CONDITION_OUTLOOK = "outlook_calendar"
+CONDITIONS = {CONDITION_NONE, CONDITION_OUTLOOK}
+
+ACTION_REPLY = "reply"
+ACTION_DM_USER = "dm_user"
+ACTION_GROUP_DM = "group_dm"
+ACTION_POST_CHANNEL = "post_channel"
+ACTIONS = {ACTION_REPLY, ACTION_DM_USER, ACTION_GROUP_DM, ACTION_POST_CHANNEL}
+
+# Actions that go somewhere other than the channel the rule lives in, and what a
+# usable target looks like. `reply` is the only action that needs none.
+ACTION_TARGET_HINTS = {
+    ACTION_DM_USER: "<@user>",
+    ACTION_GROUP_DM: "@usergroup",
+    ACTION_POST_CHANNEL: "<#channel>",
+}
+ACTIONS_REQUIRING_TARGET = set(ACTION_TARGET_HINTS)
+
+BUTTON_ACTION_PREFIX = "hutbot_btn"
+
+# Marker written to a config's ``disabled_reason`` when the bot disabled it by
+# itself (instead of a user running `disable`). Removing the bot from a channel
+# disables that channel's configs; the marker lets the bot point them out when
+# it is added back.
+DISABLED_REASON_REMOVED = "removed_from_channel"
+
+# What a button does when pressed.
+BUTTON_ACTION_CONFIG = "config"    # run another named config (an OpsGenie alert is just such a config)
+# Acknowledge/dismiss: cancels a pending escalation, and posts its text if it has
+# one. Posting and dismissing were two keywords for one behavior; this is it.
+BUTTON_ACTION_ACK = "ack"
+BUTTON_ACTION_DELAY = "delay"      # delay the pending escalation by N minutes
+BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_DELAY}
+
+# What a buttoned message escalates to if no button is pressed within the timeout.
+ESCALATION_NONE = "none"
+ESCALATION_CONFIG = "config"
+ESCALATION_BUTTON = "button"  # auto-press a named button (the "default" button)
+
+DEFAULT_CONFIG = {
+    "wait_time": 30 * 60,
+    "reply_message": "Anybody?",
+    "opsgenie": False,
+    "opsgenie_schedule_name": "",
+    "opsgenie_priority": DEFAULT_OPSGENIE_PRIORITY,
+    "opsgenie_message": "",  # optional template for the alert text; empty = original message
+    "date_format": "",
+    "time_format": "",
+    "datetime_timezone": "",
+    "datetime_locale": "",
+    "debug": False,
+    "include_bots": False,
+    "excluded_teams": [],
+    "included_teams": [],
+    "only_work_days": False,
+    "hours": [],
+    "pattern": None,
+    "pattern_case_sensitive": False,
+    "enabled": True,
+    # Why the bot disabled this config on its own; empty for a user-made change.
+    "disabled_reason": "",
+    # Trigger: how the rule starts. "message" keeps the classic behavior; "cron"
+    # carries its expression in `cron`.
+    "trigger": TRIGGER_MESSAGE,
+    "cron": "",
+    # Condition: optional gate evaluated when a cron trigger fires.
+    "condition": CONDITION_NONE,
+    "condition_negate": False,
+    "outlook_subject_pattern": "",
+    "outlook_body_pattern": "",
+    # Action: what the rule does when it fires.
+    "action": ACTION_REPLY,
+    "action_target": "",
+    # Buttons: interactive buttons attached to the sent message.
+    "buttons": [],
+    # Escalation: what happens when nobody presses a button in time. The timeout and
+    # its target are one setting, so a timer can never exist with nothing to fire.
+    "escalation_timeout": 0,           # seconds; 0 = never escalate
+    "escalation_kind": ESCALATION_NONE,  # "none" | "button" | "config"
+    "escalation_target": "",           # a button label, or a config name
+}
+
+CONFIG_FILE_NAME = os.environ.get('HUTBOT_CONFIG_FILE', 'bot.json')
+SCHEDULED_REPLIES_CACHE_FILE = os.environ.get('HUTBOT_SCHEDULED_REPLIES_CACHE_FILE', 'scheduled_replies.json')
+BUTTON_CACHE_FILE = os.environ.get('HUTBOT_BUTTON_CACHE_FILE', 'button_states.json')
+SCHEDULER_INTERVAL = int(os.environ.get('HUTBOT_SCHEDULER_INTERVAL', '30'))
+TEAM_UNKNOWN = '<unknown>'
+
+IGNORED_MESSAGE_SUBTYPES = set(['channel_join',
+                                'channel_leave',
+                                'channel_archived',
+                                'channel_unarchived',
+                                'channel_convert_to_private',
+                                'channel_convert_to_public',
+                                'channel_name',
+                                'channel_posting_permissions',
+                                'channel_purpose',
+                                'channel_topic'])
+
+
+def bot_slug(name: str) -> str:
+    """Machine-safe form of the bot name, e.g. "Hutbot (DEV)" -> "hutbot-dev".
+
+    Used where a stable identifier is needed instead of a display name (the
+    OpsGenie alert alias, which is the dedup key). "Hutbot" maps to "hutbot",
+    so the production alias is unchanged.
+    """
+    slug = re.sub(r'[^a-z0-9]+', '-', (name or "").lower()).strip('-')
+    return slug or DEFAULT_BOT_NAME.lower()
+
+
+def normalize_version(value: str) -> str:
+    """Display form of a version, e.g. "1.0.9" or "v1.0.9" -> "v1.0.9"."""
+    value = (value or "").strip()
+    if not value:
+        return ""
+    return value if value.startswith("v") else f"v{value}"
+
+
+def normalize_slash_command(value: str) -> str:
+    """Return a usable Slack slash command, defaulting when unset."""
+    value = (value or "").strip()
+    if not value:
+        return DEFAULT_SLASH_COMMAND
+    return value if value.startswith("/") else f"/{value}"
+
+
+MENTION_PATTERN = re.compile(r'(?<![|<])@([a-z0-9-_.]+)(?!>)')
+ID_PATTERN = re.compile(r'<([#@!][a-zA-Z0-9^]+)([|]([^>]*))?>')
+TIME_HOUR_PATTERN = re.compile(r"^[0-9]{1,2}$")
+CONFIG_NAME_PATTERN = re.compile(r"^[A-Za-z0-9-_\.:/]+$")
+# Words that start a command. A config may not be named after one, or
+# `set enable` would create a config called "set" instead of failing.
+RESERVED_CONFIG_NAMES = {
+    "set", "clear", "unset", "remove", "add", "enable", "disable",
+    "show", "delete", "list", "run", "fire", "test", "help", "news",
+}
+TEMPLATE_VARIABLE_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
+TEMPLATE_ARGUMENT_NAME_PATTERN = re.compile(r'[a-z_][a-z0-9_]*')
+TEMPLATE_ARGUMENT_ALIASES = {
+    "fmt": "fmt",
+    "format": "fmt",
+    "tz": "tz",
+    "timezone": "tz",
+    "lc": "lc",
+    "locale": "lc",
+}
+OPSGENIE_DATETIME_TEMPLATE_VARIABLES = {
+    f"opsgenie_{period}_{bound}_{part}"
+    for period in ("current", "next")
+    for bound in ("start", "end")
+    for part in ("date", "time", "datetime")
+}
+OPSGENIE_TEMPLATE_VARIABLES = {
+    "opsgenie_schedule_name",
+    "opsgenie_current_email",
+    "opsgenie_current_name",
+    "opsgenie_current_user",
+    "opsgenie_next_email",
+    "opsgenie_next_name",
+    "opsgenie_next_user",
+    *OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
+}
+# Formatted renderings of ``{{timestamp}}``: the triggering message's time, or the
+# time the rule ran when there is no message behind it. Like the OpsGenie date/time
+# variables they take `fmt`/`tz`/`lc` arguments.
+DATETIME_TEMPLATE_VARIABLES = {"date", "time", "datetime"}
+SUPPORTED_TEMPLATE_VARIABLES = {
+    *DATETIME_TEMPLATE_VARIABLES,
+    "channel",
+    "channel_name",
+    "config",
+    "message",
+    "message_link",
+    *OPSGENIE_TEMPLATE_VARIABLES,
+    "team",
+    "timestamp",
+    "user",
+    "user_name",
+    "wait_minutes",
+}
+UNKNOWN_EMAIL_ONCALL_PLACEHOLDER = "<no-email-set>"
+UNKNOWN_NAME_ONCALL_PLACEHOLDER = "<no-name-set>"
+UNKNOWN_USER_ONCALL_PLACEHOLDER = "<no-user-set>"
+UNKNOWN_ONCALL_PERIOD_PLACEHOLDER = "<unknown>"
+UNKNOWN_OPSGENIE_SCHEDULE_PLACEHOLDER = "<no-schedule-set>"
diff --git a/hutbot/datetimefmt.py b/hutbot/datetimefmt.py
new file mode 100644
index 0000000..4180c49
--- /dev/null
+++ b/hutbot/datetimefmt.py
@@ -0,0 +1,401 @@
+"""Date/time parsing, formatting, locale handling, and work-hours helpers."""
+
+import locale as locale_module
+import os
+import re
+import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from employee_list import log_error, log_warning
+
+from . import state
+from .constants import (
+    DEFAULT_DATE_FORMAT,
+    DEFAULT_TIME_FORMAT,
+    TIME_HOUR_PATTERN,
+    UNKNOWN_ONCALL_PERIOD_PLACEHOLDER,
+)
+
+
+def parse_time(time_str) -> datetime.time | None:
+    if TIME_HOUR_PATTERN.match(time_str):
+        time_str = f"{time_str}:00"
+
+    time = None
+    try:
+        time = datetime.datetime.strptime(time_str, "%H:%M").time()
+    except ValueError:
+        pass
+
+    return time
+
+
+def is_work_day(config: dict | None = None) -> bool:
+    # Work days are counted in the config's timezone, so a rule set to
+    # Asia/Tokyo rolls over to the next day when Tokyo does, not when the
+    # server does.
+    today = datetime.datetime.now(get_config_timezone(config)).date()
+    # TODO: add holidays
+    return today.weekday() < 5
+
+
+def is_work_time(start_time_str: str, end_time_str: str, config: dict | None = None) -> bool:
+    # Work hours are wall-clock times in the config's timezone; without one they
+    # fall back to the server's, which is what this did before timezones existed.
+    now = datetime.datetime.now(get_config_timezone(config))
+    start = parse_time(start_time_str)
+    end = parse_time(end_time_str)
+    if not start or not end:
+        log_error(f"Invalid time format {start_time_str} - {end_time_str}")
+        return True
+    start_today = datetime.datetime.combine(now.date(), start, tzinfo=now.tzinfo)
+    end_today = datetime.datetime.combine(now.date(), end, tzinfo=now.tzinfo)
+    return start_today < now < end_today
+
+
+def normalize_locale_name(value: str) -> str:
+    value = value.strip()
+    if not value:
+        raise ValueError("locale must be non-empty")
+    match = re.fullmatch(r"([A-Za-z]{2,3})(?:[-_]([A-Za-z]{2}|\d{3}))?", value)
+    if not match:
+        raise ValueError("locale must look like `en`, `en-US`, or `de_DE`")
+
+    language = match.group(1).lower()
+    region = match.group(2)
+    if not region:
+        return language
+    return f"{language}_{region.upper()}"
+
+
+def validate_timezone_name(value: str) -> str:
+    value = value.strip()
+    if not value:
+        raise ValueError("timezone must be non-empty")
+    try:
+        ZoneInfo(value)
+    except ZoneInfoNotFoundError:
+        raise ValueError(f"unknown timezone `{value}`")
+    return value
+
+
+def get_local_timezone() -> datetime.tzinfo:
+    return datetime.datetime.now().astimezone().tzinfo or datetime.timezone.utc
+
+
+def get_local_timezone_name() -> str:
+    """Best-effort zone name of the server, e.g. ``Europe/Berlin`` or ``Etc/UTC``.
+
+    Python only exposes the current abbreviation ("CEST"), so the IANA name is
+    read from the places the host keeps it. Falls back to the abbreviation when
+    none of them is available.
+    """
+    tz_env = os.environ.get("TZ", "").strip()
+    if tz_env:
+        return tz_env
+    try:
+        with open("/etc/timezone", encoding="utf-8") as f:
+            name = f.read().strip()
+        if name:
+            return name
+    except OSError:
+        pass
+    try:
+        target = os.path.realpath("/etc/localtime")
+    except OSError:
+        target = ""
+    marker = "/zoneinfo/"
+    if marker in target:
+        return target.split(marker, 1)[1]
+    return datetime.datetime.now().astimezone().tzname() or "UTC"
+
+
+def describe_timezone(timezone_name: str = "") -> str:
+    """``Europe/Berlin (CEST, UTC+02:00)`` — the zone plus its offset right now.
+
+    An empty ``timezone_name`` describes the server's own timezone and says so.
+    """
+    if timezone_name:
+        try:
+            tz = ZoneInfo(validate_timezone_name(timezone_name))
+        except ValueError:
+            return f"{timezone_name} (unknown timezone)"
+        name = timezone_name
+    else:
+        tz = get_local_timezone()
+        name = get_local_timezone_name()
+
+    now = datetime.datetime.now(tz)
+    abbreviation = now.tzname() or ""
+    offset = now.strftime("%z")
+    details = []
+    # "Etc/UTC (UTC, UTC+00:00)" says the same thing three times; keep the
+    # abbreviation only when the zone name does not already carry it.
+    if abbreviation and not name.split("/")[-1].startswith(abbreviation):
+        details.append(abbreviation)
+    details.append(f"UTC{offset[:3]}:{offset[3:]}" if offset else "UTC+00:00")
+    if not timezone_name:
+        details.append("server local time")
+    return f"{name} ({', '.join(details)})"
+
+
+def get_server_locale_name() -> str:
+    """The server's own locale as ``de_DE``, or empty when it has none set.
+
+    Only informational: the bot never applies it — date/time names come from
+    :data:`LOCALIZED_DATE_NAMES` and only when a config sets a locale.
+    """
+    candidates = list(locale_module.getlocale(locale_module.LC_TIME) or ())
+    candidates.append(os.environ.get("LC_ALL", ""))
+    candidates.append(os.environ.get("LC_TIME", ""))
+    candidates.append(os.environ.get("LANG", ""))
+    for candidate in candidates:
+        candidate = (candidate or "").split(".", 1)[0].strip()
+        if not candidate or candidate in ("C", "POSIX"):
+            continue
+        try:
+            return normalize_locale_name(candidate)
+        except ValueError:
+            continue
+    return ""
+
+
+def get_config_timezone(config: dict | None, timezone_name: str = "", local_tz: datetime.tzinfo | None = None) -> datetime.tzinfo:
+    if local_tz is not None:
+        return local_tz
+
+    configured_timezone = timezone_name or (config or {}).get("datetime_timezone", "")
+    if configured_timezone:
+        try:
+            return ZoneInfo(validate_timezone_name(configured_timezone))
+        except ValueError as e:
+            log_warning("Ignoring invalid datetime timezone in configuration:", e)
+
+    return get_local_timezone()
+
+
+def get_config_locale(config: dict | None, locale_name: str = "") -> str:
+    configured_locale = locale_name or (config or {}).get("datetime_locale", "")
+    if not configured_locale:
+        # Instance-wide fallback (HUTBOT_DEFAULT_DATETIME_LOCALE), empty unless set.
+        return state.default_datetime_locale
+    try:
+        return normalize_locale_name(configured_locale)
+    except ValueError as e:
+        log_warning("Ignoring invalid datetime locale in configuration:", e)
+        return state.default_datetime_locale
+
+
+def resolve_default_locale(value: str) -> str:
+    """Normalize the instance-wide default locale, warning about a bad value."""
+    value = (value or "").strip()
+    if not value:
+        return ""
+    try:
+        return normalize_locale_name(value)
+    except ValueError as e:
+        log_error("Ignoring invalid HUTBOT_DEFAULT_DATETIME_LOCALE:", e)
+        return ""
+
+
+GO_LAYOUT_TOKENS = [
+    ("Monday", "%A"),
+    ("January", "%B"),
+    ("Mon", "%a"),
+    ("Jan", "%b"),
+    ("2006", "%Y"),
+    ("Z07:00", "%z"),
+    ("Z0700", "%z"),
+    ("-07:00", "%z"),
+    ("-0700", "%z"),
+    ("15", "%H"),
+    ("03", "%I"),
+    ("04", "%M"),
+    ("05", "%S"),
+    ("02", "%d"),
+    ("01", "%m"),
+    ("06", "%y"),
+    ("PM", "%p"),
+    ("pm", "%p"),
+    ("MST", "%Z"),
+]
+
+
+def go_layout_to_strftime(layout: str) -> str:
+    converted = []
+    i = 0
+    while i < len(layout):
+        for token, directive in GO_LAYOUT_TOKENS:
+            if layout.startswith(token, i):
+                converted.append(directive)
+                i += len(token)
+                break
+        else:
+            converted.append(layout[i])
+            i += 1
+    return "".join(converted)
+
+
+LOCALIZED_DATE_NAMES = {
+    "de": {
+        "Monday": "Montag",
+        "Tuesday": "Dienstag",
+        "Wednesday": "Mittwoch",
+        "Thursday": "Donnerstag",
+        "Friday": "Freitag",
+        "Saturday": "Samstag",
+        "Sunday": "Sonntag",
+        "Mon": "Mo",
+        "Tue": "Di",
+        "Wed": "Mi",
+        "Thu": "Do",
+        "Fri": "Fr",
+        "Sat": "Sa",
+        "Sun": "So",
+        "January": "Januar",
+        "February": "Februar",
+        "March": "Maerz",
+        "April": "April",
+        "May": "Mai",
+        "June": "Juni",
+        "July": "Juli",
+        "August": "August",
+        "September": "September",
+        "October": "Oktober",
+        "November": "November",
+        "December": "Dezember",
+        "Jan": "Jan",
+        "Feb": "Feb",
+        "Mar": "Mrz",
+        "Apr": "Apr",
+        "Jun": "Jun",
+        "Jul": "Jul",
+        "Aug": "Aug",
+        "Sep": "Sep",
+        "Oct": "Okt",
+        "Nov": "Nov",
+        "Dec": "Dez",
+    }
+}
+
+
+def localize_formatted_datetime(value: str, locale_name: str) -> str:
+    if not locale_name:
+        return value
+
+    language = locale_name.split("_", 1)[0].lower()
+    replacements = LOCALIZED_DATE_NAMES.get(language)
+    if not replacements:
+        return value
+
+    for source in sorted(replacements, key=len, reverse=True):
+        value = re.sub(rf"\b{re.escape(source)}\b", replacements[source], value)
+    return value
+
+
+def describe_locale(locale_name: str = "") -> str:
+    """What day/month names a config actually gets, and why.
+
+    Takes the config's own locale; empty falls back to the instance default
+    (HUTBOT_DEFAULT_DATETIME_LOCALE) and, failing that, to English. The server's
+    own locale is never applied and is only named for orientation. A locale
+    without a translation table (only `de` has one) also ends up English.
+    """
+    notes = []
+    if locale_name:
+        try:
+            effective = normalize_locale_name(locale_name)
+        except ValueError:
+            return f"{locale_name} (invalid locale, English names)"
+    elif state.default_datetime_locale:
+        effective = state.default_datetime_locale
+        notes.append("instance default")
+    else:
+        server_locale = get_server_locale_name()
+        if server_locale:
+            return f"English names (server locale {server_locale} not applied)"
+        return "English names (no server locale set)"
+
+    if effective.split("_", 1)[0].lower() not in LOCALIZED_DATE_NAMES:
+        notes.append("no translations, English names")
+    return f"{effective} ({', '.join(notes)})" if notes else effective
+
+
+def parse_opsgenie_datetime(value: str) -> datetime.datetime | None:
+    if not value:
+        return None
+    try:
+        parsed = datetime.datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError:
+        return None
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=datetime.timezone.utc)
+    return parsed
+
+
+def parse_slack_timestamp(value: str) -> datetime.datetime | None:
+    """Slack message timestamps are epoch seconds, e.g. "1786453297.645799"."""
+    if not value:
+        return None
+    try:
+        return datetime.datetime.fromtimestamp(float(value), datetime.timezone.utc)
+    except (TypeError, ValueError, OSError, OverflowError):
+        return None
+
+
+def format_datetime_value(
+    value: str,
+    part: str = "datetime",
+    config: dict | None = None,
+    args: dict[str, str] | None = None,
+    local_tz: datetime.tzinfo | None = None,
+) -> str:
+    parsed = parse_opsgenie_datetime(value)
+    if not parsed:
+        return UNKNOWN_ONCALL_PERIOD_PLACEHOLDER
+    return render_datetime(parsed, part, config, args, local_tz)
+
+
+def render_datetime(
+    parsed: datetime.datetime,
+    part: str = "datetime",
+    config: dict | None = None,
+    args: dict[str, str] | None = None,
+    local_tz: datetime.tzinfo | None = None,
+) -> str:
+    """Format an instant with the config's date/time format, timezone, and locale."""
+    args = args or {}
+    timezone = get_config_timezone(config, args.get("tz", ""), local_tz)
+    local_time = parsed.astimezone(timezone)
+
+    date_format = (config or {}).get("date_format") or DEFAULT_DATE_FORMAT
+    time_format = (config or {}).get("time_format") or DEFAULT_TIME_FORMAT
+    default_format = {
+        "date": date_format,
+        "time": time_format,
+        "datetime": f"{date_format} {time_format}",
+    }.get(part, f"{date_format} {time_format}")
+
+    fmt = args.get("fmt") or default_format
+    if "%" not in fmt:
+        fmt = go_layout_to_strftime(fmt)
+
+    locale_name = get_config_locale(config, args.get("lc", ""))
+    return localize_formatted_datetime(local_time.strftime(fmt), locale_name)
+
+
+def format_timestamp_value(value: str, part: str = "datetime", config: dict | None = None, args: dict[str, str] | None = None) -> str:
+    """Render a Slack message timestamp for `{{date}}` / `{{time}}` / `{{datetime}}`."""
+    parsed = parse_slack_timestamp(value)
+    if not parsed:
+        return ""
+    return render_datetime(parsed, part, config, args)
+
+
+def format_opsgenie_template_datetime(value: str, variable: str, config: dict | None = None, args: dict[str, str] | None = None) -> str:
+    part = variable.rsplit("_", 1)[-1]
+    return format_datetime_value(value, part, config, args)
+
+
+def format_opsgenie_datetime(value: str, local_tz: datetime.tzinfo | None = None) -> str:
+    return format_datetime_value(value, "datetime", local_tz=local_tz)
diff --git a/hutbot/messaging.py b/hutbot/messaging.py
new file mode 100644
index 0000000..774bc8e
--- /dev/null
+++ b/hutbot/messaging.py
@@ -0,0 +1,314 @@
+"""Low-level Slack message posting + Slack-text cleaning / mention resolution."""
+
+import re
+import asyncio
+
+from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
+
+from employee_list import log_error, log_warning
+
+from . import slackcache
+from . import state
+from .constants import ID_PATTERN, MENTION_PATTERN, SUPPORTED_TEMPLATE_VARIABLES
+from .models import Channel, User
+from .textutil import log_debug
+
+
+# Slack cuts a message this long into several, wherever the break happens to fall —
+# mid code fence included. Anything longer has to be split by us, on our own lines.
+SLACK_MESSAGE_CHARACTER_LIMIT = 3800
+
+
+def pack_message_chunks(parts: list[str], separator: str = "\n\n", limit: int = SLACK_MESSAGE_CHARACTER_LIMIT) -> list[str]:
+    """Greedily group `parts` into messages no longer than `limit`.
+
+    A single part longer than the limit is kept whole — splitting it would break
+    whatever made it one part (a code block, one config's settings).
+    """
+    chunks: list[str] = []
+    current = ""
+    for part in parts:
+        candidate = f"{current}{separator}{part}" if current else part
+        if current and len(candidate) > limit:
+            chunks.append(current)
+            current = part
+        else:
+            current = candidate
+    if current:
+        chunks.append(current)
+    return chunks
+
+
+async def send_message(app: AsyncApp, channel: Channel, user: User, text: str, thread_ts: str = "") -> None:
+    log_debug(channel, f"Attempting to send message to #{channel.name}, user @{user.name}: {text.replace(chr(10), '\\n')}")
+    retries = 3
+    delay = 1
+    for attempt in range(retries):
+        try:
+            if thread_ts:
+                await app.client.chat_postMessage(
+                    channel=channel.id,
+                    thread_ts=thread_ts,
+                    text=text,
+                    mrkdwn=True
+                )
+            else:
+                await app.client.chat_postEphemeral(
+                    channel=channel.id,
+                    user=user.id,
+                    text=text,
+                    mrkdwn=True
+                )
+            log_debug(channel, f"Successfully sent message to #{channel.name}, user @{user.name}")
+            return  # Exit if successful
+        except SlackApiError as e:
+            if attempt < retries - 1:
+                log_warning(f"Failed to send message in channel #{channel.name}, user @{user.name}, retrying in {delay} seconds ({attempt + 1}/{retries})...", e)
+                await asyncio.sleep(delay)
+                delay *= 2  # Exponential backoff
+            else:
+                log_error(f"Failed to send message in channel #{channel.name}, user @{user.name} after {retries} attempts:", e)
+
+
+async def _post_message(app: AsyncApp, channel_id: str, text: str, blocks: list | None, thread_ts: str = "") -> dict | None:
+    kwargs = {"channel": channel_id, "text": text, "mrkdwn": True}
+    if blocks:
+        kwargs["blocks"] = blocks
+    if thread_ts:
+        kwargs["thread_ts"] = thread_ts
+    retries = 3
+    delay = 1
+    for attempt in range(retries):
+        try:
+            response = await app.client.chat_postMessage(**kwargs)
+            return {"channel": channel_id, "ts": response.get("ts")}
+        except SlackApiError as e:
+            if attempt < retries - 1:
+                log_warning(f"Failed to post message to {channel_id}, retrying in {delay} seconds ({attempt + 1}/{retries})...", e)
+                await asyncio.sleep(delay)
+                delay *= 2
+            else:
+                log_error(f"Failed to post message to {channel_id} after {retries} attempts:", e)
+                return None
+
+
+async def replace_ids(app: AsyncApp, channel: Channel | None, text: str) -> str:
+    for match in ID_PATTERN.finditer(text):
+        full_match = match.group(0)
+        log_debug(channel, f"Found ID match: {full_match}...")
+        id = match.group(1)
+        handled = False
+        if id and id[0] == '@':
+            user_id = id[1:]
+            log_debug(channel, f"Looking up user with ID {user_id}...")
+            user = await slackcache.get_user_by_id(app, user_id)
+            if user.id:
+                log_debug(channel, f"Found user {user}")
+                text = text.replace(full_match, user.real_name)
+                handled = True
+        elif id and id[0] == '#':
+            ch_id = id[1:]
+            log_debug(channel, f"Looking up channel with ID {ch_id}...")
+            ch = await slackcache.get_channel_by_id(app, ch_id)
+            if ch.id:
+                log_debug(channel, f"Found channel {ch}")
+                text = text.replace(full_match, f"#{ch.name}")
+                handled = True
+        elif id and id.startswith('!subteam^'):
+            ug_id = id[9:]
+            log_debug(channel, f"Looking up usergroup with ID {ug_id}...")
+            ug = await slackcache.get_usergroup_by_id(app, ug_id)
+            if ug.id:
+                log_debug(channel, f"Found usergroup {ug}")
+                text = text.replace(full_match, f"@{ug.handle}")
+                handled = True
+        if not handled:
+            alias = match.group(3)
+            if alias:
+                log_debug(channel, f"Fallback, replacing {full_match} with alias {alias}.")
+                text = text.replace(full_match, alias)
+            else:
+                log_debug(channel, f"Fallback, replacing {full_match} with {id}.")
+                text = text.replace(full_match, id)
+    return text
+
+
+async def clean_slack_text(app: AsyncApp, channel: Channel, text: str):
+    # replace all kinds of <@ID> mentions
+    text = await replace_ids(app, channel, text)
+
+    # unescape any escaped formatting characters (like \*, \_, etc.)
+    text = re.sub(r'\\([*_~`])', r'\1', text)
+
+    # process all <...> elements to extract display text or URL
+    def replace_link(match):
+        parts = match.group(1).split('|', 1)
+        if len(parts) == 1 and parts[0].startswith('http'):
+            return "[URL]"
+        return parts[1] if len(parts) > 1 and len(parts[1]) > 0 else parts[0]
+
+    text = re.sub(r'<([^>]+)>', replace_link, text)
+
+    # remove all remaining formatting characters and new lines
+    text = re.sub(r'[*_~`]', '', text).replace('\n', ' ')
+
+    # reduce duplicate spaces and trim
+    text = re.sub(r'\s{2,}', ' ', text).strip()
+
+    return text
+
+
+async def process_mentions(app: AsyncApp, message: str) -> tuple[bool, str, str]:
+    # Regular expression to find @username patterns
+    matches = MENTION_PATTERN.findall(message)
+    if matches:
+        for user_match in matches:
+            user = await slackcache.get_user_by_name(app, user_match)
+            if user.id:
+                message = message.replace(f"@{user_match}", f"<@{user.id}>")
+            else:
+                log_error(f"Invalid *reply message*: username `{user_match}` not found")
+                return False, f"{user_match} not found", ""
+    return True, "", message
+
+
+async def send_news_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
+    command = state.slash_command
+    name = state.bot_name
+    version = state.version
+    mention = f"@{state.bot_user_name}"
+    update_text = (
+        f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what's :new::\n\n"
+        "> :robot_face: *Triggers, actions & buttons*\n>\n"
+        f"> Rules can now run on a `cron` schedule, DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `{command} help`.\n>\n"
+        "> :calendar: *OpsGenie date/time template variables and defaults*\n>\n"
+        f"> OpsGenie templates can now include current and next on-call start/end dates, times, and datetimes. Use `{command} [config] set datetime-format \"<date>\" \"<time>\" [<timezone> <locale>]` to set the defaults.\n>\n"
+        "> :pencil: *Customize reply messages with `{{placeholders}}`*\n>\n"
+        "> That means " + name + " can include details like the `{{user}}`, `{{team}}`, `{{channel}}` or `{{wait_minutes}}`, or even mention the person who is currently on-call `{{opsgenie_current_user}}` in the reply message :exploding_head:.\n>\n"
+        "> :sparkles: Just configure an Opsgenie schedule and you are good to go.\n>\n"
+        "> :list-item: *List available Opsgenie schedules*\n>\n"
+        "> :telephone_receiver: *Print the current on-call user*\n"
+        f"> Use `{command} [config] on-call [schedule name]` to get the current OpsGenie on-call user as a Slack mention.\n>\n"
+        "> :test_tube: *Preview your configured reply*\n"
+        f"> Use `{command} [config] test` or mention me with `{mention} [config] test <message>` to test reply templates and variables.\n>\n"
+        f"> :bug: *{name} now ONLY cancels replying, when the _expected_ team(s) have already replied* :lightbulb:\n>\n"
+        "> Issue was:\n>\n"
+        "> 1. Team *A* sends a message intended for Team *B*\n"
+        "> 2. Someone else from Team *A* adds additional information\n"
+        f"> 3. {name} cancels the reply and does NOT remind Team *B* anymore :fail:\n"
+    )
+    await send_message(app, channel, user, update_text, thread_ts)
+
+
+async def send_help_message(app: AsyncApp, channel: Channel, user: User, thread_ts: str = "") -> None:
+    supported_template_variables = ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
+    command = state.slash_command
+    name = state.bot_name
+    version = state.version
+    mention = f"@{state.bot_user_name}"
+    # Grouped in the order a rule runs — configs, then trigger, condition, what it
+    # matches, timing, the message it sends, buttons, alerting, formatting — with
+    # lookups and meta commands last. Same grouping as `show config` prints.
+    command_groups = [
+        ("Configurations", [
+            (f"{command} show config", "Show all configurations."),
+            (f"{command} [config] enable", "Enable this config."),
+            (f"{command} [config] disable", "Disable this config."),
+            (f"{command} delete config <name>", "Delete a configuration."),
+        ]),
+        ("Trigger", [
+            (f"{command} [config] set trigger <message|manual>", "Set how the rule starts."),
+            (f"{command} [config] set trigger cron \"<expr>\"", "Fire on a cron schedule, e.g. 0 9 * * 1-5."),
+        ]),
+        ("Condition", [
+            (f"{command} [config] set condition <none|outlook>", "Gate a cron trigger on a condition."),
+            (f"{command} [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
+            (f"{command} [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
+            (f"{command} [config] enable negate", "Invert the condition (e.g. no matching event)."),
+            (f"{command} [config] disable negate", "Stop inverting the condition."),
+        ]),
+        ("What to react to", [
+            (f"{command} [config] set pattern \"<regex>\" [0|1]", "Set message pattern; 1 means case sensitive."),
+            (f"{command} [config] clear pattern", "React to every message again."),
+            (f"{command} [config] add included-team <team>", "Add an allowed team."),
+            (f"{command} [config] clear included-teams", "Clear allowed teams."),
+            (f"{command} [config] add excluded-team <team>", "Add an ignored team."),
+            (f"{command} [config] clear excluded-teams", "Clear ignored teams."),
+            (f"{command} [config] enable bots", "Respond to bot messages."),
+            (f"{command} [config] disable bots", "Ignore bot messages."),
+        ]),
+        ("When to react", [
+            (f"{command} [config] set wait-time <minutes>", "Set reminder delay."),
+            (f"{command} [config] enable only-work-days", "Respond only on work days."),
+            (f"{command} [config] disable only-work-days", "Respond on all days."),
+            (f"{command} [config] set work-hours <start> <end>", "Set active hours, e.g. 9:00 17:00."),
+            (f"{command} [config] clear work-hours", "React at any hour."),
+        ]),
+        ("Message and action", [
+            (f"{command} [config] set message \"<reply message>\"", "Set reminder message."),
+            (f"{command} [config] set action reply", "Reply in this channel (the default)."),
+            (f"{command} [config] set action post-channel <#channel>", "Post to another channel."),
+            (f"{command} [config] set action dm-user <@user>", "DM a single user."),
+            (f"{command} [config] set action group-dm <@usergroup>", "Open one group DM with a user group."),
+        ]),
+        ("Buttons", [
+            (f"{command} [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
+            (f"{command} [config] add button \"<label>\" ack [text]", "Button marks it handled, posting [text] if given."),
+            (f"{command} [config] add button \"<label>\" delay <minutes>", "Button postpones the escalation; buttons stay."),
+            (f"{command} [config] clear buttons", "Remove all buttons."),
+            (f"{command} [config] set escalation <minutes> button \"<label>\"", "Auto-press that button if nobody does in time."),
+            (f"{command} [config] set escalation <minutes> config <config>", "Run that config if nobody presses in time."),
+            (f"{command} [config] clear escalation", "Never escalate; buttons stay open."),
+        ]),
+        ("OpsGenie", [
+            (f"{command} [config] enable opsgenie", "Enable OpsGenie alerts."),
+            (f"{command} [config] disable opsgenie", "Disable OpsGenie alerts."),
+            (f"{command} [config] set opsgenie-schedule <name>", "Set the OpsGenie schedule name."),
+            (f"{command} [config] set opsgenie-priority <P1-P5>", "Set the OpsGenie alert priority."),
+            (f"{command} [config] set opsgenie-message <text>", "Template for the alert text (default: the message)."),
+            (f"{command} [config] clear opsgenie-message", "Back to alerting with the message itself."),
+        ]),
+        ("Date and time", [
+            (f"{command} [config] set datetime-format \"<date>\" \"<time>\" [<tz> <locale>]", "Date/time output; <tz> also drives cron and work hours."),
+        ]),
+        ("Try it out and look things up", [
+            (f"{command} [config] run", "Run this configuration's action now."),
+            (f"{command} [config] test", "Preview configured reply."),
+            (f"{mention} [config] test <message>", "Preview reply with <message> as {{message}}."),
+            (f"{command} [config] on-call [opsgenie-schedule]", "Show current on-call user."),
+            (f"{command} list teams", "List available teams."),
+            (f"{command} list opsgenie-schedules", "List OpsGenie schedules."),
+            (f"{command} team of <@user>", "Show a user's team."),
+        ]),
+        ("Help", [
+            (f"{command} news", "Show what's new."),
+            (f"{command} help", "Show this help."),
+        ]),
+    ]
+    command_width = max(len(command) for _, rows in command_groups for command, _ in rows)
+    group_blocks = [
+        f"# {title}\n" + "\n".join(f"{command:<{command_width}}  {description}" for command, description in rows)
+        for title, rows in command_groups
+    ]
+    intro = (
+        f"Hi! :wave: I am *{name}* `{version}` :palm_up_hand::tophat: Here's what I can do:\n\n"
+        "*Show All Configurations:*\n"
+        f"> Either use the command `{command}` or just `{mention}` me.\n"
+        f"```{command} show config\n"
+        f"{mention} show config```\n"
+        f"Displays all configurations for `#{channel.name}`."
+    )
+    outro = (
+        "`[config]` is optional; omitted commands use `default`. The leading `set`/`add` is optional too.\n\n"
+        f"Supported reply variables: {supported_template_variables}."
+    )
+    # The command table alone is well past Slack's per-message limit, and Slack
+    # splits an oversized message wherever it happens to land — which cuts the code
+    # fence in half. Send it in chunks that each close their own fence.
+    command_messages = [
+        f"*Commands{'' if index == 0 else ' (continued)'}:*\n```\n{chunk}\n```"
+        for index, chunk in enumerate(pack_message_chunks(group_blocks, limit=SLACK_MESSAGE_CHARACTER_LIMIT - 200))
+    ]
+    for message in [intro, *command_messages, outro]:
+        await send_message(app, channel, user, message, thread_ts)
diff --git a/hutbot/models.py b/hutbot/models.py
new file mode 100644
index 0000000..4dd687c
--- /dev/null
+++ b/hutbot/models.py
@@ -0,0 +1,22 @@
+"""Data types shared across the package: namedtuples + template expression."""
+
+import collections
+from dataclasses import dataclass
+
+ScheduledReply = collections.namedtuple('ScheduledReply', ['task', 'user_id'])
+# `is_bot` defaults to False so the many four-field constructions stay valid.
+User = collections.namedtuple('User', ['id', 'name', 'real_name', 'team', 'is_bot'], defaults=(False,))
+Usergroup = collections.namedtuple('Usergroup', ['id', 'handle', 'name'])
+Channel = collections.namedtuple('Channel', ['id', 'name', 'configs'])
+OpsGeniePeriod = collections.namedtuple('OpsGeniePeriod', ['recipient_email', 'slack_user', 'start', 'end'])
+OpsGenieContext = collections.namedtuple('OpsGenieContext', ['schedule_name', 'current', 'next'])
+
+
+@dataclass(frozen=True)
+class TemplateExpression:
+    variable: str
+    args: dict[str, str]
+
+
+class TemplateExpressionError(ValueError):
+    pass
diff --git a/hutbot/opsgenie.py b/hutbot/opsgenie.py
new file mode 100644
index 0000000..a4ec4dd
--- /dev/null
+++ b/hutbot/opsgenie.py
@@ -0,0 +1,429 @@
+"""OpsGenie integration: on-call resolution, template variables, alerts, heartbeat."""
+
+import json
+import asyncio
+import datetime
+import urllib.parse
+
+import aiohttp
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log, log_error, log_warning
+
+from . import datetimefmt
+from . import slackcache
+from . import messaging
+from . import state
+from .constants import (
+    DEFAULT_CONFIG,
+    DEFAULT_OPSGENIE_PRIORITY,
+    bot_slug,
+    OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
+    OPSGENIE_PRIORITIES,
+    UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
+    UNKNOWN_NAME_ONCALL_PLACEHOLDER,
+    UNKNOWN_ONCALL_PERIOD_PLACEHOLDER,
+    UNKNOWN_OPSGENIE_SCHEDULE_PLACEHOLDER,
+    UNKNOWN_USER_ONCALL_PLACEHOLDER,
+)
+from .models import OpsGenieContext, OpsGeniePeriod, User
+from .textutil import log_debug
+
+
+def get_opsgenie_priority(config: dict | None) -> str:
+    priority = (config or {}).get('opsgenie_priority', DEFAULT_OPSGENIE_PRIORITY)
+    priority = priority.strip().upper() if isinstance(priority, str) else ""
+    return priority if priority in OPSGENIE_PRIORITIES else DEFAULT_OPSGENIE_PRIORITY
+
+
+def get_opsgenie_placeholder_variables(config: dict | None = None) -> dict[str, str]:
+    schedule_name = (config or {}).get("opsgenie_schedule_name", "").strip()
+    variables = {
+        "opsgenie_schedule_name": schedule_name or UNKNOWN_OPSGENIE_SCHEDULE_PLACEHOLDER,
+        "opsgenie_current_email": UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
+        "opsgenie_current_name": UNKNOWN_NAME_ONCALL_PLACEHOLDER,
+        "opsgenie_current_user": UNKNOWN_USER_ONCALL_PLACEHOLDER,
+        "opsgenie_next_email": UNKNOWN_EMAIL_ONCALL_PLACEHOLDER,
+        "opsgenie_next_name": UNKNOWN_NAME_ONCALL_PLACEHOLDER,
+        "opsgenie_next_user": UNKNOWN_USER_ONCALL_PLACEHOLDER,
+    }
+    for variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
+        variables[variable] = UNKNOWN_ONCALL_PERIOD_PLACEHOLDER
+        variables[f"__{variable}_raw"] = ""
+    return variables
+
+
+def fill_opsgenie_period_variables(variables: dict[str, str], config: dict, prefix: str, period: OpsGeniePeriod) -> None:
+    if not period.recipient_email:
+        return
+
+    variables[f"opsgenie_{prefix}_email"] = period.recipient_email
+    variables[f"opsgenie_{prefix}_name"] = period.recipient_email
+    if period.slack_user:
+        variables[f"opsgenie_{prefix}_user"] = f"<@{period.slack_user.id}>"
+        variables[f"opsgenie_{prefix}_name"] = period.slack_user.real_name if period.slack_user.real_name else period.slack_user.name
+
+    for bound, value in (("start", period.start), ("end", period.end)):
+        for part in ("date", "time", "datetime"):
+            variable = f"opsgenie_{prefix}_{bound}_{part}"
+            variables[f"__{variable}_raw"] = value or ""
+            variables[variable] = datetimefmt.format_opsgenie_template_datetime(value, variable, config)
+
+
+async def resolve_slack_user_for_opsgenie_recipient(app: AsyncApp, recipient_email: str) -> User | None:
+    slack_user = await slackcache.get_user_by_email(app, recipient_email)
+    if not slack_user.id:
+        log_warning(f"Failed to map OpsGenie recipient '{recipient_email}' to a Slack user.")
+        return None
+    return slack_user
+
+
+async def resolve_opsgenie_on_call(app: AsyncApp, opsgenie_token: str, schedule_name: str) -> tuple[str, User | None]:
+    schedule_name = schedule_name.strip()
+    if not opsgenie_token:
+        log_warning(f"Cannot resolve OpsGenie schedule '{schedule_name}': missing token.")
+        return "", None
+
+    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
+    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/on-calls"
+    headers = {
+        "Authorization": f"GenieKey {opsgenie_token}",
+    }
+    params = {
+        "scheduleIdentifierType": "name",
+        "flat": "true",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers, params=params) as response:
+                if response.status != 200:
+                    log_error(f"Failed to retrieve on-call recipients for OpsGenie schedule '{schedule_name}': {response.status}")
+                    return "", None
+                payload = await response.json()
+    except Exception as e:
+        log_error(f"Failed to retrieve on-call recipients for OpsGenie schedule '{schedule_name}':", e)
+        return "", None
+
+    recipients = payload.get("data", {}).get("onCallRecipients", [])
+    if not recipients:
+        log_warning(f"OpsGenie schedule '{schedule_name}' returned no current on-call recipients.")
+        return "", None
+
+    recipient_email = recipients[0].strip()
+    if not recipient_email:
+        return "", None
+
+    return recipient_email, await resolve_slack_user_for_opsgenie_recipient(app, recipient_email)
+
+
+def merge_opsgenie_periods(periods: list[dict], current_index: int) -> tuple[str, str]:
+    current_period = periods[current_index]
+    recipient_name = current_period.get("recipient", {}).get("name", "").strip().casefold()
+    merged_start = datetimefmt.parse_opsgenie_datetime(current_period.get("startDate", ""))
+    merged_end = datetimefmt.parse_opsgenie_datetime(current_period.get("endDate", ""))
+    if not recipient_name or merged_start is None or merged_end is None:
+        return current_period.get("startDate", ""), current_period.get("endDate", "")
+
+    first_period = current_period
+    last_period = current_period
+
+    for period in reversed(periods[:current_index]):
+        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
+        period_start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+        period_end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+        if period_recipient != recipient_name or period_start is None or period_end is None or period_end != merged_start:
+            break
+        merged_start = period_start
+        first_period = period
+
+    for period in periods[current_index + 1:]:
+        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
+        period_start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+        period_end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+        if period_recipient != recipient_name or period_start is None or period_end is None or period_start != merged_end:
+            break
+        merged_end = period_end
+        last_period = period
+
+    return first_period.get("startDate", ""), last_period.get("endDate", "")
+
+
+def merge_opsgenie_periods_forward(periods: list[dict], current_index: int) -> tuple[str, str]:
+    current_period = periods[current_index]
+    recipient_name = current_period.get("recipient", {}).get("name", "").strip().casefold()
+    merged_end = datetimefmt.parse_opsgenie_datetime(current_period.get("endDate", ""))
+    if not recipient_name or merged_end is None:
+        return current_period.get("startDate", ""), current_period.get("endDate", "")
+
+    last_period = current_period
+    for period in periods[current_index + 1:]:
+        period_recipient = period.get("recipient", {}).get("name", "").strip().casefold()
+        period_start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+        period_end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+        if period_recipient != recipient_name or period_start is None or period_end is None or period_start != merged_end:
+            break
+        merged_end = period_end
+        last_period = period
+
+    return current_period.get("startDate", ""), last_period.get("endDate", "")
+
+
+def find_opsgenie_on_call_period(data: dict, recipient_email: str, now: datetime.datetime | None = None) -> tuple[str, str]:
+    now = now or datetime.datetime.now(datetime.timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=datetime.timezone.utc)
+
+    rotations = []
+    for timeline_name in ("finalTimeline", "baseTimeline"):
+        rotations.extend(data.get(timeline_name, {}).get("rotations", []))
+
+    periods = [period for rotation in rotations for period in rotation.get("periods", [])]
+    if not periods:
+        return "", ""
+
+    recipient_email = recipient_email.casefold()
+
+    for rotation in rotations:
+        rotation_periods = sorted(
+            rotation.get("periods", []),
+            key=lambda period: datetimefmt.parse_opsgenie_datetime(period.get("startDate", "")) or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
+        )
+        for index, period in enumerate(rotation_periods):
+            start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+            end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+            is_current = start is not None and end is not None and start <= now < end
+            recipient_name = period.get("recipient", {}).get("name", "").strip().casefold()
+            matches_recipient = bool(recipient_email and recipient_name == recipient_email)
+            if is_current and matches_recipient:
+                return merge_opsgenie_periods(rotation_periods, index)
+
+    return "", ""
+
+
+def find_opsgenie_upcoming_on_call_period(data: dict, now: datetime.datetime | None = None) -> tuple[str, str, str]:
+    now = now or datetime.datetime.now(datetime.timezone.utc)
+    if now.tzinfo is None:
+        now = now.replace(tzinfo=datetime.timezone.utc)
+
+    best_candidate = None
+    for timeline_name in ("finalTimeline", "baseTimeline"):
+        rotations = data.get(timeline_name, {}).get("rotations", [])
+        for rotation in rotations:
+            rotation_periods = sorted(
+                rotation.get("periods", []),
+                key=lambda period: datetimefmt.parse_opsgenie_datetime(period.get("startDate", "")) or datetime.datetime.min.replace(tzinfo=datetime.timezone.utc),
+            )
+            threshold = now
+            include_threshold = False
+            for index, period in enumerate(rotation_periods):
+                start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+                end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+                if start is not None and end is not None and start <= now < end:
+                    _, merged_end = merge_opsgenie_periods(rotation_periods, index)
+                    threshold = datetimefmt.parse_opsgenie_datetime(merged_end) or end
+                    include_threshold = True
+                    break
+
+            for index, period in enumerate(rotation_periods):
+                start = datetimefmt.parse_opsgenie_datetime(period.get("startDate", ""))
+                end = datetimefmt.parse_opsgenie_datetime(period.get("endDate", ""))
+                recipient_email = period.get("recipient", {}).get("name", "").strip()
+                if start is None or end is None or not recipient_email:
+                    continue
+                if start < threshold or (start == threshold and not include_threshold):
+                    continue
+
+                candidate = (start, rotation_periods, index, recipient_email)
+                if best_candidate is None or candidate[0] < best_candidate[0]:
+                    best_candidate = candidate
+
+    if best_candidate is None:
+        return "", "", ""
+
+    _, rotation_periods, index, recipient_email = best_candidate
+    start, end = merge_opsgenie_periods_forward(rotation_periods, index)
+    return recipient_email, start, end
+
+
+async def resolve_opsgenie_on_call_period(opsgenie_token: str, schedule_name: str, recipient_email: str) -> tuple[str, str]:
+    schedule_name = schedule_name.strip()
+    if not opsgenie_token:
+        return "", ""
+
+    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
+    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/timeline"
+    headers = {
+        "Authorization": f"GenieKey {opsgenie_token}",
+    }
+    timeline_start = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=90)
+    params = {
+        "identifierType": "name",
+        "date": timeline_start.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "interval": "6",
+        "intervalUnit": "months",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers, params=params) as response:
+                if response.status != 200:
+                    log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}': {response.status}")
+                    return "", ""
+                payload = await response.json()
+    except Exception as e:
+        log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}':", e)
+        return "", ""
+
+    return find_opsgenie_on_call_period(payload.get("data", {}), recipient_email)
+
+
+async def resolve_opsgenie_upcoming_on_call_period(opsgenie_token: str, schedule_name: str) -> tuple[str, str, str]:
+    schedule_name = schedule_name.strip()
+    if not opsgenie_token:
+        return "", "", ""
+
+    encoded_schedule_name = urllib.parse.quote(schedule_name, safe="")
+    url = f"https://api.opsgenie.com/v2/schedules/{encoded_schedule_name}/timeline"
+    headers = {
+        "Authorization": f"GenieKey {opsgenie_token}",
+    }
+    timeline_start = datetime.datetime.now(datetime.timezone.utc) - datetime.timedelta(days=90)
+    params = {
+        "identifierType": "name",
+        "date": timeline_start.strftime("%Y-%m-%dT%H:%M:%SZ"),
+        "interval": "6",
+        "intervalUnit": "months",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers, params=params) as response:
+                if response.status != 200:
+                    log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}': {response.status}")
+                    return "", "", ""
+                payload = await response.json()
+    except Exception as e:
+        log_error(f"Failed to retrieve timeline for OpsGenie schedule '{schedule_name}':", e)
+        return "", "", ""
+
+    return find_opsgenie_upcoming_on_call_period(payload.get("data", {}))
+
+
+async def resolve_opsgenie_on_call_context(app: AsyncApp, opsgenie_token: str, schedule_name: str, include_next: bool = True) -> OpsGenieContext:
+    schedule_name = schedule_name.strip()
+    empty_period = OpsGeniePeriod("", None, "", "")
+    current_period = empty_period
+    next_period = empty_period
+
+    recipient_email, slack_user = await resolve_opsgenie_on_call(app, opsgenie_token, schedule_name)
+    if recipient_email:
+        start, end = await resolve_opsgenie_on_call_period(opsgenie_token, schedule_name, recipient_email)
+        current_period = OpsGeniePeriod(recipient_email, slack_user, start, end)
+
+    if include_next:
+        next_email, next_start, next_end = await resolve_opsgenie_upcoming_on_call_period(opsgenie_token, schedule_name)
+        next_slack_user = await resolve_slack_user_for_opsgenie_recipient(app, next_email) if next_email else None
+        next_period = OpsGeniePeriod(next_email, next_slack_user, next_start, next_end)
+
+    return OpsGenieContext(schedule_name, current_period, next_period)
+
+
+async def get_opsgenie_template_variables(app: AsyncApp, opsgenie_token: str, config: dict) -> dict[str, str]:
+    schedule_name = config.get("opsgenie_schedule_name", "").strip()
+    variables = get_opsgenie_placeholder_variables(config)
+    if not schedule_name:
+        return variables
+
+    context = await resolve_opsgenie_on_call_context(app, opsgenie_token, schedule_name, include_next=True)
+    fill_opsgenie_period_variables(variables, config, "current", context.current)
+    fill_opsgenie_period_variables(variables, config, "next", context.next)
+
+    return variables
+
+
+async def send_current_on_call(app: AsyncApp, opsgenie_token: str, channel, config_name: str, schedule_name: str, user, thread_ts: str = "") -> None:
+    config = channel.configs.get(config_name, DEFAULT_CONFIG.copy())
+    schedule_name = schedule_name.strip() or config.get("opsgenie_schedule_name", "").strip()
+    if not schedule_name:
+        await messaging.send_message(app, channel, user, f"No OpsGenie schedule configured. Use `{state.slash_command} [config] set opsgenie-schedule <name>` or `{state.slash_command} [config] on-call <schedule name>`.", thread_ts)
+        return
+    if not opsgenie_token:
+        await messaging.send_message(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
+        return
+
+    recipient_email, slack_user = await resolve_opsgenie_on_call(app, opsgenie_token, schedule_name)
+    if recipient_email:
+        start, end = await resolve_opsgenie_on_call_period(opsgenie_token, schedule_name, recipient_email)
+    else:
+        recipient_email, start, end = await resolve_opsgenie_upcoming_on_call_period(opsgenie_token, schedule_name)
+        if recipient_email:
+            slack_user = await resolve_slack_user_for_opsgenie_recipient(app, recipient_email)
+
+    if not recipient_email:
+        await messaging.send_message(app, channel, user, f"Failed to resolve on-call user for OpsGenie schedule `{schedule_name}`.", thread_ts)
+        return
+
+    mention = f"<@{slack_user.id}>" if slack_user else recipient_email
+    message = (
+        f"*Schedule*: `{schedule_name}`\n"
+        f"*On-call*: {mention}\n"
+        f"*Start*: `{datetimefmt.format_datetime_value(start, 'datetime', config)}`\n"
+        f"*End*: `{datetimefmt.format_datetime_value(end, 'datetime', config)}`"
+    )
+    await messaging.send_message(app, channel, user, message, thread_ts)
+
+
+async def post_opsgenie_alert(app: AsyncApp, opsgenie_token: str, channel, config: dict | None, user: User, text: str, ts: str, permalink: str) -> None:
+    log_debug(channel, f"> {text.replace(chr(10), '\\n')}")
+    text = await messaging.clean_slack_text(app, channel, text)
+    log_debug(channel, f"< {text}")
+    user_name = user.real_name if user.real_name else user.name
+    priority = get_opsgenie_priority(config)
+    url = 'https://api.opsgenie.com/v2/alerts'
+    headers = {
+        'Content-Type': 'application/json',
+        'Authorization': f'GenieKey {opsgenie_token}'
+    }
+    # The alias is OpsGenie's dedup key, so it uses the slug rather than the
+    # display name — that also keeps a dev instance from deduping against prod.
+    slug = bot_slug(state.bot_name)
+    async with aiohttp.ClientSession() as session:
+        try:
+            data = {
+                "message": f"#{channel.name}: {text}",
+                "alias": f"{slug}: {user_name} in #{channel.name} {ts}",
+                "description": f"{user_name} in #{channel.name}: {text}",
+                "tags": [state.bot_name],
+                "details": {
+                    "channel": f"#{channel.name}",
+                    "sender": user_name,
+                    "bot": slug,
+                    "permalink": permalink,
+                },
+                "priority": priority,
+            }
+            async with session.post(url, headers=headers, data=json.dumps(data)) as response:
+                if response.status != 202:
+                    log_error(f"Failed to send alert for message {ts} in channel #{channel.name}, user @{user.name}: {response.status}")
+                else:
+                    log(f"Successfully sent OpsGenie alert for message {ts} in channel #{channel.name}, user @{user.name} with status code {response.status}")
+        except Exception as e:
+            log_error(f"Failed to send alert for message {ts} in channel #{channel.name}, user @{user.name}:", e)
+
+
+async def send_heartbeat(opsgenie_token: str, opsgenie_heartbeat_name: str) -> None:
+    url = 'https://api.opsgenie.com/v2/heartbeats/' + opsgenie_heartbeat_name + '/ping'
+    headers = {
+        'Authorization': f'GenieKey {opsgenie_token}'
+    }
+    log(f"Starting to send heartbeat to {url}...")
+    async with aiohttp.ClientSession() as session:
+        while True:
+            try:
+                async with session.get(url, headers=headers) as response:
+                    if response.status != 202:
+                        log_error(f"Failed to send heartbeat: {response.status}")
+            except Exception as e:
+                log_error("Exception while sending heartbeat:", e)
+            await asyncio.sleep(60)
diff --git a/hutbot/persistence.py b/hutbot/persistence.py
new file mode 100644
index 0000000..6d85d4f
--- /dev/null
+++ b/hutbot/persistence.py
@@ -0,0 +1,152 @@
+"""Load/save of the configuration and the scheduled-reply / button-state caches.
+
+File paths come from ``constants`` (read qualified so tests can patch them).
+"""
+
+import json
+
+import aiofiles
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log, log_error, log_warning
+
+from . import state
+from . import constants
+from .buttonutil import normalize_button
+
+
+async def migrate_and_apply_defaults(app: AsyncApp, config: dict) -> dict:
+    for channel_id, channel_data in config.items():
+        # Migration for old format
+        # old format: "C1234": { "wait_time": 60, ... }
+        # new format: "C1234": { "default": { "wait_time": 60, ... } }
+        # A nested configuration may legitimately use a field name as its
+        # configuration name (for example, ``trigger`` or ``action``). New
+        # fields added to DEFAULT_CONFIG must not make those existing configs
+        # look like the legacy flat format. Flat fields hold scalar/list
+        # values; nested configuration names hold dictionaries.
+        is_flat_config = any(
+            key in constants.DEFAULT_CONFIG and not isinstance(value, dict)
+            for key, value in channel_data.items()
+        )
+        if is_flat_config:
+            # This looks like an old, flat config. Let's wrap it.
+            log(f"Migrating old configuration for channel {channel_id}")
+            channel_data = {constants.DEFAULT_CONFIG_NAME: channel_data}
+            config[channel_id] = channel_data
+
+        for config_name, single_config in channel_data.items():
+            for key, value in constants.DEFAULT_CONFIG.items():
+                if key not in single_config:
+                    single_config[key] = value
+            # `forward_channel` was replaced by the `post_channel` action. Drop it
+            # instead of silently keeping a field nothing reads any more.
+            legacy_forward_channel = single_config.pop('forward_channel', '')
+            if legacy_forward_channel:
+                log_warning(
+                    f"Dropping the forward channel {legacy_forward_channel} of config '{config_name}' in channel {channel_id}. "
+                    f"To keep forwarding, add a second config with `set trigger message`, "
+                    f"`set action post-channel <#{legacy_forward_channel}>` and a message using {{{{message_link}}}}."
+                )
+            # Crons now fire in the config's date/time timezone. Carry a separate
+            # schedule timezone over so the cron keeps its wall-clock time; if the
+            # two disagree, the date/time one wins and the cron shifts.
+            legacy_schedule_timezone = single_config.pop('schedule_timezone', '')
+            if legacy_schedule_timezone:
+                datetime_timezone = single_config.get('datetime_timezone') or ''
+                if not datetime_timezone:
+                    single_config['datetime_timezone'] = legacy_schedule_timezone
+                    log_warning(
+                        f"Config '{config_name}' in channel {channel_id}: moved the schedule timezone "
+                        f"{legacy_schedule_timezone} to the date/time timezone, which the cron now uses."
+                    )
+                elif datetime_timezone != legacy_schedule_timezone:
+                    log_warning(
+                        f"Config '{config_name}' in channel {channel_id}: dropping the schedule timezone "
+                        f"{legacy_schedule_timezone}; its cron now fires in {datetime_timezone}."
+                    )
+            # Keep buttons to {label, action, value} and drop anything unusable.
+            buttons = single_config.get('buttons')
+            if isinstance(buttons, list):
+                normalized = []
+                for button in buttons:
+                    if not isinstance(button, dict):
+                        continue
+                    action, value = normalize_button(button)
+                    normalized.append({'label': button.get('label', ''), 'action': action, 'value': value})
+                single_config['buttons'] = normalized
+    return config
+
+
+async def load_configuration(app: AsyncApp) -> None:
+    try:
+        async with aiofiles.open(constants.CONFIG_FILE_NAME, 'r') as f:
+            content = await f.read()
+            loaded_config = json.loads(content)
+            state.channel_config = await migrate_and_apply_defaults(app, loaded_config)
+            log("Configuration loaded from disk.")
+    except FileNotFoundError:
+        log_warning("No configuration file found. Using default settings.")
+        state.channel_config = {}
+    except json.JSONDecodeError as e:
+        log_error("Failed to decode JSON configuration:", e)
+        state.channel_config = {}
+
+
+async def save_configuration() -> None:
+    try:
+        async with aiofiles.open(constants.CONFIG_FILE_NAME, 'w') as f:
+            content = json.dumps(state.channel_config, indent=2)
+            await f.write(content)
+    except Exception as e:
+        log_error("Failed to save configuration:", e)
+
+
+async def load_replies_cache() -> None:
+    try:
+        async with aiofiles.open(constants.SCHEDULED_REPLIES_CACHE_FILE, 'r') as f:
+            content = await f.read()
+            entries = json.loads(content)
+            state._scheduled_replies_cache.clear()
+            state._scheduled_replies_cache.update({
+                (e['channel_id'], e['ts'], e['config_name']): e
+                for e in entries
+            })
+            log(f"Loaded {len(state._scheduled_replies_cache)} pending scheduled replies from cache.")
+    except FileNotFoundError:
+        state._scheduled_replies_cache.clear()
+    except Exception as e:
+        log_error("Failed to load scheduled replies cache:", e)
+        state._scheduled_replies_cache.clear()
+
+
+async def flush_replies_cache() -> None:
+    try:
+        async with aiofiles.open(constants.SCHEDULED_REPLIES_CACHE_FILE, 'w') as f:
+            await f.write(json.dumps(list(state._scheduled_replies_cache.values()), indent=2))
+    except Exception as e:
+        log_error("Failed to flush scheduled replies cache:", e)
+
+
+async def load_button_cache() -> None:
+    try:
+        async with aiofiles.open(constants.BUTTON_CACHE_FILE, 'r') as f:
+            entries = json.loads(await f.read())
+            state._button_states_cache.clear()
+            state._button_states_cache.update({
+                (e['posted_channel_id'], e['message_ts']): e for e in entries
+            })
+            log(f"Loaded {len(state._button_states_cache)} pending button states from cache.")
+    except FileNotFoundError:
+        state._button_states_cache.clear()
+    except Exception as e:
+        log_error("Failed to load button states cache:", e)
+        state._button_states_cache.clear()
+
+
+async def flush_button_cache() -> None:
+    try:
+        async with aiofiles.open(constants.BUTTON_CACHE_FILE, 'w') as f:
+            await f.write(json.dumps(list(state._button_states_cache.values()), indent=2))
+    except Exception as e:
+        log_error("Failed to flush button states cache:", e)
diff --git a/hutbot/routing.py b/hutbot/routing.py
new file mode 100644
index 0000000..748df0a
--- /dev/null
+++ b/hutbot/routing.py
@@ -0,0 +1,347 @@
+"""Inbound Slack event routing, message handlers, and handler registration."""
+
+import re
+import json
+import asyncio
+import datetime
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log
+
+from . import state
+from . import slackcache
+from . import datetimefmt
+from . import scheduling
+from . import persistence
+from . import buttons
+from . import commands
+from . import messaging
+from .constants import (
+    BUTTON_ACTION_PREFIX,
+    DISABLED_REASON_REMOVED,
+    IGNORED_MESSAGE_SUBTYPES,
+    TRIGGER_MESSAGE,
+)
+from .models import ScheduledReply
+from .textutil import extract_message_text, log_debug
+
+
+def is_command(text: str) -> bool:
+    return f"<@{state.bot_user_id}>" in text
+
+
+async def route_message(app: AsyncApp, opsgenie_token: str, event: dict) -> None:
+    subtype = event.get('subtype')
+    previous_message = event.get('previous_message', {})
+    channel_id = event.get('channel', '')
+    user_id = event.get('user', '')
+    bot_id = event.get('bot_id', '')
+    ts = event.get('ts', '')
+    thread_ts = event.get('thread_ts', '')
+    text = extract_message_text(event)
+
+    channel = await slackcache.get_channel_by_id(app, channel_id)
+    log_debug(channel, f"Received message event from #{channel.name}: {json.dumps(event)}")
+
+    # Ignore messages from the bot itself
+    if user_id == state.bot_user_id or bot_id == state.bot_user_id:
+        log(f"Ignoring message from the bot from channel #{channel.name}.")
+        return
+
+    if subtype in IGNORED_MESSAGE_SUBTYPES:
+        log(f"Ignoring message with subtype '{subtype}' for channel #{channel.name}.")
+        return
+
+    # An app posting through its bot user sends both `user` and `bot_id`, so the
+    # presence of `user` says nothing about whether a human wrote this.
+    actor_is_bot = bool(bot_id) or subtype == 'bot_message'
+    user = None
+    if user_id:
+        user = await slackcache.get_user_by_id(app, user_id)
+        actor_is_bot = actor_is_bot or user_id == 'USLACKBOT' or bool(getattr(user, 'is_bot', False))
+    elif bot_id and (thread_ts or any(c.get('include_bots', False) for c in channel.configs.values())):
+        user = await slackcache.get_user_by_id(app, bot_id)
+
+    if subtype == 'message_deleted' and previous_message:
+        # deleted message
+        previous_user = await slackcache.get_user_by_id(app, previous_message.get('user'))
+        await handle_message_deletion(app, channel, previous_user, previous_message.get('ts'))
+    elif user and is_command(text):
+        # command
+        await commands.process_command(app, text, channel, user, ts, opsgenie_token, allow_test_message=True, command_ts=ts)
+    elif user and thread_ts:
+        # thread
+        await handle_thread_response(app, channel, user, thread_ts, actor_is_bot)
+    elif user and ts:
+        # channel message
+        await handle_channel_message(app, opsgenie_token, channel, user, text, ts, actor_is_bot)
+
+
+def user_matches_actor_criteria(config: dict | None, user, actor_is_bot: bool = False) -> bool:
+    if not config:
+        return False
+
+    if actor_is_bot and not config.get('include_bots', False):
+        return False
+
+    included_teams = config.get('included_teams', [])
+    if included_teams and user.team not in included_teams:
+        return False
+
+    excluded_teams = config.get('excluded_teams', [])
+    if excluded_teams and user.team in excluded_teams:
+        return False
+
+    return True
+
+
+def get_actor_mismatch_reason(config: dict | None, user, actor_is_bot: bool = False) -> str:
+    if not config:
+        return "the configuration no longer exists"
+    if actor_is_bot and not config.get('include_bots', False):
+        return "bots are not included"
+    included_teams = config.get('included_teams', [])
+    if included_teams and user.team not in included_teams:
+        return f"team '{user.team}' is not included"
+    excluded_teams = config.get('excluded_teams', [])
+    if excluded_teams and user.team in excluded_teams:
+        return f"team '{user.team}' is excluded"
+    return "the actor does not match the configuration"
+
+
+async def handle_thread_response(app: AsyncApp, channel, reply_user, thread_ts: str, actor_is_bot: bool = False):
+    keys_to_cancel = []
+    for key, scheduled_reply in state.scheduled_messages.items():
+        if key[0] != channel.id or key[1] != thread_ts:
+            continue
+
+        config = channel.configs.get(key[2])
+        no_restrictions = (
+            config is not None
+            and not config.get('included_teams')
+            and not config.get('excluded_teams')
+            and (not actor_is_bot or not config.get('include_bots', False))
+        )
+        if no_restrictions or not user_matches_actor_criteria(config, reply_user, actor_is_bot):
+            keys_to_cancel.append(key)
+
+    if not keys_to_cancel:
+        return
+
+    message_user_id = state.scheduled_messages[keys_to_cancel[0]].user_id
+    message_user = await slackcache.get_user_by_id(app, message_user_id)
+    log(f"Thread reply by user @{reply_user.name} detected. Cancelling {len(keys_to_cancel)} reminder(s) for message {thread_ts} in channel #{channel.name}, user @{message_user.name}")
+
+    for key in keys_to_cancel:
+        state.scheduled_messages[key].task.cancel()
+        del state.scheduled_messages[key]
+
+
+async def handle_channel_message(app: AsyncApp, opsgenie_token: str, channel, user, text: str, ts: str, actor_is_bot: bool = False):
+    for config_name, config in channel.configs.items():
+        if config.get('trigger', TRIGGER_MESSAGE) != TRIGGER_MESSAGE:
+            # Schedule/manual rules are driven by the scheduler or buttons, not messages.
+            continue
+        if not config.get('enabled', True):
+            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because replies are disabled.")
+            continue
+
+        only_work_days = config.get('only_work_days')
+        hours = config.get('hours')
+        pattern = config.get('pattern')
+        pattern_case_sensitive = config.get('pattern_case_sensitive')
+
+        if only_work_days and not datetimefmt.is_work_day(config):
+            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because of a non work day.")
+            continue
+        if len(hours) == 2 and not datetimefmt.is_work_time(hours[0], hours[1], config):
+            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because it was sent outside work time.")
+            continue
+        if not user_matches_actor_criteria(config, user, actor_is_bot):
+            log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because {get_actor_mismatch_reason(config, user, actor_is_bot)}.")
+            continue
+
+        if pattern:
+            flags = 0 if pattern_case_sensitive else re.IGNORECASE
+            if not re.search(pattern, text, flags):
+                log(f"Message from user @{user.name} in #{channel.name} will be ignored for config '{config_name}' because it does not match pattern '{pattern}'.")
+                continue
+
+        task = asyncio.create_task(scheduling.schedule_reply(app, opsgenie_token, channel, config, config_name, user, text, ts))
+        state.scheduled_messages[(channel.id, ts, config_name)] = ScheduledReply(task, user.id)
+        send_at = datetime.datetime.now() + datetime.timedelta(seconds=config['wait_time'])
+        state._scheduled_replies_cache[(channel.id, ts, config_name)] = {
+            'channel_id': channel.id,
+            'ts': ts,
+            'config_name': config_name,
+            'user_id': user.id,
+            'text': text,
+            'send_at': send_at.isoformat(),
+            # The wait this reply was scheduled with; the config may change before
+            # it fires, and a restore logs both.
+            'wait_time': config['wait_time'],
+        }
+        await persistence.flush_replies_cache()
+
+
+async def handle_reaction_added(app: AsyncApp, event):
+    item = event.get('item', {})
+    channel_id = item.get('channel', '')
+    user_id = event.get('user', '')
+    ts = item.get('ts')
+    channel = await slackcache.get_channel_by_id(app, channel_id)
+    reaction_user = await slackcache.get_user_by_id(app, user_id)
+
+    keys_to_cancel = []
+    for key, scheduled_reply in state.scheduled_messages.items():
+        if key[0] != channel_id or key[1] != ts:
+            continue
+
+        config = channel.configs.get(key[2])
+        no_restrictions = config is not None and not config.get('included_teams') and not config.get('excluded_teams')
+        if no_restrictions or not user_matches_actor_criteria(config, reaction_user):
+            keys_to_cancel.append(key)
+
+    if not keys_to_cancel:
+        return
+
+    message_user_id = state.scheduled_messages[keys_to_cancel[0]].user_id
+    message_user = await slackcache.get_user_by_id(app, message_user_id)
+    log(f"Reaction added by user @{reaction_user.name}. Cancelling {len(keys_to_cancel)} reminder(s) for message {ts} in channel #{channel.name}, user @{message_user.name}")
+
+    for key in keys_to_cancel:
+        state.scheduled_messages[key].task.cancel()
+        del state.scheduled_messages[key]
+
+
+async def handle_message_deletion(app: AsyncApp, channel, previous_message_user, previous_message_ts: str):
+    if previous_message_user.id == state.bot_user_id:
+        log(f"Ignoring message deletion by bot from channel #{channel.name}.")
+        return
+
+    keys_to_cancel = []
+    for key in state.scheduled_messages.keys():
+        if key[0] == channel.id and key[1] == previous_message_ts:
+            keys_to_cancel.append(key)
+
+    if not keys_to_cancel:
+        return
+
+    log(f"Message deleted. Cancelling {len(keys_to_cancel)} reply/replies for message {previous_message_ts} in channel #{channel.name}, user @{previous_message_user.name}")
+    for key in keys_to_cancel:
+        state.scheduled_messages[key].task.cancel()
+        del state.scheduled_messages[key]
+
+
+def is_bot_membership_event(event: dict) -> bool:
+    """True if a member_joined/left_channel event is about the bot itself."""
+    return bool(state.bot_user_id) and event.get('user') == state.bot_user_id
+
+
+async def cancel_channel_scheduled_replies(channel_id: str) -> int:
+    """Cancel every pending scheduled reply of a channel; returns how many were cancelled."""
+    keys_to_cancel = [key for key in state.scheduled_messages if key[0] == channel_id]
+    for key in keys_to_cancel:
+        state.scheduled_messages[key].task.cancel()
+        del state.scheduled_messages[key]
+        state._scheduled_replies_cache.pop(key, None)
+    if keys_to_cancel:
+        await persistence.flush_replies_cache()
+    return len(keys_to_cancel)
+
+
+async def handle_bot_removed_from_channel(app: AsyncApp, channel_id: str) -> None:
+    """Disable a channel's configurations after the bot was removed from it.
+
+    The configuration outlives the membership, so schedule triggers would keep
+    firing (and pending reminders/escalations would keep coming due) for a
+    channel the bot can no longer post to. Configurations disabled here are
+    marked with ``disabled_reason`` so a later rejoin can point them out; they
+    are never re-enabled automatically.
+    """
+    if not channel_id:
+        return
+
+    cancelled = await cancel_channel_scheduled_replies(channel_id)
+    cancelled_buttons = await buttons.cancel_channel_pending_buttons(channel_id)
+
+    configs = state.channel_config.get(channel_id, {})
+    disabled_names = sorted(name for name, config in configs.items() if config.get('enabled', True))
+    for name in disabled_names:
+        configs[name]['enabled'] = False
+        configs[name]['disabled_reason'] = DISABLED_REASON_REMOVED
+    if disabled_names:
+        await persistence.save_configuration()
+
+    log(f"{state.bot_name} was removed from channel {channel_id}. "
+        f"Disabled configuration(s): {', '.join(disabled_names) if disabled_names else '<none>'}. "
+        f"Cancelled {cancelled} scheduled reply/replies and {cancelled_buttons} pending button escalation(s).")
+
+
+async def handle_bot_added_to_channel(app: AsyncApp, channel_id: str) -> None:
+    """Point out the configurations that an earlier removal disabled."""
+    if not channel_id:
+        return
+
+    configs = state.channel_config.get(channel_id, {})
+    names = sorted(
+        name for name, config in configs.items()
+        if not config.get('enabled', True) and config.get('disabled_reason') == DISABLED_REASON_REMOVED
+    )
+    if not names:
+        return
+
+    config_list = ", ".join(f"`{name}`" for name in names)
+    singular = len(names) == 1
+    text = (
+        f"Hi! :wave: I am *{state.bot_name}* :palm_up_hand::tophat: and I am back in this channel.\n\n"
+        f"I disabled {'this configuration' if singular else 'these configurations'} when I was removed: {config_list}. "
+        f"Re-enable {'it' if singular else 'them'} with `{state.slash_command} [config] enable`."
+    )
+    await messaging._post_message(app, channel_id, text, None)
+    log(f"{state.bot_name} was added to channel {channel_id}. "
+        f"Configuration(s) still disabled from an earlier removal: {', '.join(names)}.")
+
+
+async def handle_command_event(app: AsyncApp, command: dict, opsgenie_token: str = ""):
+    text = command.get('text', '')
+    channel_id = command.get('channel_id', '')
+    user_id = command.get('user_id', '')
+
+    channel = await slackcache.get_channel_by_id(app, channel_id)
+    user = await slackcache.get_user_by_id(app, user_id)
+    await commands.process_command(app, text, channel, user, opsgenie_token=opsgenie_token)
+
+
+def register_app_handlers(app: AsyncApp, opsgenie_token: str = "") -> None:
+
+    @app.event("message")
+    async def handle_message_events(body, logger):
+        await route_message(app, opsgenie_token, body.get('event', {}) if body else {})
+
+    @app.event("reaction_added")
+    async def handle_reaction_added_events(body, logger):
+        await handle_reaction_added(app, body.get('event', {}) if body else {})
+
+    @app.event("member_left_channel")
+    async def handle_member_left_channel_events(body, logger):
+        event = body.get('event', {}) if body else {}
+        if is_bot_membership_event(event):
+            await handle_bot_removed_from_channel(app, event.get('channel', ''))
+
+    @app.event("member_joined_channel")
+    async def handle_member_joined_channel_events(body, logger):
+        event = body.get('event', {}) if body else {}
+        if is_bot_membership_event(event):
+            await handle_bot_added_to_channel(app, event.get('channel', ''))
+
+    @app.command(state.slash_command)
+    async def handle_command(ack, body, logger):
+        await ack()
+        await handle_command_event(app, body, opsgenie_token)
+
+    @app.action(re.compile(rf"^{BUTTON_ACTION_PREFIX}:"))
+    async def handle_button_action(ack, body, action, logger):
+        await ack()
+        await buttons.handle_button_press(app, opsgenie_token, body, action)
diff --git a/hutbot/scheduling.py b/hutbot/scheduling.py
new file mode 100644
index 0000000..0662d04
--- /dev/null
+++ b/hutbot/scheduling.py
@@ -0,0 +1,160 @@
+"""Deferred message reminders and the cron-trigger scheduler."""
+
+import asyncio
+import datetime
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log, log_error, log_warning
+
+from . import state
+from . import datetimefmt
+from . import slackcache
+from . import actions
+from . import persistence
+from .constants import SCHEDULER_INTERVAL, TRIGGER_CRON
+from .models import ScheduledReply
+
+try:
+    from croniter import croniter
+except ImportError:  # pragma: no cover - dependency optional at runtime
+    croniter = None
+
+
+def format_minutes(seconds: float) -> str:
+    minutes = int(seconds // 60)
+    return f"{minutes} min" if minutes == 1 else f"{minutes} mins"
+
+
+async def schedule_reply(app: AsyncApp, opsgenie_token: str, channel, config: dict, config_name: str, user, text: str, ts: str, wait_time_override: float | None = None, original_wait_time: float | None = None) -> None:
+    opsgenie_enabled = config.get('opsgenie')
+    wait_time = config.get('wait_time')
+    scheduled_message_key = (channel.id, ts, config_name)
+    actual_wait = wait_time_override if wait_time_override is not None else wait_time
+    if wait_time_override is None:
+        verb = "Scheduling"
+        timing = f"wait time {format_minutes(wait_time)}"
+    else:
+        # A restored reply keeps the deadline it was scheduled with, so log what it
+        # is actually waiting for — and name the wait time it started with, which
+        # the config may since have changed.
+        verb = "Rescheduling"
+        timing = f"{actual_wait:.0f}s remaining"
+        if original_wait_time is not None:
+            timing += f" of the original {format_minutes(original_wait_time)}"
+            if int(original_wait_time) != int(wait_time):
+                timing += f", config now {format_minutes(wait_time)}"
+    log(f"{verb} reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, {timing}, opsgenie {'enabled' if opsgenie_enabled else 'disabled'}{', but not configured' if opsgenie_enabled and not state.opsgenie_configured else ''}")
+    try:
+        await asyncio.sleep(actual_wait)
+        permalink = await slackcache.get_message_permalink(app, channel, ts)
+        # Single unified send path: the reply (and any configured action/buttons)
+        # goes through the action engine. The message context lets the reply thread
+        # on the original message and reuse its template variables.
+        posted = await actions.run_action(app, opsgenie_token, channel, config, config_name, context={
+            'user': user,
+            'text': text,
+            'ts': ts,
+            'thread_ts': ts,
+            'channel_id': channel.id,
+            'permalink': permalink,
+        })
+        # OpsGenie is fired inside run_action when this config has it enabled. To
+        # button-gate an alert, put OpsGenie on a separate (manual) config and run
+        # it from a button / button-timeout instead of on the reply config itself.
+    except asyncio.CancelledError as e:
+        log(f"Cancelling scheduled reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}:", e)
+    except Exception as e:
+        log_error(f"Failed to send scheduled reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}:", e)
+    finally:
+        state.scheduled_messages.pop(scheduled_message_key, None)
+        state._scheduled_replies_cache.pop(scheduled_message_key, None)
+        await persistence.flush_replies_cache()
+
+
+def _cron_due(cron_expr: str, config: dict, last: datetime.datetime, now: datetime.datetime) -> bool:
+    # A cron fires in the config's date/time timezone (server local without one),
+    # the same timezone its work hours and date/time output use.
+    tz = datetimefmt.get_config_timezone(config)
+    base = last.astimezone(tz)
+    current = now.astimezone(tz)
+    try:
+        nxt = croniter(cron_expr, base).get_next(datetime.datetime)
+    except (ValueError, KeyError) as e:
+        log_warning(f"Invalid cron expression '{cron_expr}': {e}")
+        return False
+    return nxt <= current
+
+
+async def run_scheduler(app: AsyncApp, opsgenie_token: str) -> None:
+    if croniter is None:
+        log_warning("croniter is not installed; scheduled triggers are disabled.")
+        return
+    state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    log(f"Scheduler started (interval {SCHEDULER_INTERVAL}s).")
+    while True:
+        await asyncio.sleep(SCHEDULER_INTERVAL)
+        try:
+            await scheduler_tick(app, opsgenie_token)
+        except Exception as e:
+            log_error("Scheduler tick failed:", e)
+
+
+async def scheduler_tick(app: AsyncApp, opsgenie_token: str) -> None:
+    now = datetime.datetime.now(datetime.timezone.utc)
+    last = state._scheduler_last_check or now
+    state._scheduler_last_check = now
+    for channel_id, configs in list(state.channel_config.items()):
+        for config_name, config in list(configs.items()):
+            if config.get('trigger') != TRIGGER_CRON:
+                continue
+            if not config.get('enabled', True):
+                continue
+            cron_expr = config.get('cron') or ''
+            if not cron_expr:
+                continue
+            if croniter is not None and not croniter.is_valid(cron_expr):
+                log_warning(f"Cron config '{config_name}' in channel {channel_id} has an invalid expression '{cron_expr}'.")
+                continue
+            if not _cron_due(cron_expr, config, last, now):
+                continue
+            channel = await slackcache.get_channel_by_id(app, channel_id)
+            if not await actions.evaluate_condition(app, config):
+                log(f"Cron config '{config_name}' in #{channel.name} fired but condition not met.")
+                continue
+            log(f"Cron config '{config_name}' in #{channel.name} firing.")
+            try:
+                await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel_id})
+            except Exception as e:
+                log_error(f"Cron config '{config_name}' action failed:", e)
+
+
+async def restore_scheduled_replies(app: AsyncApp, opsgenie_token: str) -> None:
+    entries = list(state._scheduled_replies_cache.items())
+    invalid_keys = []
+    restored = 0
+    log(f"Restoring {len(entries)} scheduled replies from cache...")
+    for key, entry in entries:
+        channel_id = entry['channel_id']
+        ts = entry['ts']
+        config_name = entry['config_name']
+        if channel_id not in state.channel_config or config_name not in state.channel_config[channel_id]:
+            log_warning(f"Skipping cached reply for message {ts}: channel {channel_id} / config '{config_name}' no longer configured.")
+            invalid_keys.append(key)
+            continue
+        config = state.channel_config[channel_id][config_name]
+        channel = await slackcache.get_channel_by_id(app, channel_id)
+        user = await slackcache.get_user_by_id(app, entry['user_id'])
+        send_at = datetime.datetime.fromisoformat(entry['send_at'])
+        remaining = max(0.0, (send_at - datetime.datetime.now()).total_seconds())
+        # Written since the cache gained the field; older entries have no original.
+        original_wait_time = entry.get('wait_time')
+        log(f"Restoring reply for message {ts} in channel #{channel.name} for config '{config_name}', user @{user.name}, due {send_at.isoformat(timespec='seconds')}.")
+        task = asyncio.create_task(schedule_reply(app, opsgenie_token, channel, config, config_name, user, entry['text'], ts, wait_time_override=remaining, original_wait_time=original_wait_time))
+        state.scheduled_messages[(channel.id, ts, config_name)] = ScheduledReply(task, user.id)
+        restored += 1
+    for key in invalid_keys:
+        state._scheduled_replies_cache.pop(key, None)
+    if invalid_keys:
+        await persistence.flush_replies_cache()
+    log(f"Restored {restored} scheduled replies.")
diff --git a/hutbot/slackcache.py b/hutbot/slackcache.py
new file mode 100644
index 0000000..d8d876e
--- /dev/null
+++ b/hutbot/slackcache.py
@@ -0,0 +1,308 @@
+"""Slack channel/user/usergroup lookups backed by the in-memory caches in ``state``."""
+
+import json
+import time
+
+from slack_bolt.async_app import AsyncApp
+from slack_sdk.errors import SlackApiError
+
+from employee_list import (
+    load_employee_mappings,
+    load_employees,
+    log,
+    log_error,
+    normalize_id,
+    normalize_real_name,
+    normalize_real_name_with_diagraphs,
+    normalize_user_name,
+    log_warning,
+)
+
+from . import state
+from .constants import TEAM_UNKNOWN
+from .models import Channel, User, Usergroup
+from .textutil import log_debug
+
+# Slack member ids per channel, cached briefly so listing a user's
+# channels doesn't hammer conversations.members on every UI request.
+_CHANNEL_MEMBERS_TTL = 300.0
+
+
+async def get_channel_by_id(app: AsyncApp, channel_id: str) -> Channel:
+    if channel_id not in state.channel_config:
+        state.channel_config[channel_id] = {}
+
+    name = await get_channel_name(app, channel_id)
+    configs = state.channel_config[channel_id]
+
+    return Channel(id=channel_id, name=name, configs=configs)
+
+
+async def get_channel_name(app: AsyncApp, channel_id: str) -> str:
+    try:
+        response = await app.client.conversations_info(channel=channel_id)
+        channel_name = response.get('channel', {}).get('name', '')
+        if channel_name:
+            return channel_name
+    except SlackApiError as e:
+        log_error(f"Failed to get channel name for {channel_id}", e)
+
+    return channel_id
+
+
+async def get_message_permalink(app: AsyncApp, channel: Channel, ts: str) -> str:
+    permalink = ""
+    try:
+        response = await app.client.chat_getPermalink(
+            channel=channel.id,
+            message_ts=ts
+        )
+
+        permalink = response.get('permalink', '')
+    except SlackApiError as e:
+        log_error(f"Failed to get permalink for message {ts} in channel #{channel.name}:", e)
+
+    return permalink
+
+
+async def update_usergroup_cache(app: AsyncApp) -> None:
+    if not state.usergroup_id_cache or not state.id_usergroup_cache:
+        try:
+            response = await app.client.usergroups_list()
+            usergroups = response['usergroups']
+            for usergroup in usergroups:
+                if usergroup.get('date_deleted', 0) == 0:
+                    usergroup_id = usergroup.get('id', '')
+                    usergroup_handle = usergroup.get('handle', '')
+                    usergroup_name = usergroup.get('name', '')
+                    state.usergroup_id_cache[usergroup_handle] = Usergroup(id=usergroup_id, handle=usergroup_handle, name=usergroup_name)
+                    state.id_usergroup_cache[usergroup_id] = Usergroup(id=usergroup_id, handle=usergroup_handle, name=usergroup_name)
+        except SlackApiError as e:
+            log_error("Failed to fetch usergroup list:", e)
+
+
+def build_user(user: dict, employees: dict, mappings: dict) -> tuple[str, User]:
+    user_id = user.get('id', '')
+    user_name = normalize_id(user.get('name', ''))
+    if user_name in mappings:
+        log(f"Applying employee mapping: {user_name} -> {mappings[user_name]}")
+        user_name = mappings[user_name]
+    user_name_normalized = normalize_user_name(user_name)
+    user_email = normalize_id(user.get('profile', {}).get('email', ''))
+    user_email_alias = normalize_id(user_email.split('@')[0])
+    user_email_alias_normalized = normalize_user_name(user_email_alias)
+    user_real_name = user.get('real_name', '').strip()
+    user_real_name_normalized = normalize_real_name(user_real_name)
+    user_is_bot = bool(user.get('is_bot')) or user_id == 'USLACKBOT'
+    user_team = TEAM_UNKNOWN
+
+    if len(employees) > 0 and not user_is_bot:
+        # Try different variations of the username to find a match in employees
+        user_key_candidates = [
+            user_name,
+            user_name_normalized,
+            user_email_alias,
+            user_email_alias_normalized
+        ]
+        user_key = next((k for k in user_key_candidates if k in employees), None)
+
+        if not user_key:
+            # loop through all employees and try to match some form of the real name
+            for employee_key, employee in employees.items():
+                employee_real_name = employee.get('fullname', '').strip()
+                employee_real_name_normalized = normalize_real_name(employee_real_name)
+                employee_real_name_super_normalized = normalize_real_name_with_diagraphs(employee_real_name)
+                user_real_name_super_normalized = normalize_real_name_with_diagraphs(user_real_name)
+                if employee_real_name_normalized == user_real_name_normalized or \
+                employee_real_name_super_normalized == user_real_name_normalized or \
+                employee_real_name_super_normalized == user_real_name_super_normalized:
+                    user_key = employee_key
+                    # finally!
+                    break
+            if not user_key:
+                user_json = json.dumps(user)
+                if len(user_json) > 100:
+                    user_json = user_json[:97] + '...'
+                log_warning(f"Failed to map user @{user_name} to a employee: {user_json}")
+
+        if user_key:
+            user_team = employees[user_key].get('group', '').strip()
+
+    return user_email, User(id=user_id, name=user_name, team=user_team, real_name=user_real_name, is_bot=user_is_bot)
+
+
+def cache_user(user_email: str, u: User) -> None:
+    state.user_id_cache[u.name] = u
+    if user_email:
+        state.user_email_cache[user_email] = u
+    state.id_user_cache[u.id] = u
+    if u.team not in state.team_cache:
+        state.team_cache.add(u.team)
+
+
+async def update_user_cache(app: AsyncApp) -> None:
+    if not state.user_id_cache or not state.user_email_cache or not state.id_user_cache:
+        employees = await load_employees()
+        mappings = load_employee_mappings()
+        try:
+            cursor = None
+            while True:
+                response = await app.client.users_list(cursor=cursor, limit=200)
+                for user in response['members']:
+                    if not user.get('deleted') and \
+                       not user.get('is_bot', False) and \
+                       not user.get('is_restricted', False) and \
+                       user.get('id', '') != 'USLACKBOT':
+                        cache_user(*build_user(user, employees, mappings))
+                cursor = response.get('response_metadata', {}).get('next_cursor')
+                if not cursor:
+                    break
+        except SlackApiError as e:
+            log_error("Failed to fetch user list:", e)
+
+
+async def fetch_user_by_id(app: AsyncApp, id: str, channel: Channel | None = None) -> User | None:
+    try:
+        response = await app.client.users_info(user=id)
+    except SlackApiError as e:
+        log_error(f"Failed to fetch user `{id}`:", e)
+        return None
+    slack_user = response.get('user')
+    if not slack_user:
+        return None
+    log_debug(channel, f"Retrieved user not in cache from Slack API: {json.dumps(slack_user)}")
+    employees = await load_employees()
+    mappings = load_employee_mappings()
+    user_email, user = build_user(slack_user, employees, mappings)
+    cache_user(user_email, user)
+    return user
+
+
+async def fetch_bot_handle(app: AsyncApp, bot_user_id: str) -> str:
+    """The handle people actually type to mention the bot, e.g. "Hutbot_DEV".
+
+    ``auth.test`` only reports the bot user's username, which Slack derives from
+    the app name by lowercasing it and dropping punctuation ("hutbotdev"). The
+    handle shown in the mention autocomplete is the profile display name.
+    """
+    if not bot_user_id:
+        return ""
+    try:
+        response = await app.client.users_info(user=bot_user_id)
+    except SlackApiError as e:
+        log_error(f"Failed to fetch the bot user `{bot_user_id}`:", e)
+        return ""
+    slack_user = response.get('user') or {}
+    profile = slack_user.get('profile') or {}
+    # Bot users usually have no display name; their `real_name` carries the app's
+    # display name ("Hutbot_DEV"), which is what the mention autocomplete offers.
+    # `name` is the flattened username and only a last resort.
+    candidates = (
+        profile.get('display_name'),
+        profile.get('display_name_normalized'),
+        slack_user.get('real_name'),
+        profile.get('real_name'),
+        slack_user.get('name'),
+    )
+    for candidate in candidates:
+        if candidate and candidate.strip():
+            return candidate.strip()
+    return ""
+
+
+async def get_user_by_id(app: AsyncApp, id: str, channel: Channel | None = None) -> User:
+    await update_user_cache(app)
+    user = state.id_user_cache.get(id, None)
+    if not user:
+        user = await fetch_user_by_id(app, id, channel)
+    if not user:
+        user = User(id=id, name=id, team=TEAM_UNKNOWN, real_name='')
+    return user
+
+
+async def get_user_by_name(app: AsyncApp, name: str) -> User:
+    await update_user_cache(app)
+    user = state.user_id_cache.get(name, None)
+    if not user:
+        user = User(id=None, name=name, team=TEAM_UNKNOWN, real_name='')
+    return user
+
+
+async def get_user_by_email(app: AsyncApp, email: str) -> User:
+    await update_user_cache(app)
+    normalized_email = normalize_id(email)
+    user = state.user_email_cache.get(normalized_email, None)
+    if user:
+        return user
+
+    user_alias = normalized_email.split('@')[0]
+    return await get_user_by_name(app, user_alias)
+
+
+async def get_user_by_email_strict(app: AsyncApp, email: str) -> User:
+    """Exact-email lookup only — no username fallback.
+
+    Used for web-UI authentication: the lenient ``get_user_by_email`` falls back
+    to matching a Slack *username* from the email local-part, which would let a
+    proxy-authenticated address like ``alice@external.example`` be authorized as
+    Slack user ``alice``. This resolver returns an id-less User on no exact match
+    so the UI gate rejects it.
+    """
+    await update_user_cache(app)
+    user = state.user_email_cache.get(normalize_id(email), None)
+    if user:
+        return user
+    return User(id=None, name=email, team=TEAM_UNKNOWN, real_name='')
+
+
+async def get_usergroup_by_id(app: AsyncApp, id: str) -> Usergroup:
+    await update_usergroup_cache(app)
+    usergroup = state.id_usergroup_cache.get(id, None)
+    if not usergroup:
+        usergroup = Usergroup(id=id, handle=id, name=id)
+    return usergroup
+
+
+async def get_usergroup_by_handle(app: AsyncApp, handle: str) -> Usergroup:
+    await update_usergroup_cache(app)
+    usergroup = state.usergroup_id_cache.get(handle, None)
+    if not usergroup:
+        usergroup = Usergroup(id=None, handle=handle, name=handle)
+    return usergroup
+
+
+async def get_usergroup_members(app: AsyncApp, usergroup_id: str) -> list[str]:
+    try:
+        response = await app.client.usergroups_users_list(usergroup=usergroup_id)
+        return response.get('users', [])
+    except SlackApiError as e:
+        log_error(f"Failed to fetch members of usergroup {usergroup_id}:", e)
+        return []
+
+
+async def get_channel_members(app: AsyncApp, channel_id: str) -> set:
+    """Set of Slack member ids for a channel, cached for _CHANNEL_MEMBERS_TTL seconds."""
+    now = time.monotonic()
+    cached = state._channel_members_cache.get(channel_id)
+    if cached and (now - cached[0]) < _CHANNEL_MEMBERS_TTL:
+        return cached[1]
+    members: set = set()
+    cursor = None
+    try:
+        while True:
+            response = await app.client.conversations_members(channel=channel_id, cursor=cursor, limit=200)
+            members.update(response.get('members', []) or [])
+            cursor = response.get('response_metadata', {}).get('next_cursor')
+            if not cursor:
+                break
+    except SlackApiError as e:
+        log_error(f"Failed to fetch members for channel {channel_id}:", e)
+        return cached[1] if cached else set()
+    state._channel_members_cache[channel_id] = (now, members)
+    return members
+
+
+async def is_user_in_channel(app: AsyncApp, channel_id: str, user_id: str) -> bool:
+    if not user_id:
+        return False
+    return user_id in await get_channel_members(app, channel_id)
diff --git a/hutbot/state.py b/hutbot/state.py
new file mode 100644
index 0000000..c35d652
--- /dev/null
+++ b/hutbot/state.py
@@ -0,0 +1,94 @@
+"""Shared mutable process state.
+
+Every cache, the live channel configuration, and the scheduler/heartbeat flags
+live here so that the rest of the package can share them without import cycles.
+
+IMPORTANT: always read and write these through the module (``state.channel_config``),
+never ``from .state import channel_config`` — several of these names are *rebound*
+(not just mutated) at runtime, and a ``from`` import would freeze a stale reference
+(and would also be invisible to ``unittest.mock.patch('hutbot.state.<name>')``).
+"""
+
+import asyncio
+import datetime
+
+from . import __version__
+from .constants import DEFAULT_BOT_NAME, DEFAULT_SLASH_COMMAND, normalize_version
+
+# Slash command this instance listens on; set from HUTBOT_SLASH_COMMAND at startup.
+slash_command = DEFAULT_SLASH_COMMAND
+
+# Version shown in `help` / `news`; set from HUTBOT_VERSION (the deployed image
+# tag) at startup, falling back to the package version.
+version = normalize_version(__version__)
+
+# Name the bot uses for itself in user-facing text; set from HUTBOT_BOT_NAME at startup.
+bot_name = DEFAULT_BOT_NAME
+
+# Date/time locale used by configs that set none; set from
+# HUTBOT_DEFAULT_DATETIME_LOCALE at startup and already normalized ("de_DE").
+# There is no timezone counterpart: the container's TZ is the server local
+# timezone, which is what a config without its own timezone already uses.
+default_datetime_locale = ""
+
+# Live configuration: {channel_id: {config_name: config_dict}}.
+channel_config: dict = {}
+
+# In-flight scheduled replies: {(channel_id, ts, config_name): ScheduledReply}.
+scheduled_messages: dict = {}
+# Persisted mirror of the above: {(channel_id, ts, config_name): entry_dict}.
+_scheduled_replies_cache: dict[tuple, dict] = {}
+
+# Pending interactive-button messages awaiting a press, keyed by (channel_id, message_ts).
+pending_buttons: dict[tuple, dict] = {}
+_button_states_cache: dict[tuple, dict] = {}
+
+# Timestamp of the scheduler's previous tick; cron occurrences in (last tick, now] fire.
+_scheduler_last_check: datetime.datetime | None = None
+
+# Slack user/usergroup/team caches.
+user_id_cache: dict = {}
+user_email_cache: dict = {}
+id_user_cache: dict = {}
+usergroup_id_cache: dict = {}
+id_usergroup_cache: dict = {}
+team_cache: set = set()
+
+# Resolved on startup from auth.test.
+bot_user_id = None
+# The bot's Slack handle from auth.test; used for the `@mention` examples in the help text.
+bot_user_name = DEFAULT_BOT_NAME
+
+# True once an OpsGenie token + heartbeat name are configured.
+opsgenie_configured = False
+
+# Slack member ids per channel, cached briefly (see slackcache.get_channel_members).
+_channel_members_cache: dict[str, tuple[float, set]] = {}
+
+# Serializes web-UI config writes (mutate channel_config + save_configuration).
+_config_write_lock = asyncio.Lock()
+
+
+def reset() -> None:
+    """Reset all shared state to its initial values (used by the test suite)."""
+    global _scheduler_last_check, bot_user_id, bot_user_name, opsgenie_configured, slash_command, bot_name, default_datetime_locale, version
+    channel_config.clear()
+    scheduled_messages.clear()
+    _scheduled_replies_cache.clear()
+    pending_buttons.clear()
+    _button_states_cache.clear()
+    user_id_cache.clear()
+    user_email_cache.clear()
+    id_user_cache.clear()
+    usergroup_id_cache.clear()
+    id_usergroup_cache.clear()
+    team_cache.clear()
+    _channel_members_cache.clear()
+    _scheduler_last_check = None
+    bot_user_id = None
+    bot_user_name = DEFAULT_BOT_NAME
+    opsgenie_configured = False
+    slash_command = DEFAULT_SLASH_COMMAND
+    bot_name = DEFAULT_BOT_NAME
+    default_datetime_locale = ""
+    version = normalize_version(__version__)
diff --git a/hutbot/targets.py b/hutbot/targets.py
new file mode 100644
index 0000000..addd464
--- /dev/null
+++ b/hutbot/targets.py
@@ -0,0 +1,52 @@
+"""Resolve `#channel` / `@user` / `@usergroup` references to ids and objects."""
+
+import re
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import normalize_id
+
+from . import slackcache
+from .constants import ID_PATTERN
+from .models import Usergroup, User
+
+
+def parse_channel_ref(channel_ref: str) -> str | None:
+    """Resolve a `#channel` mention or raw `Cxxxx` id to a channel id."""
+    for match in ID_PATTERN.finditer(channel_ref):
+        ident = match.group(1)
+        if ident and ident[0] == '#':
+            return ident[1:]
+    stripped = channel_ref.strip()
+    if re.match(r'^[CGD][A-Z0-9]+$', stripped):
+        return stripped
+    return None
+
+
+async def resolve_user_target(app: AsyncApp, target: str) -> User | None:
+    target = target.strip()
+    if not target:
+        return None
+    for match in ID_PATTERN.finditer(target):
+        ident = match.group(1)
+        if ident and ident[0] == '@':
+            return await slackcache.get_user_by_id(app, ident[1:])
+    if re.match(r'^[UW][A-Z0-9]+$', target):
+        return await slackcache.get_user_by_id(app, target)
+    if target.startswith('@'):
+        return await slackcache.get_user_by_name(app, normalize_id(target[1:]))
+    if '@' in target:
+        return await slackcache.get_user_by_email(app, target)
+    return await slackcache.get_user_by_name(app, normalize_id(target))
+
+
+async def resolve_usergroup_target(app: AsyncApp, target: str) -> Usergroup | None:
+    target = target.strip()
+    if not target:
+        return None
+    for match in re.finditer(r'<!subteam\^([A-Z0-9]+)', target):
+        return await slackcache.get_usergroup_by_id(app, match.group(1))
+    if re.match(r'^S[A-Z0-9]+$', target):
+        return await slackcache.get_usergroup_by_id(app, target)
+    handle = target[1:] if target.startswith('@') else target
+    return await slackcache.get_usergroup_by_handle(app, handle)
diff --git a/hutbot/templating.py b/hutbot/templating.py
new file mode 100644
index 0000000..2bf67e6
--- /dev/null
+++ b/hutbot/templating.py
@@ -0,0 +1,251 @@
+"""Parsing and rendering of ``{{variable}}`` reply-message templates."""
+
+import datetime
+
+from slack_bolt.async_app import AsyncApp
+
+from . import datetimefmt
+from . import opsgenie
+from .constants import (
+    DATETIME_TEMPLATE_VARIABLES,
+    OPSGENIE_DATETIME_TEMPLATE_VARIABLES,
+    SUPPORTED_TEMPLATE_VARIABLES,
+    TEAM_UNKNOWN,
+    TEMPLATE_ARGUMENT_ALIASES,
+    TEMPLATE_ARGUMENT_NAME_PATTERN,
+    TEMPLATE_VARIABLE_NAME_PATTERN,
+    UNKNOWN_ONCALL_PERIOD_PLACEHOLDER,
+)
+from .models import Channel, TemplateExpression, TemplateExpressionError, User
+
+
+def iter_template_expression_parts(message: str):
+    pos = 0
+    while pos < len(message):
+        next_open = message.find("{{", pos)
+        next_close = message.find("}}", pos)
+        if next_close != -1 and (next_open == -1 or next_close < next_open):
+            raise TemplateExpressionError("unexpected `}}`")
+        if next_open == -1:
+            break
+
+        close = message.find("}}", next_open + 2)
+        if close == -1:
+            raise TemplateExpressionError("missing closing `}}`")
+        yield next_open, close + 2, message[next_open + 2:close].strip()
+        pos = close + 2
+
+
+def parse_template_expression(content: str) -> TemplateExpression:
+    i = 0
+    match = TEMPLATE_VARIABLE_NAME_PATTERN.match(content, i)
+    if not match:
+        raise TemplateExpressionError("missing variable name")
+    variable = match.group(0)
+    i = match.end()
+
+    while i < len(content) and content[i].isspace():
+        i += 1
+    if i == len(content):
+        return TemplateExpression(variable, {})
+    if content[i] != "(":
+        raise TemplateExpressionError("expected `(` after variable name")
+    i += 1
+
+    args = {}
+    while True:
+        while i < len(content) and content[i].isspace():
+            i += 1
+        if i < len(content) and content[i] == ")":
+            i += 1
+            break
+        if i >= len(content):
+            raise TemplateExpressionError("missing closing `)`")
+
+        name_match = TEMPLATE_ARGUMENT_NAME_PATTERN.match(content, i)
+        if not name_match:
+            raise TemplateExpressionError("missing argument name")
+        arg_name = name_match.group(0)
+        i = name_match.end()
+        canonical_arg_name = TEMPLATE_ARGUMENT_ALIASES.get(arg_name)
+        if not canonical_arg_name:
+            raise TemplateExpressionError(f"unknown argument `{arg_name}`")
+        if canonical_arg_name in args:
+            raise TemplateExpressionError(f"duplicate argument `{arg_name}`")
+
+        while i < len(content) and content[i].isspace():
+            i += 1
+        if i >= len(content) or content[i] != "=":
+            raise TemplateExpressionError(f"missing `=` after argument `{arg_name}`")
+        i += 1
+        while i < len(content) and content[i].isspace():
+            i += 1
+        if i >= len(content) or content[i] in ",)":
+            raise TemplateExpressionError(f"missing value for argument `{arg_name}`")
+
+        if content[i] in ("'", '"'):
+            quote = content[i]
+            i += 1
+            value = []
+            while i < len(content):
+                if content[i] == "\\" and i + 1 < len(content) and content[i + 1] in (quote, "\\"):
+                    value.append(content[i + 1])
+                    i += 2
+                    continue
+                if content[i] == quote:
+                    i += 1
+                    break
+                value.append(content[i])
+                i += 1
+            else:
+                raise TemplateExpressionError(f"unterminated quoted value for argument `{arg_name}`")
+            arg_value = "".join(value)
+        else:
+            start = i
+            while i < len(content) and content[i] not in ",)":
+                i += 1
+            arg_value = content[start:i].strip()
+
+        if not arg_value:
+            raise TemplateExpressionError(f"missing value for argument `{arg_name}`")
+        args[canonical_arg_name] = arg_value
+
+        while i < len(content) and content[i].isspace():
+            i += 1
+        if i < len(content) and content[i] == ",":
+            i += 1
+            j = i
+            while j < len(content) and content[j].isspace():
+                j += 1
+            if j < len(content) and content[j] == ")":
+                raise TemplateExpressionError("missing argument after `,`")
+            continue
+        if i < len(content) and content[i] == ")":
+            i += 1
+            break
+        if i >= len(content):
+            raise TemplateExpressionError("missing closing `)`")
+        raise TemplateExpressionError("expected `,` or `)` after argument value")
+
+    while i < len(content) and content[i].isspace():
+        i += 1
+    if i != len(content):
+        raise TemplateExpressionError("unexpected text after closing `)`")
+
+    return TemplateExpression(variable, args)
+
+
+def parse_template_expressions(message: str) -> list[TemplateExpression]:
+    return [parse_template_expression(content) for _, _, content in iter_template_expression_parts(message)]
+
+
+def validate_template_expressions(message: str) -> str:
+    try:
+        expressions = parse_template_expressions(message)
+    except TemplateExpressionError as e:
+        return f"malformed template expression: {e}"
+
+    unknown_variables = sorted({expr.variable for expr in expressions if expr.variable not in SUPPORTED_TEMPLATE_VARIABLES})
+    if unknown_variables:
+        return (
+            "unsupported template variable(s) "
+            + ", ".join(f"`{{{{{variable}}}}}`" for variable in unknown_variables)
+            + ". Supported variables: "
+            + ", ".join(f"`{{{{{variable}}}}}`" for variable in sorted(SUPPORTED_TEMPLATE_VARIABLES))
+            + "."
+        )
+
+    for expr in expressions:
+        if expr.args and expr.variable not in OPSGENIE_DATETIME_TEMPLATE_VARIABLES | DATETIME_TEMPLATE_VARIABLES:
+            return f"template variable `{{{{{expr.variable}}}}}` does not support arguments"
+        if "tz" in expr.args:
+            try:
+                datetimefmt.validate_timezone_name(expr.args["tz"])
+            except ValueError as e:
+                return str(e)
+        if "lc" in expr.args:
+            try:
+                datetimefmt.normalize_locale_name(expr.args["lc"])
+            except ValueError as e:
+                return str(e)
+
+    return ""
+
+
+def find_unknown_template_variables(message: str) -> list[str]:
+    try:
+        variables = {expr.variable for expr in parse_template_expressions(message)}
+    except TemplateExpressionError:
+        return []
+    return sorted(variable for variable in variables if variable not in SUPPORTED_TEMPLATE_VARIABLES)
+
+
+def find_template_variables(message: str) -> set[str]:
+    try:
+        return {expr.variable for expr in parse_template_expressions(message)}
+    except TemplateExpressionError:
+        return set()
+
+
+def render_reply_message_template(message: str, variables: dict[str, str], config: dict | None = None) -> str:
+    try:
+        spans = list(iter_template_expression_parts(message))
+    except TemplateExpressionError:
+        return message
+
+    rendered = []
+    last_index = 0
+    for start, end, content in spans:
+        rendered.append(message[last_index:start])
+        try:
+            expr = parse_template_expression(content)
+        except TemplateExpressionError:
+            rendered.append(message[start:end])
+            last_index = end
+            continue
+
+        if expr.variable in DATETIME_TEMPLATE_VARIABLES:
+            rendered.append(datetimefmt.format_timestamp_value(variables.get("__timestamp_raw", ""), expr.variable, config, expr.args))
+        elif expr.variable in OPSGENIE_DATETIME_TEMPLATE_VARIABLES:
+            raw_value = variables.get(f"__{expr.variable}_raw", "")
+            if raw_value or expr.args:
+                rendered.append(datetimefmt.format_opsgenie_template_datetime(raw_value, expr.variable, config, expr.args))
+            else:
+                rendered.append(variables.get(expr.variable, UNKNOWN_ONCALL_PERIOD_PLACEHOLDER))
+        else:
+            rendered.append(variables.get(expr.variable, message[start:end]))
+        last_index = end
+
+    rendered.append(message[last_index:])
+    return "".join(rendered)
+
+
+async def build_reply_template_variables(app: AsyncApp, opsgenie_token: str, channel: Channel, config: dict, config_name: str, user: User, text: str, ts: str, permalink: str, include_opsgenie: bool = False) -> dict[str, str]:
+    wait_time = config.get('wait_time') or 0
+    opsgenie_template_variables = {}
+    if include_opsgenie:
+        opsgenie_template_variables = await opsgenie.get_opsgenie_template_variables(app, opsgenie_token, config)
+
+    # `test`, `run`, and schedule/manual triggers have no message behind them, so
+    # there is no Slack timestamp to report. Stand in the current time instead of
+    # rendering the time variables empty.
+    ts = ts or f"{datetime.datetime.now(datetime.timezone.utc).timestamp():.6f}"
+
+    return {
+        "date": datetimefmt.format_timestamp_value(ts, "date", config),
+        "time": datetimefmt.format_timestamp_value(ts, "time", config),
+        "datetime": datetimefmt.format_timestamp_value(ts, "datetime", config),
+        # The raw timestamp, so `{{date(tz=...)}}` and friends can re-render it.
+        "__timestamp_raw": ts,
+        "channel": f"#{channel.name}",
+        "channel_name": channel.name,
+        "config": config_name,
+        "message": text,
+        "message_link": permalink,
+        **opsgenie_template_variables,
+        "team": user.team if user.team else TEAM_UNKNOWN,
+        "timestamp": ts,
+        "user": f"<@{user.id}>",
+        "user_name": user.real_name if user.real_name else user.name,
+        "wait_minutes": str(wait_time // 60),
+    }
diff --git a/hutbot/textutil.py b/hutbot/textutil.py
new file mode 100644
index 0000000..3365f45
--- /dev/null
+++ b/hutbot/textutil.py
@@ -0,0 +1,95 @@
+"""Logging + small text helpers with no Slack/network dependencies."""
+
+import sys
+import datetime
+
+from .models import Channel
+
+
+def log_debug(channel: Channel | None, *args: object) -> None:
+    if channel and any(c.get('debug') for c in channel.configs.values()):
+        _log(sys.stderr, 'DEBUG', *args)
+
+
+def _log(file, prefix, *args: object) -> None:
+    parts = []
+    for arg in args:
+        part = str(arg)
+        if isinstance(arg, BaseException):
+            error_type = type(arg).__name__
+            error_message = str(arg)
+            part = f"{error_type}{': ' + error_message if error_message else ''}"
+        parts.append(part)
+    message = ' '.join(parts)
+    prefix = f"{datetime.datetime.now().strftime('%Y-%m-%dT%H:%M:%S')} {prefix}:"
+    print(prefix, message, flush=True, file=file)
+
+
+def strip_quotes(text: str) -> str:
+    if text and ((text.startswith('"') and text.endswith('"')) or (text.startswith("'") and text.endswith("'"))):
+        text = text[1:-1]
+
+    return text
+
+
+def parse_quoted_tokens(text: str) -> tuple[list[str], str]:
+    tokens = []
+    i = 0
+    while i < len(text):
+        while i < len(text) and text[i].isspace():
+            i += 1
+        if i >= len(text):
+            break
+
+        if text[i] in ("'", '"'):
+            quote = text[i]
+            i += 1
+            value = []
+            while i < len(text):
+                if text[i] == "\\" and i + 1 < len(text) and text[i + 1] in (quote, "\\"):
+                    value.append(text[i + 1])
+                    i += 2
+                    continue
+                if text[i] == quote:
+                    i += 1
+                    break
+                value.append(text[i])
+                i += 1
+            else:
+                return [], "unterminated quoted value"
+            if i < len(text) and not text[i].isspace():
+                return [], "quoted values must be separated by whitespace"
+            tokens.append("".join(value))
+        else:
+            start = i
+            while i < len(text) and not text[i].isspace():
+                i += 1
+            tokens.append(text[start:i])
+
+    return tokens, ""
+
+
+def extract_message_text(event: dict) -> str:
+    text = event.get('text', '')
+    if isinstance(text, str) and text.strip():
+        return text
+
+    attachment_texts = []
+    fallback_texts = []
+    for attachment in event.get('attachments', []):
+        if not isinstance(attachment, dict):
+            continue
+
+        for field in ('pretext', 'title', 'text'):
+            value = attachment.get(field, '')
+            if isinstance(value, str) and value.strip():
+                attachment_texts.append(value)
+
+        fallback = attachment.get('fallback', '')
+        if isinstance(fallback, str) and fallback.strip():
+            fallback_texts.append(fallback)
+
+    if attachment_texts:
+        return "\n".join(attachment_texts).strip()
+
+    return "\n".join(fallback_texts).strip()
diff --git a/hutbot/webui_backend.py b/hutbot/webui_backend.py
new file mode 100644
index 0000000..c5bf482
--- /dev/null
+++ b/hutbot/webui_backend.py
@@ -0,0 +1,450 @@
+"""Web-UI backend: channel membership, payload validation, and config writes.
+
+The aiohttp server itself lives in ``webui.py``; these helpers bridge it to the
+live bot state and reuse the same validation as the slash-command setters.
+"""
+
+import os
+import re
+import copy
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from slack_bolt.async_app import AsyncApp
+
+from employee_list import log, log_error
+
+from . import state
+from . import slackcache
+from . import messaging
+from . import templating
+from . import datetimefmt
+from . import persistence
+from .constants import (
+    ACTION_DM_USER,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
+    ACTION_REPLY,
+    ACTIONS,
+    BUTTON_ACTION_CONFIG,
+    BUTTON_ACTION_ACK,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
+    BUTTON_ACTION_DELAY,
+    BUTTON_ACTIONS,
+    CONDITION_NONE,
+    CONDITION_OUTLOOK,
+    CONDITIONS,
+    CONFIG_NAME_PATTERN,
+    DEFAULT_CONFIG,
+    DEFAULT_CONFIG_NAME,
+    DEFAULT_OPSGENIE_PRIORITY,
+    DISABLED_REASON_REMOVED,
+    OPSGENIE_PRIORITIES,
+    SUPPORTED_TEMPLATE_VARIABLES,
+    TEAM_UNKNOWN,
+    TRIGGER_MESSAGE,
+    TRIGGER_CRON,
+    TRIGGERS,
+)
+from .models import User
+
+try:
+    from croniter import croniter
+except ImportError:  # pragma: no cover - dependency optional at runtime
+    croniter = None
+
+
+async def list_user_config_channels(app: AsyncApp, user: User) -> list[dict]:
+    """Channels that have a Hutbot config and that `user` belongs to, sorted by name."""
+    channels = []
+    for channel_id in list(state.channel_config.keys()):
+        if await slackcache.is_user_in_channel(app, channel_id, user.id):
+            channels.append({'id': channel_id, 'name': await slackcache.get_channel_name(app, channel_id)})
+    channels.sort(key=lambda c: c['name'].lower())
+    return channels
+
+
+def _ui_bool(value) -> bool:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, (int, float)):
+        return bool(value)
+    if isinstance(value, str):
+        return value.strip().lower() in ('1', 'true', 'yes', 'on')
+    return False
+
+
+def _ui_team_list(value) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    cleaned = []
+    for team in value:
+        team = str(team).strip()
+        if team and team not in cleaned:
+            cleaned.append(team)
+    return cleaned
+
+
+async def validate_config_payload(payload: dict, app: AsyncApp, channel_id: str = "") -> tuple[dict | None, dict]:
+    """Validate a config dict from the web UI, mirroring the slash-command setters.
+
+    Returns ``(clean_config, {})`` on success or ``(None, {field: message})`` on failure.
+    Values use the persisted shape: ``wait_time`` and ``escalation_timeout`` are in seconds.
+    """
+    if not isinstance(payload, dict):
+        return None, {'_': "Expected a configuration object."}
+
+    errors: dict[str, str] = {}
+    cfg = copy.deepcopy(DEFAULT_CONFIG)
+
+    def get(key):
+        return payload.get(key, DEFAULT_CONFIG.get(key))
+
+    for key in ('enabled', 'include_bots', 'only_work_days', 'debug',
+                'opsgenie', 'condition_negate', 'pattern_case_sensitive'):
+        cfg[key] = _ui_bool(get(key))
+
+    # wait_time (stored as seconds; 1..1440 minutes)
+    try:
+        wait_time = int(get('wait_time'))
+    except (TypeError, ValueError):
+        errors['wait_time'] = "Reminder delay must be a number."
+    else:
+        if wait_time < 60 or wait_time > 86400:
+            errors['wait_time'] = "Reminder delay must be between 1 and 1440 minutes."
+        else:
+            cfg['wait_time'] = wait_time
+
+    # escalation_timeout (stored as seconds; 1..1440 minutes, 0 = never escalate) and
+    # what it escalates to. Both halves are validated together.
+    try:
+        escalation_timeout = int(get('escalation_timeout'))
+    except (TypeError, ValueError):
+        errors['escalation_timeout'] = "Escalation timeout must be a number."
+    else:
+        escalation_kind = str(get('escalation_kind') or ESCALATION_NONE).strip().lower() or ESCALATION_NONE
+        escalation_target = str(get('escalation_target') or "").strip()
+        if escalation_timeout < 0 or escalation_timeout > 86400:
+            errors['escalation_timeout'] = "Escalation timeout must be between 0 and 1440 minutes."
+        elif escalation_kind not in (ESCALATION_NONE, ESCALATION_BUTTON, ESCALATION_CONFIG):
+            errors['escalation_kind'] = "Escalation must be none, button or config."
+        elif escalation_kind == ESCALATION_NONE or not escalation_timeout:
+            # Half a setting escalates nothing, so store it as switched off.
+            cfg['escalation_timeout'] = 0
+            cfg['escalation_kind'] = ESCALATION_NONE
+            cfg['escalation_target'] = ""
+        elif not escalation_target:
+            errors['escalation_target'] = "Pick a button label or a rule to escalate to."
+        else:
+            cfg['escalation_timeout'] = escalation_timeout
+            cfg['escalation_kind'] = escalation_kind
+            cfg['escalation_target'] = escalation_target
+
+    # reply_message — resolve @mentions and validate template variables
+    reply_message = get('reply_message')
+    if not isinstance(reply_message, str) or not reply_message.strip():
+        errors['reply_message'] = "Reply message can't be empty."
+    else:
+        ok, mention_error, processed = await messaging.process_mentions(app, reply_message)
+        if not ok:
+            errors['reply_message'] = f"Unknown user mention: {mention_error}."
+        else:
+            template_error = templating.validate_template_expressions(processed)
+            if template_error:
+                errors['reply_message'] = template_error
+            else:
+                cfg['reply_message'] = processed
+
+    # opsgenie_message — template only (empty = original message)
+    opsgenie_message = get('opsgenie_message') or ""
+    if not isinstance(opsgenie_message, str):
+        errors['opsgenie_message'] = "OpsGenie message must be text."
+    else:
+        opsgenie_message = opsgenie_message.strip()
+        template_error = templating.validate_template_expressions(opsgenie_message) if opsgenie_message else ""
+        if template_error:
+            errors['opsgenie_message'] = template_error
+        else:
+            cfg['opsgenie_message'] = opsgenie_message
+
+    cfg['opsgenie_schedule_name'] = str(get('opsgenie_schedule_name') or "").strip()
+
+    priority = str(get('opsgenie_priority') or DEFAULT_OPSGENIE_PRIORITY).strip().upper()
+    if priority not in OPSGENIE_PRIORITIES:
+        errors['opsgenie_priority'] = "Priority must be one of " + ", ".join(sorted(OPSGENIE_PRIORITIES)) + "."
+    else:
+        cfg['opsgenie_priority'] = priority
+
+    cfg['date_format'] = str(get('date_format') or "")
+    cfg['time_format'] = str(get('time_format') or "")
+
+    tz_name = str(get('datetime_timezone') or "").strip()
+    if tz_name:
+        try:
+            datetimefmt.validate_timezone_name(tz_name)
+            cfg['datetime_timezone'] = tz_name
+        except ValueError as e:
+            errors['datetime_timezone'] = str(e)
+    else:
+        cfg['datetime_timezone'] = ""
+
+    locale_value = str(get('datetime_locale') or "").strip()
+    if locale_value:
+        try:
+            cfg['datetime_locale'] = datetimefmt.normalize_locale_name(locale_value)
+        except ValueError as e:
+            errors['datetime_locale'] = str(e)
+    else:
+        cfg['datetime_locale'] = ""
+
+    cron_expr = str(get('cron') or "").strip()
+    if cron_expr and croniter is not None and not croniter.is_valid(cron_expr):
+        errors['cron'] = "Invalid cron expression. Use 5 fields, e.g. `0 9 * * 1-5`."
+    else:
+        cfg['cron'] = cron_expr
+
+    trigger = str(get('trigger') or TRIGGER_MESSAGE).strip().lower()
+    trigger = {'msg': TRIGGER_MESSAGE, 'schedule': TRIGGER_CRON, 'scheduled': TRIGGER_CRON}.get(trigger, trigger)
+    if trigger not in TRIGGERS:
+        errors['trigger'] = "Trigger must be one of " + ", ".join(sorted(TRIGGERS)) + "."
+    else:
+        cfg['trigger'] = trigger
+
+    condition = str(get('condition') or CONDITION_NONE).strip().lower()
+    condition = {'none': CONDITION_NONE, 'off': CONDITION_NONE, '': CONDITION_NONE,
+                 'outlook': CONDITION_OUTLOOK, 'calendar': CONDITION_OUTLOOK,
+                 'outlook_calendar': CONDITION_OUTLOOK}.get(condition, condition)
+    if condition not in CONDITIONS:
+        errors['condition'] = "Condition must be `none` or `outlook`."
+    else:
+        cfg['condition'] = condition
+
+    for field in ('outlook_subject_pattern', 'outlook_body_pattern'):
+        value = str(get(field) or "")
+        if value:
+            try:
+                re.compile(value)
+            except re.error as e:
+                errors[field] = f"Invalid pattern: {e}"
+                continue
+        cfg[field] = value
+
+    action = str(get('action') or ACTION_REPLY).strip().lower().replace('-', '_')
+    if action not in ACTIONS:
+        errors['action'] = "Action must be one of " + ", ".join(sorted(ACTIONS)) + "."
+    else:
+        cfg['action'] = action
+
+    action_target = str(get('action_target') or "").strip()
+    if action in (ACTION_DM_USER, ACTION_GROUP_DM, ACTION_POST_CHANNEL) and not action_target:
+        errors['action_target'] = "This action needs a target (a user, user group, or channel)."
+    else:
+        cfg['action_target'] = action_target
+
+    pattern = get('pattern')
+    if pattern in (None, ""):
+        cfg['pattern'] = None
+    elif not isinstance(pattern, str):
+        errors['pattern'] = "Pattern must be text."
+    else:
+        try:
+            re.compile(pattern)
+            cfg['pattern'] = pattern
+        except re.error as e:
+            errors['pattern'] = f"Invalid pattern: {e}"
+
+
+    await slackcache.update_user_cache(app)
+    included = _ui_team_list(get('included_teams'))
+    excluded = _ui_team_list(get('excluded_teams'))
+    if included and excluded:
+        errors['included_teams'] = "Set included teams or excluded teams, not both."
+    unknown_included = [team for team in included if team not in state.team_cache]
+    unknown_excluded = [team for team in excluded if team not in state.team_cache]
+    if unknown_included:
+        errors['included_teams'] = "Unknown team(s): " + ", ".join(unknown_included) + "."
+    if unknown_excluded:
+        errors['excluded_teams'] = "Unknown team(s): " + ", ".join(unknown_excluded) + "."
+    if 'included_teams' not in errors:
+        cfg['included_teams'] = included
+    if 'excluded_teams' not in errors:
+        cfg['excluded_teams'] = excluded
+
+    hours_value = get('hours')
+    if hours_value in (None, "", []):
+        cfg['hours'] = []
+    elif isinstance(hours_value, list) and len(hours_value) == 2:
+        start_time = datetimefmt.parse_time(str(hours_value[0]))
+        end_time = datetimefmt.parse_time(str(hours_value[1]))
+        if not start_time or not end_time:
+            errors['hours'] = "Use times like `09:00` and `17:00`."
+        else:
+            normalized = [start_time.strftime("%H:%M"), end_time.strftime("%H:%M")]
+            cfg['hours'] = [] if normalized == ["00:00", "00:00"] else normalized
+    else:
+        errors['hours'] = "Work hours need a start and an end time."
+
+    buttons_value = get('buttons')
+    if buttons_value in (None, ""):
+        buttons_value = []
+    clean_buttons = []
+    if not isinstance(buttons_value, list):
+        errors['buttons'] = "Buttons must be a list."
+    else:
+        for i, button in enumerate(buttons_value):
+            if not isinstance(button, dict):
+                errors[f'buttons.{i}'] = "Each button needs a label and an action."
+                continue
+            label = str(button.get('label') or "").strip()
+            button_action = str(button.get('action') or BUTTON_ACTION_CONFIG).strip().lower()
+            value = str(button.get('value') or "").strip()
+            if not label:
+                errors[f'buttons.{i}'] = "Button label can't be empty."
+                continue
+            if button_action not in BUTTON_ACTIONS:
+                errors[f'buttons.{i}'] = "Button action must be one of " + ", ".join(sorted(BUTTON_ACTIONS)) + "."
+                continue
+            if button_action == BUTTON_ACTION_CONFIG and not value:
+                errors[f'buttons.{i}'] = "`config` button needs a configuration name."
+                continue
+            if button_action == BUTTON_ACTION_ACK and value:
+                # Same treatment as reply_message: mentions resolved, variables checked.
+                ok, mention_error, value = await messaging.process_mentions(app, value)
+                if not ok:
+                    errors[f'buttons.{i}'] = f"Unknown user mention: {mention_error}."
+                    continue
+                template_error = templating.validate_template_expressions(value)
+                if template_error:
+                    errors[f'buttons.{i}'] = template_error
+                    continue
+            if button_action == BUTTON_ACTION_DELAY:
+                try:
+                    minutes = int(value)
+                except ValueError:
+                    errors[f'buttons.{i}'] = "Delay button needs a number of minutes."
+                    continue
+                if minutes <= 0 or minutes > 1440:
+                    errors[f'buttons.{i}'] = "Delay minutes must be between 1 and 1440."
+                    continue
+                value = str(minutes)
+            clean_buttons.append({'label': label, 'action': button_action, 'value': value})
+    if not any(key == 'buttons' or key.startswith('buttons.') for key in errors):
+        cfg['buttons'] = clean_buttons
+
+
+    if errors:
+        return None, errors
+    return cfg, {}
+
+
+async def ui_apply_config(app: AsyncApp, channel_id: str, config_name: str, payload: dict) -> tuple[bool, dict]:
+    """Validate and persist a single config (rule). Returns (ok, errors)."""
+    config_name = (config_name or "").strip()
+    if not CONFIG_NAME_PATTERN.fullmatch(config_name):
+        return False, {'name': "Names may use letters, numbers, and - _ . : / only."}
+    clean, errors = await validate_config_payload(payload, app, channel_id)
+    if errors:
+        return False, errors
+    async with state._config_write_lock:
+        configs = state.channel_config.get(channel_id, {})
+        if config_name not in configs:
+            return False, {'name': "That rule no longer exists."}
+        previous = configs[config_name]
+        if (not previous.get('enabled', True)
+                and previous.get('disabled_reason') == DISABLED_REASON_REMOVED):
+            # A draft loaded before the bot left still says enabled and has no
+            # marker. Do not let an unrelated stale edit undo the automatic
+            # disable. A draft loaded after removal carries the marker, which
+            # distinguishes its explicit enable toggle from that stale save.
+            explicit_reenable = (
+                clean['enabled']
+                and payload.get('disabled_reason') == DISABLED_REASON_REMOVED
+            )
+            if not explicit_reenable:
+                clean['enabled'] = False
+                clean['disabled_reason'] = DISABLED_REASON_REMOVED
+        configs[config_name] = clean
+        await persistence.save_configuration()
+    log(f"Config UI: applied rule `{config_name}` in channel {channel_id}.")
+    return True, {}
+
+
+async def ui_create_config(app: AsyncApp, channel_id: str, config_name: str) -> tuple[bool, str]:
+    config_name = (config_name or "").strip()
+    if not CONFIG_NAME_PATTERN.fullmatch(config_name):
+        return False, "Names may use letters, numbers, and - _ . : / only."
+    async with state._config_write_lock:
+        configs = state.channel_config.setdefault(channel_id, {})
+        if config_name in configs:
+            return False, f"A rule named `{config_name}` already exists."
+        configs[config_name] = copy.deepcopy(DEFAULT_CONFIG)
+        await persistence.save_configuration()
+    log(f"Config UI: created rule `{config_name}` in channel {channel_id}.")
+    return True, ""
+
+
+async def ui_delete_config(app: AsyncApp, channel_id: str, config_name: str) -> tuple[bool, str]:
+    if config_name == DEFAULT_CONFIG_NAME:
+        return False, f"The `{DEFAULT_CONFIG_NAME}` rule can't be deleted."
+    async with state._config_write_lock:
+        configs = state.channel_config.get(channel_id, {})
+        if config_name not in configs:
+            return False, "That rule no longer exists."
+        del configs[config_name]
+        await persistence.save_configuration()
+    log(f"Config UI: deleted rule `{config_name}` in channel {channel_id}.")
+    return True, ""
+
+
+def ui_snapshot_configs(channel_id: str) -> dict:
+    """A deep copy of a channel's configs for read-only display."""
+    return copy.deepcopy(state.channel_config.get(channel_id, {}))
+
+
+def ui_meta() -> dict:
+    """Option lists and defaults the editor needs, sourced from the live constants."""
+    return {
+        'triggers': sorted(TRIGGERS),
+        'conditions': sorted(CONDITIONS),
+        'actions': sorted(ACTIONS),
+        'button_actions': sorted(BUTTON_ACTIONS),
+        'opsgenie_priorities': sorted(OPSGENIE_PRIORITIES),
+        'teams': sorted((t for t in state.team_cache if t and t != TEAM_UNKNOWN), key=lambda v: v.upper()),
+        'template_variables': sorted(SUPPORTED_TEMPLATE_VARIABLES),
+        'opsgenie_configured': state.opsgenie_configured,
+        'default_config': copy.deepcopy(DEFAULT_CONFIG),
+        'default_config_name': DEFAULT_CONFIG_NAME,
+        # Lets the UI brand itself per instance (e.g. "Hutbot (DEV)").
+        'bot_name': state.bot_name,
+        'slash_command': state.slash_command,
+    }
+
+
+async def maybe_start_web_ui(app: AsyncApp):
+    """Start the config web UI if HUTBOT_UI_ENABLED is set. Returns the aiohttp runner or None."""
+    if os.environ.get('HUTBOT_UI_ENABLED', '').strip().lower() not in ('1', 'true', 'yes', 'on'):
+        return None
+    try:
+        from webui import WebUIContext, start_web_ui
+    except Exception as e:
+        log_error("Web UI is enabled but the webui module failed to import:", e)
+        return None
+    host = os.environ.get('HUTBOT_UI_HOST', '0.0.0.0')
+    try:
+        port = int(os.environ.get('HUTBOT_UI_PORT', '8080'))
+    except ValueError:
+        port = 8080
+    ctx = WebUIContext(
+        user_header=os.environ.get('HUTBOT_UI_USER_HEADER', 'X-Forwarded-Email'),
+        resolve_user=lambda email: slackcache.get_user_by_email_strict(app, email),
+        list_channels=lambda user: list_user_config_channels(app, user),
+        is_member=lambda channel_id, user_id: slackcache.is_user_in_channel(app, channel_id, user_id),
+        get_configs=ui_snapshot_configs,
+        apply_config=lambda channel_id, name, payload: ui_apply_config(app, channel_id, name, payload),
+        create_config=lambda channel_id, name: ui_create_config(app, channel_id, name),
+        delete_config=lambda channel_id, name: ui_delete_config(app, channel_id, name),
+        meta=ui_meta,
+        bot_name=state.bot_name,
+    )
+    return await start_web_ui(ctx, host, port)
diff --git a/outlook.py b/outlook.py
new file mode 100644
index 0000000..28cfe7a
--- /dev/null
+++ b/outlook.py
@@ -0,0 +1,64 @@
+"""Outlook calendar integration.
+
+STUB ONLY. The real Microsoft Graph / Outlook integration is implemented in a
+separate task. This module exposes the interface the bot's condition engine
+relies on so the rest of the feature (scheduled triggers, conditions) can be
+built and tested today.
+
+Until the real implementation lands, calendar events are read from the
+``HUTBOT_OUTLOOK_STUB_EVENTS`` environment variable (a JSON array of
+``{"subject": str, "body": str}`` objects) or default to an empty list. Tests
+patch ``find_calendar_events`` directly.
+"""
+
+import json
+import os
+import re
+
+from employee_list import log_error, log_warning
+
+
+def _load_stub_events() -> list[dict]:
+    raw = os.environ.get("HUTBOT_OUTLOOK_STUB_EVENTS", "")
+    if not raw.strip():
+        return []
+    try:
+        events = json.loads(raw)
+    except json.JSONDecodeError as e:
+        log_error("Failed to decode HUTBOT_OUTLOOK_STUB_EVENTS:", e)
+        return []
+    if not isinstance(events, list):
+        log_warning("HUTBOT_OUTLOOK_STUB_EVENTS must be a JSON array; ignoring.")
+        return []
+    return [e for e in events if isinstance(e, dict)]
+
+
+async def find_calendar_events(subject_pattern: str = "", body_pattern: str = "") -> list[dict]:
+    """Return calendar events, optionally filtered by subject/body regex.
+
+    STUB: returns events from ``HUTBOT_OUTLOOK_STUB_EVENTS`` (or none). The real
+    implementation will query the Outlook/Microsoft Graph calendar API.
+    """
+    events = _load_stub_events()
+    if subject_pattern:
+        try:
+            sub_re = re.compile(subject_pattern, re.IGNORECASE)
+            events = [e for e in events if sub_re.search(e.get("subject", ""))]
+        except re.error as e:
+            log_error(f"Invalid outlook subject pattern '{subject_pattern}':", e)
+            return []
+    if body_pattern:
+        try:
+            body_re = re.compile(body_pattern, re.IGNORECASE)
+            events = [e for e in events if body_re.search(e.get("body", ""))]
+        except re.error as e:
+            log_error(f"Invalid outlook body pattern '{body_pattern}':", e)
+            return []
+    return events
+
+
+async def calendar_condition_met(subject_pattern: str = "", body_pattern: str = "", negate: bool = False) -> bool:
+    """True when a matching calendar event exists (or, if ``negate``, when none does)."""
+    events = await find_calendar_events(subject_pattern, body_pattern)
+    matched = len(events) > 0
+    return matched != negate
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..533390a
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,5 @@
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests", "test_query_employees.py"]
+python_files = ["test_*.py"]
+addopts = "-q"
diff --git a/requirements-dev.txt b/requirements-dev.txt
new file mode 100644
index 0000000..bf51dd4
--- /dev/null
+++ b/requirements-dev.txt
@@ -0,0 +1,3 @@
+-r requirements.txt
+pytest
+pytest-asyncio
diff --git a/requirements.txt b/requirements.txt
index 4994e90..d8c4785 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,4 +3,5 @@ slack_bolt
 asyncio
 aiohttp
 aiofiles
-unidecode
\ No newline at end of file
+unidecode
+croniter
\ No newline at end of file
diff --git a/test_bot.py b/test_bot.py
deleted file mode 100644
index cdf4c2d..0000000
--- a/test_bot.py
+++ /dev/null
@@ -1,1855 +0,0 @@
-import pytest
-import datetime
-from unittest.mock import AsyncMock, patch, call, MagicMock
-import json
-import tempfile
-import os
-from bot import (
-    replace_ids, Channel, User, Usergroup, get_team_of, process_command,
-    clean_slack_text, send_message, route_message, handle_channel_message,
-    scheduled_messages, set_work_hours, parse_time, is_work_day, is_work_time,
-    DEFAULT_CONFIG, migrate_and_apply_defaults, set_pattern, show_config,
-    handle_thread_response, handle_reaction_added, handle_message_deletion,
-    ScheduledReply, set_reply_message, schedule_reply,
-    load_replies_cache, flush_replies_cache, restore_scheduled_replies,
-    extract_message_text, _scheduled_replies_cache,
-    set_forward_channel, clear_forward_channel,
-    set_replies_enabled,
-)
-from slack_sdk.errors import SlackApiError
-import base64
-from bot import get_env_var
-
-def test_get_env_var_decoding_and_passthrough(monkeypatch):
-    encoded = base64.b64encode(b"hello world").decode("utf-8")
-    monkeypatch.setenv("MY_ENV_VAR", encoded)
-    assert get_env_var("MY_ENV_VAR") == "hello world"
-    monkeypatch.setenv("MY_ENV_VAR_PLAIN", "plain value")
-    assert get_env_var("MY_ENV_VAR_PLAIN") == "plain value"
-
-def test_extract_message_text_prefers_top_level_text():
-    event = {
-        "text": "Top-level text",
-        "attachments": [{"text": "Attachment text"}],
-    }
-
-    assert extract_message_text(event) == "Top-level text"
-
-def test_extract_message_text_extracts_attachment_text():
-    event = {
-        "text": "",
-        "attachments": [{
-            "text": "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
-        }],
-    }
-
-    assert extract_message_text(event) == "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
-
-def test_extract_message_text_includes_attachment_title_and_text():
-    event = {
-        "text": "",
-        "attachments": [{
-            "title": "[FIRING:1] FailedTemporalExecutions",
-            "text": "Alerts: temporal executions need operating.",
-            "fallback": "Noisy fallback",
-        }],
-    }
-
-    assert extract_message_text(event) == "[FIRING:1] FailedTemporalExecutions\nAlerts: temporal executions need operating."
-
-def test_extract_message_text_uses_fallback_only_without_cleaner_attachment_text():
-    event = {
-        "text": "",
-        "attachments": [{
-            "fallback": "[FIRING:1] FailedTemporalExecutions noisy fallback",
-        }],
-    }
-
-    assert extract_message_text(event) == "[FIRING:1] FailedTemporalExecutions noisy fallback"
-
-def test_extract_message_text_handles_missing_attachments():
-    assert extract_message_text({"text": ""}) == ""
-
-@pytest.mark.asyncio
-async def test_process_command_set_wait_time():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set wait-time 10", channel, user, thread_ts)
-        assert channel.configs["default"]["wait_time"] == 600
-        mock_send_message.assert_called_with(app, channel, user, "*Wait time* set to `10` minutes in configuration `default`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_process_command_set_wait_time_custom_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "my-config set wait-time 20", channel, user, thread_ts)
-        assert channel.configs["my-config"]["wait_time"] == 1200
-        mock_send_message.assert_called_with(app, channel, user, "*Wait time* set to `20` minutes in configuration `my-config`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_migrate_and_apply_defaults():
-    app = AsyncMock()
-    app.client.conversations_info.return_value = {"channel": {"id": "C123", "name": "general"}}
-
-    old_config = {
-        "C123": {
-            "wait_time": 60,
-            "reply_message": "Old message"
-        }
-    }
-
-    migrated_config = await migrate_and_apply_defaults(app, old_config)
-
-    assert "default" in migrated_config["C123"]
-    assert migrated_config["C123"]["default"]["wait_time"] == 60
-    assert migrated_config["C123"]["default"]["reply_message"] == "Old message"
-    assert migrated_config["C123"]["default"]["opsgenie"] is False
-    assert migrated_config["C123"]["default"]["opsgenie_schedule_name"] == ""
-    assert migrated_config["C123"]["default"]["opsgenie_priority"] == "P4"
-    assert migrated_config["C123"]["default"]["pattern"] is None
-
-@pytest.mark.asyncio
-async def test_process_command_set_opsgenie_schedule():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set opsgenie-schedule Team Primary", channel, user, thread_ts)
-        assert channel.configs["default"]["opsgenie_schedule_name"] == "Team Primary"
-        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie schedule* set to `Team Primary` in configuration `default`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_process_command_set_opsgenie_priority():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set opsgenie-priority P2", channel, user, thread_ts)
-        assert channel.configs["default"]["opsgenie_priority"] == "P2"
-        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie priority* set to `P2` in configuration `default`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_process_command_set_opsgenie_priority_custom_config_normalizes_case():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "alerts set opsgenie-priority p1", channel, user, thread_ts)
-        assert channel.configs["alerts"]["opsgenie_priority"] == "P1"
-        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie priority* set to `P1` in configuration `alerts`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_process_command_set_opsgenie_priority_rejects_invalid_value():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration') as mock_save, patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set opsgenie-priority P0", channel, user, thread_ts)
-
-    assert channel.configs["default"]["opsgenie_priority"] == "P4"
-    mock_save.assert_not_called()
-    sent_message = mock_send_message.call_args.args[3]
-    assert "Invalid *OpsGenie priority*" in sent_message
-    assert "`P1`, `P2`, `P3`, `P4`, `P5`" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_set_datetime_format_with_quotes_timezone_and_locale():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set datetime-format \"%a, %d %b %Y\" \"%H:%M\" Europe/Berlin de-DE", channel, user, thread_ts)
-
-    assert channel.configs["default"]["date_format"] == "%a, %d %b %Y"
-    assert channel.configs["default"]["time_format"] == "%H:%M"
-    assert channel.configs["default"]["datetime_timezone"] == "Europe/Berlin"
-    assert channel.configs["default"]["datetime_locale"] == "de_DE"
-    mock_send_message.assert_called_with(
-        app,
-        channel,
-        user,
-        "*Date/time format* set to date `%a, %d %b %Y` and time `%H:%M`, timezone `Europe/Berlin`, locale `de_DE` in configuration `default`.",
-        thread_ts
-    )
-
-@pytest.mark.asyncio
-async def test_process_command_set_datefmt_alias_rejects_invalid_timezone():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration') as mock_save, patch('bot.send_message') as mock_send_message:
-        await process_command(app, "set datefmt %Y %H:%M Mars/Base de-DE", channel, user, thread_ts)
-
-    mock_save.assert_not_called()
-    sent_message = mock_send_message.call_args.args[3]
-    assert "Invalid *date/time format*" in sent_message
-    assert "unknown timezone `Mars/Base`" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_list_opsgenie_schedules():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    response = AsyncMock()
-    response.status = 200
-    response.json = AsyncMock(return_value={
-        "data": [
-            {"name": "Zulu"},
-            {"name": "alpha"},
-        ]
-    })
-    response_context = AsyncMock()
-    response_context.__aenter__.return_value = response
-    response_context.__aexit__.return_value = None
-
-    session = MagicMock()
-    session.get.return_value = response_context
-    session_context = AsyncMock()
-    session_context.__aenter__.return_value = session
-    session_context.__aexit__.return_value = None
-
-    with patch('bot.get_env_var', return_value="token"), \
-         patch('bot.aiohttp.ClientSession', return_value=session_context), \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "list opsgenie-schedules", channel, user, thread_ts)
-
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "*OpsGenie schedules*:\n`alpha`\n`Zulu`",
-            thread_ts
-        )
-
-@pytest.mark.asyncio
-async def test_process_command_list_opsgenie_schedules_without_token():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.get_env_var', return_value=""), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "list opsgenie-schedules", channel, user, thread_ts)
-
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.",
-            thread_ts
-        )
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_uses_configured_schedule():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
-    user = User("U12345", "test", "Test User", "Testers")
-    on_call_user = User("U999", "oncall", "On Call User", "Ops")
-    thread_ts = "1234567890.123456"
-    start = "2026-04-26T08:00:00Z"
-    end = "2026-04-27T08:00:00Z"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=(start, end))) as mock_period, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_resolve.assert_awaited_once_with(app, "token", "Team Primary")
-    mock_period.assert_awaited_once_with("token", "Team Primary", "oncall@example.com")
-    mock_send_message.assert_called_with(
-        app,
-        channel,
-        user,
-        "*Schedule*: `Team Primary`\n"
-        "*On-call*: <@U999>\n"
-        f"*Start*: `{bot.format_opsgenie_datetime(start)}`\n"
-        f"*End*: `{bot.format_opsgenie_datetime(end)}`",
-        thread_ts
-    )
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_uses_explicit_schedule():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Configured Schedule"
-    user = User("U12345", "test", "Test User", "Testers")
-    on_call_user = User("U999", "oncall", "On Call User", "Ops")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-27T08:00:00Z"))) as mock_period, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call Team Secondary", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_resolve.assert_awaited_once_with(app, "token", "Team Secondary")
-    mock_period.assert_awaited_once_with("token", "Team Secondary", "oncall@example.com")
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Schedule*: `Team Secondary`" in sent_message
-    assert "*On-call*: <@U999>" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_uses_selected_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={
-        "default": DEFAULT_CONFIG.copy(),
-        "alerts": DEFAULT_CONFIG.copy(),
-    })
-    channel.configs["default"]["opsgenie_schedule_name"] = "Default Schedule"
-    channel.configs["alerts"]["opsgenie_schedule_name"] = "Alerts Schedule"
-    user = User("U12345", "test", "Test User", "Testers")
-    on_call_user = User("U999", "oncall", "On Call User", "Ops")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-27T08:00:00Z"))) as mock_period, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "alerts on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_resolve.assert_awaited_once_with(app, "token", "Alerts Schedule")
-    mock_period.assert_awaited_once_with("token", "Alerts Schedule", "oncall@example.com")
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Schedule*: `Alerts Schedule`" in sent_message
-    assert "*On-call*: <@U999>" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_falls_back_to_email_when_unmapped():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-    start = "2026-04-26T08:00:00Z"
-    end = "2026-04-27T08:00:00Z"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", None))), \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=(start, end))), \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*On-call*: oncall@example.com" in sent_message
-    assert f"*Start*: `{bot.format_opsgenie_datetime(start)}`" in sent_message
-    assert f"*End*: `{bot.format_opsgenie_datetime(end)}`" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_uses_upcoming_period_when_no_current_on_call():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Cloud Hosting_schedule"
-    user = User("U12345", "test", "Test User", "Testers")
-    upcoming_user = User("U999", "next", "Next User", "Ops")
-    thread_ts = "1234567890.123456"
-    start = "2026-04-28T08:00:00Z"
-    end = "2026-04-29T08:00:00Z"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("", None))) as mock_resolve, \
-         patch('bot.resolve_opsgenie_upcoming_on_call_period', new=AsyncMock(return_value=("next@example.com", start, end))) as mock_upcoming, \
-         patch('bot.resolve_slack_user_for_opsgenie_recipient', new=AsyncMock(return_value=upcoming_user)) as mock_slack_user, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_resolve.assert_awaited_once_with(app, "token", "Cloud Hosting_schedule")
-    mock_upcoming.assert_awaited_once_with("token", "Cloud Hosting_schedule")
-    mock_slack_user.assert_awaited_once_with(app, "next@example.com")
-    mock_send_message.assert_called_with(
-        app,
-        channel,
-        user,
-        "*Schedule*: `Cloud Hosting_schedule`\n"
-        "*On-call*: <@U999>\n"
-        f"*Start*: `{bot.format_opsgenie_datetime(start)}`\n"
-        f"*End*: `{bot.format_opsgenie_datetime(end)}`",
-        thread_ts
-    )
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_uses_configured_datetime_defaults():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
-    channel.configs["default"]["date_format"] = "%d.%m.%Y"
-    channel.configs["default"]["time_format"] = "%H:%M"
-    channel.configs["default"]["datetime_timezone"] = "Europe/Berlin"
-    user = User("U12345", "test", "Test User", "Testers")
-    on_call_user = User("U999", "oncall", "On Call User", "Ops")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))), \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-26T16:00:00Z"))), \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Start*: `26.04.2026 10:00`" in sent_message
-    assert "*End*: `26.04.2026 18:00`" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_errors_when_no_current_or_upcoming_on_call():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Cloud Hosting_schedule"
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock(return_value=("", None))), \
-         patch('bot.resolve_opsgenie_upcoming_on_call_period', new=AsyncMock(return_value=("", "", ""))), \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_send_message.assert_called_with(app, channel, user, "Failed to resolve on-call user for OpsGenie schedule `Cloud Hosting_schedule`.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_without_schedule():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock()) as mock_resolve, \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock()) as mock_period, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
-
-    mock_resolve.assert_not_awaited()
-    mock_period.assert_not_awaited()
-    mock_send_message.assert_called_with(
-        app,
-        channel,
-        user,
-        "No OpsGenie schedule configured. Use `/hutbot [config] set opsgenie-schedule <name>` or `/hutbot [config] on-call <schedule name>`.",
-        thread_ts
-    )
-
-@pytest.mark.asyncio
-async def test_process_command_on_call_without_token():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.resolve_opsgenie_on_call', new=AsyncMock()) as mock_resolve, \
-         patch('bot.resolve_opsgenie_on_call_period', new=AsyncMock()) as mock_period, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "on-call", channel, user, thread_ts)
-
-    mock_resolve.assert_not_awaited()
-    mock_period.assert_not_awaited()
-    mock_send_message.assert_called_with(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
-
-def test_find_opsgenie_on_call_period_prefers_matching_current_period():
-    import bot
-
-    data = {
-        "finalTimeline": {
-            "rotations": [{
-                "periods": [
-                    {
-                        "startDate": "2026-04-26T06:00:00Z",
-                        "endDate": "2026-04-26T08:00:00Z",
-                        "recipient": {"name": "previous@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-26T08:00:00Z",
-                        "endDate": "2026-04-27T08:00:00Z",
-                        "recipient": {"name": "oncall@example.com"},
-                    },
-                ],
-            }],
-        },
-    }
-    now = datetime.datetime(2026, 4, 26, 10, 0, tzinfo=datetime.timezone.utc)
-
-    assert bot.find_opsgenie_on_call_period(data, "oncall@example.com", now) == (
-        "2026-04-26T08:00:00Z",
-        "2026-04-27T08:00:00Z",
-    )
-
-def test_format_opsgenie_datetime_uses_local_timezone():
-    import bot
-
-    local_tz = datetime.timezone(datetime.timedelta(hours=2), "CEST")
-
-    assert bot.format_opsgenie_datetime("2026-04-26T08:00:00Z", local_tz) == "Sun, 26 Apr 2026 10:00"
-
-def test_format_datetime_value_supports_python_format_timezone_and_locale():
-    import bot
-
-    config = {
-        **DEFAULT_CONFIG.copy(),
-        "date_format": "%A, %d %B %Y",
-        "time_format": "%H:%M",
-        "datetime_timezone": "Europe/Berlin",
-        "datetime_locale": "de-DE",
-    }
-
-    assert bot.format_datetime_value("2026-04-26T08:00:00Z", "datetime", config) == "Sonntag, 26 April 2026 10:00"
-
-def test_format_datetime_value_supports_go_layout_args():
-    import bot
-
-    rendered = bot.format_datetime_value(
-        "2026-04-26T08:00:00Z",
-        "datetime",
-        DEFAULT_CONFIG.copy(),
-        {"fmt": "02.01.2006 15:04", "tz": "UTC", "lc": "en-us"},
-    )
-
-    assert rendered == "26.04.2026 08:00"
-
-def test_find_opsgenie_on_call_period_merges_adjacent_matching_periods():
-    import bot
-
-    data = {
-        "finalTimeline": {
-            "rotations": [{
-                "periods": [
-                    {
-                        "startDate": "2026-04-24T16:00:00Z",
-                        "endDate": "2026-04-26T17:19:04.912Z",
-                        "recipient": {"name": "oncall@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-26T17:19:04.912Z",
-                        "endDate": "2026-05-14T06:00:00Z",
-                        "recipient": {"name": "oncall@example.com"},
-                    },
-                    {
-                        "startDate": "2026-05-14T06:00:00Z",
-                        "endDate": "2026-05-31T22:00:00Z",
-                        "recipient": {"name": "next@example.com"},
-                    },
-                ],
-            }],
-        },
-    }
-    now = datetime.datetime(2026, 4, 26, 16, 35, tzinfo=datetime.timezone.utc)
-
-    assert bot.find_opsgenie_on_call_period(data, "oncall@example.com", now) == (
-        "2026-04-24T16:00:00Z",
-        "2026-05-14T06:00:00Z",
-    )
-
-def test_find_opsgenie_upcoming_on_call_period_selects_next_period():
-    import bot
-
-    data = {
-        "finalTimeline": {
-            "rotations": [{
-                "periods": [
-                    {
-                        "startDate": "2026-04-26T08:00:00Z",
-                        "endDate": "2026-04-26T10:00:00Z",
-                        "recipient": {"name": "past@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-27T08:00:00Z",
-                        "endDate": "2026-04-27T12:00:00Z",
-                        "recipient": {"name": "next@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-27T12:00:00Z",
-                        "endDate": "2026-04-27T18:00:00Z",
-                        "recipient": {"name": "next@example.com"},
-                    },
-                ],
-            }],
-        },
-    }
-    now = datetime.datetime(2026, 4, 26, 12, 0, tzinfo=datetime.timezone.utc)
-
-    assert bot.find_opsgenie_upcoming_on_call_period(data, now) == (
-        "next@example.com",
-        "2026-04-27T08:00:00Z",
-        "2026-04-27T18:00:00Z",
-    )
-
-def test_find_opsgenie_upcoming_on_call_period_skips_current_period():
-    import bot
-
-    data = {
-        "finalTimeline": {
-            "rotations": [{
-                "periods": [
-                    {
-                        "startDate": "2026-04-26T08:00:00Z",
-                        "endDate": "2026-04-26T12:00:00Z",
-                        "recipient": {"name": "current@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-26T12:00:00Z",
-                        "endDate": "2026-04-26T18:00:00Z",
-                        "recipient": {"name": "current@example.com"},
-                    },
-                    {
-                        "startDate": "2026-04-26T18:00:00Z",
-                        "endDate": "2026-04-26T20:00:00Z",
-                        "recipient": {"name": "next@example.com"},
-                    },
-                ],
-            }],
-        },
-    }
-    now = datetime.datetime(2026, 4, 26, 10, 0, tzinfo=datetime.timezone.utc)
-
-    assert bot.find_opsgenie_upcoming_on_call_period(data, now) == (
-        "next@example.com",
-        "2026-04-26T18:00:00Z",
-        "2026-04-26T20:00:00Z",
-    )
-
-@pytest.mark.asyncio
-async def test_resolve_opsgenie_on_call_period_requests_past_anchored_wide_timeline():
-    import bot
-
-    response = AsyncMock()
-    response.status = 200
-    response.json = AsyncMock(return_value={"data": {}})
-    response_context = AsyncMock()
-    response_context.__aenter__.return_value = response
-    response_context.__aexit__.return_value = None
-
-    session = MagicMock()
-    session.get.return_value = response_context
-    session_context = AsyncMock()
-    session_context.__aenter__.return_value = session
-    session_context.__aexit__.return_value = None
-
-    with patch('bot.aiohttp.ClientSession', return_value=session_context):
-        await bot.resolve_opsgenie_on_call_period("token", "Team Primary", "oncall@example.com")
-
-    params = session.get.call_args.kwargs["params"]
-    assert params["identifierType"] == "name"
-    assert params["interval"] == "6"
-    assert params["intervalUnit"] == "months"
-    assert params["date"].endswith("Z")
-
-@pytest.mark.asyncio
-async def test_process_command_set_pattern():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_pattern(app, channel, "default", '".*alarm.*"', "true", user, "")
-        assert channel.configs["default"]["pattern"] == ".*alarm.*"
-        assert channel.configs["default"]["pattern_case_sensitive"] is True
-        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `.*alarm.*` for configuration `default`. (case-sensitive)", "")
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_pattern(app, channel, "default", '"*"', None, user, "")
-        mock_send_message.assert_called_with(app, channel, user, "Invalid pattern: `nothing to repeat at position 0`", "")
-
-@pytest.mark.asyncio
-async def test_process_command_set_pattern_empty():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_pattern(app, channel, "default", '""', "true", user, "")
-        assert channel.configs["default"]["pattern"] == ""
-        assert channel.configs["default"]["pattern_case_sensitive"] is True
-        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `` for configuration `default`. (case-sensitive)", "")
-
-@pytest.mark.asyncio
-async def test_process_command_set_pattern_custom_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_pattern(app, channel, "my-config", '".*alarm.*"', "true", user, "")
-        assert channel.configs["my-config"]["pattern"] == ".*alarm.*"
-        assert channel.configs["my-config"]["pattern_case_sensitive"] is True
-        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `.*alarm.*` for configuration `my-config`. (case-sensitive)", "")
-
-@pytest.mark.asyncio
-async def test_handle_channel_message_multi_config_and_pattern():
-    app = AsyncMock()
-    configs = {
-        "config1": {"pattern": ".*alarm.*", "reply_message": "Alarm message"},
-        "config2": {"pattern": ".*report.*", "reply_message": "Report message"},
-        "config3": {"pattern": ".*nothing.*", "reply_message": "Nothing message"}
-    }
-
-    for name, cfg in configs.items():
-        for k, v in DEFAULT_CONFIG.items():
-            if k not in cfg:
-                cfg[k] = v
-
-    channel = Channel(id="C12345", name="general", configs=configs)
-    user = User(id="U12345", name="test", real_name="Test User", team="team1")
-
-    with patch('bot.is_work_day', return_value=True), \
-         patch('bot.schedule_reply') as mock_schedule_reply:
-
-        scheduled_messages.clear()
-        await handle_channel_message(app, "token", channel, user, "This is an alarm and a report", "1234.1")
-
-        assert mock_schedule_reply.call_count == 2
-
-        calls = [
-            call(app, "token", channel, configs["config1"], "config1", user, "This is an alarm and a report", "1234.1"),
-            call(app, "token", channel, configs["config2"], "config2", user, "This is an alarm and a report", "1234.1")
-        ]
-        mock_schedule_reply.assert_has_calls(calls, any_order=True)
-
-@pytest.mark.asyncio
-async def test_multi_cancel_thread_response():
-    app = AsyncMock()
-    configs = {
-        "config1": {**DEFAULT_CONFIG.copy(), "included_teams": ["A"]},
-        "config2": {**DEFAULT_CONFIG.copy(), "included_teams": ["B"]},
-    }
-    channel = Channel(id="C123", name="test-ch", configs=configs)
-    user1 = User(id="U1", name="user1", real_name="User One", team="A")
-    user2 = User(id="U2", name="user2", real_name="User Two", team="B")
-    ts = "12345.6789"
-
-    task1 = AsyncMock()
-    task1.cancel = MagicMock()
-    task2 = AsyncMock()
-    task2.cancel = MagicMock()
-
-    scheduled_messages.clear()
-    scheduled_messages[(channel.id, ts, "config1")] = ScheduledReply(task=task1, user_id=user1.id)
-    scheduled_messages[(channel.id, ts, "config2")] = ScheduledReply(task=task2, user_id=user1.id)
-
-    with patch('bot.get_user_by_id', return_value=user1):
-        await handle_thread_response(app, channel, user2, ts)
-
-    task1.cancel.assert_called_once()
-    task2.cancel.assert_not_called()
-    assert list(scheduled_messages.keys()) == [(channel.id, ts, "config2")]
-
-@pytest.mark.asyncio
-async def test_multi_cancel_reaction_added():
-    app = AsyncMock()
-    channel_id = "C123"
-    user1_id = "U1"
-    user2 = User(id="U2", name="user2", real_name="User Two", team="B")
-    ts = "12345.6789"
-    event = {'item': {'channel': channel_id, 'ts': ts}, 'user': user2.id}
-    configs = {
-        "config1": {**DEFAULT_CONFIG.copy(), "included_teams": ["A"]},
-        "config2": {**DEFAULT_CONFIG.copy(), "included_teams": ["B"]},
-    }
-    channel = Channel(id=channel_id, name="test-ch", configs=configs)
-
-    task1 = AsyncMock()
-    task1.cancel = MagicMock()
-    task2 = AsyncMock()
-    task2.cancel = MagicMock()
-
-    scheduled_messages.clear()
-    scheduled_messages[(channel_id, ts, "config1")] = ScheduledReply(task=task1, user_id=user1_id)
-    scheduled_messages[(channel_id, ts, "config2")] = ScheduledReply(task=task2, user_id=user1_id)
-
-    with patch('bot.get_channel_by_id', return_value=channel), patch('bot.get_user_by_id', side_effect=[user2, User(id=user1_id, name="user1", real_name="User One", team="A")]):
-        await handle_reaction_added(app, event)
-
-    task1.cancel.assert_called_once()
-    task2.cancel.assert_not_called()
-    assert list(scheduled_messages.keys()) == [(channel_id, ts, "config2")]
-
-@pytest.mark.asyncio
-async def test_handle_channel_message_ignores_bot_for_configs_without_include_bots():
-    app = AsyncMock()
-    configs = {
-        "bots": {**DEFAULT_CONFIG.copy(), "include_bots": True},
-        "humans": {**DEFAULT_CONFIG.copy(), "include_bots": False},
-    }
-    channel = Channel(id="C12345", name="general", configs=configs)
-    bot_user = User(id="B12345", name="alert-bot", real_name="Alert Bot", team="Bots")
-
-    with patch('bot.is_work_day', return_value=True), \
-         patch('bot.schedule_reply') as mock_schedule_reply:
-        scheduled_messages.clear()
-        await handle_channel_message(app, "token", channel, bot_user, "Alarm", "1234.1", actor_is_bot=True)
-
-    mock_schedule_reply.assert_called_once_with(app, "token", channel, configs["bots"], "bots", bot_user, "Alarm", "1234.1")
-
-@pytest.mark.asyncio
-async def test_route_message_schedules_bot_attachment_text_when_bots_included():
-    app = AsyncMock()
-    configs = {
-        "alerts": {
-            **DEFAULT_CONFIG.copy(),
-            "include_bots": True,
-            "pattern": "FailedTemporalExecutions",
-        },
-    }
-    channel = Channel(id="C12345", name="general", configs=configs)
-    bot_user = User(id="B12345", name="alertmanager", real_name="Alertmanager", team="Bots")
-    event = {
-        "type": "message",
-        "subtype": "bot_message",
-        "text": "",
-        "attachments": [{
-            "fallback": "[FIRING:1] FailedTemporalExecutions noisy fallback",
-            "text": "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating.",
-            "title": "[FIRING:1] FailedTemporalExecutions",
-        }],
-        "ts": "1234.1",
-        "bot_id": bot_user.id,
-        "channel": channel.id,
-        "event_ts": "1234.1",
-        "channel_type": "channel",
-    }
-
-    extracted_text = (
-        "[FIRING:1] FailedTemporalExecutions\n"
-        "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
-    )
-
-    with patch('bot.get_channel_by_id', return_value=channel), \
-         patch('bot.get_user_by_id', return_value=bot_user), \
-         patch('bot.is_work_day', return_value=True), \
-         patch('bot.flush_replies_cache', new=AsyncMock()), \
-         patch('bot.schedule_reply') as mock_schedule_reply:
-        scheduled_messages.clear()
-        _scheduled_replies_cache.clear()
-        await route_message(app, "token", event)
-
-    mock_schedule_reply.assert_called_once_with(app, "token", channel, configs["alerts"], "alerts", bot_user, extracted_text, "1234.1")
-    assert _scheduled_replies_cache[(channel.id, "1234.1", "alerts")]["text"] == extracted_text
-
-@pytest.mark.asyncio
-async def test_thread_response_by_bot_cancels_only_configs_without_include_bots():
-    app = AsyncMock()
-    configs = {
-        "bots": {**DEFAULT_CONFIG.copy(), "include_bots": True},
-        "humans": {**DEFAULT_CONFIG.copy(), "include_bots": False},
-    }
-    channel = Channel(id="C123", name="test-ch", configs=configs)
-    bot_user = User(id="B1", name="alert-bot", real_name="Alert Bot", team="Bots")
-    message_user = User(id="U1", name="user1", real_name="User One", team="A")
-    ts = "12345.6789"
-
-    task1 = AsyncMock()
-    task1.cancel = MagicMock()
-    task2 = AsyncMock()
-    task2.cancel = MagicMock()
-
-    scheduled_messages.clear()
-    scheduled_messages[(channel.id, ts, "bots")] = ScheduledReply(task=task1, user_id=message_user.id)
-    scheduled_messages[(channel.id, ts, "humans")] = ScheduledReply(task=task2, user_id=message_user.id)
-
-    with patch('bot.get_user_by_id', return_value=message_user):
-        await handle_thread_response(app, channel, bot_user, ts, actor_is_bot=True)
-
-    task1.cancel.assert_not_called()
-    task2.cancel.assert_called_once()
-    assert list(scheduled_messages.keys()) == [(channel.id, ts, "bots")]
-
-@pytest.mark.asyncio
-async def test_show_config():
-    app = AsyncMock()
-    configs = {
-        "alarms": {"pattern": ".*alarm.*", "wait_time": 300, "reply_message": "Alarm message"},
-        "default": {"wait_time": 600, "reply_message": "Default message"}
-    }
-    for name, cfg in configs.items():
-        for k, v in DEFAULT_CONFIG.items():
-            if k not in cfg:
-                cfg[k] = v
-    channel = Channel(id="C123", name="general", configs=configs)
-    user = User(id="U123", name="test", real_name="Test User", team="A")
-
-    with patch('bot.send_message') as mock_send_message:
-        await show_config(app, channel, user, "")
-
-        sent_message = mock_send_message.call_args.args[3]
-        assert "\n\n*Configuration*: `default` (enabled)" in sent_message
-        assert "> *Reply message*:\n> Default message\n>\n> *Forward channel*: <None>\n>\n> *Settings*:\n```" in sent_message
-        assert "OpsGenie schedule" in sent_message
-        assert "OpsGenie priority   P4" in sent_message
-        assert "Date format         %a, %d %b %Y" in sent_message
-        assert "Time format         %H:%M" in sent_message
-        assert "Date/time timezone  <server local>" in sent_message
-        assert "Date/time locale    <default>" in sent_message
-        assert "Wait time           10 minutes" in sent_message
-        assert "Default message" in sent_message
-        assert "\n\n*Configuration*: `alarms` (enabled)" in sent_message
-        assert "Wait time           5 minutes" in sent_message
-        assert "Pattern             .*alarm.* (case-insensitive)" in sent_message
-        assert "Alarm message" in sent_message
-
-@pytest.mark.asyncio
-async def test_show_config_displays_multiline_team_values():
-    app = AsyncMock()
-    config = {
-        **DEFAULT_CONFIG.copy(),
-        "excluded_teams": [
-            "Cloud Hosting",
-            "m-kubed (m³)",
-            "Systemarchitektur Infrastruktur/Technik",
-            "Site Reliability",
-        ],
-    }
-    channel = Channel(id="C123", name="general", configs={"default": config})
-    user = User(id="U123", name="test", real_name="Test User", team="A")
-
-    with patch('bot.send_message') as mock_send_message:
-        await show_config(app, channel, user, "")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert (
-        "Excluded teams      Cloud Hosting\n"
-        "                    m-kubed (m³)\n"
-        "                    Systemarchitektur Infrastruktur/Technik\n"
-        "                    Site Reliability"
-    ) in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_delete_config():
-    app = AsyncMock()
-    configs = {
-        "default": DEFAULT_CONFIG.copy(),
-        "todelete": DEFAULT_CONFIG.copy()
-    }
-    channel = Channel(id="C12345", name="general", configs=configs)
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        # Test deleting a config
-        await process_command(app, "delete config todelete", channel, user, thread_ts)
-        assert "todelete" not in channel.configs
-        mock_send_message.assert_called_with(app, channel, user, "Configuration `todelete` has been deleted.", thread_ts)
-
-        # Test deleting default config
-        await process_command(app, "delete config default", channel, user, thread_ts)
-        assert "default" in channel.configs
-        mock_send_message.assert_called_with(app, channel, user, "The `default` configuration cannot be deleted.", thread_ts)
-
-        # Test deleting non-existent config
-        await process_command(app, "delete config non-existent", channel, user, thread_ts)
-        mock_send_message.assert_called_with(app, channel, user, "Configuration `non-existent` not found.", thread_ts)
-
-@pytest.mark.asyncio
-async def test_set_reply_message_template():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_reply_message(
-            app,
-            channel,
-            "default",
-            "Hi {{user}}, {{user_name}}, {{team}}, {{channel}}, {{channel_name}}, {{message}}, {{message_link}}, {{config}}, {{wait_minutes}}, {{timestamp}}, {{opsgenie_current_user}}, {{opsgenie_current_email}}, {{opsgenie_current_name}}",
-            user,
-            ""
-        )
-
-        assert "{{user}}" in channel.configs["default"]["reply_message"]
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "*Reply message* set to: Hi {{user}}, {{user_name}}, {{team}}, {{channel}}, {{channel_name}}, {{message}}, {{message_link}}, {{config}}, {{wait_minutes}}, {{timestamp}}, {{opsgenie_current_user}}, {{opsgenie_current_email}}, {{opsgenie_current_name}} in configuration `default`.",
-            ""
-        )
-
-@pytest.mark.asyncio
-async def test_set_reply_message_template_accepts_datetime_args():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    message = (
-        "{{opsgenie_current_start_datetime(fmt=\"%d.%m.%Y %H:%M\", tz='Europe/Berlin', lc=de-DE)}} "
-        "{{opsgenie_next_start_datetime(format=02.01.2006 15:04, timezone=UTC, locale=en_us)}}"
-    )
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", message, user, "")
-
-    assert channel.configs["default"]["reply_message"] == message
-    assert mock_send_message.call_args.args[3] == f"*Reply message* set to: {message} in configuration `default`."
-
-@pytest.mark.asyncio
-async def test_set_reply_message_rejects_unknown_template_variable():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", "Hi {{unknown}}", user, "")
-
-        assert channel.configs["default"]["reply_message"] == "Anybody?"
-        sent_message = mock_send_message.call_args.args[3]
-        assert "unsupported template variable(s) `{{unknown}}`" in sent_message
-        assert "`{{user}}`" in sent_message
-        assert "`{{message_link}}`" in sent_message
-
-@pytest.mark.asyncio
-async def test_set_reply_message_rejects_malformed_datetime_args():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(fmt='%Y',)}}", user, "")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "Invalid *reply message*: malformed template expression" in sent_message
-    assert "missing argument after `,`" in sent_message
-
-@pytest.mark.asyncio
-async def test_set_reply_message_rejects_unknown_arg_invalid_timezone_and_locale():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(foo=bar)}}", user, "")
-    assert "unknown argument `foo`" in mock_send_message.call_args.args[3]
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(tz=Mars/Base)}}", user, "")
-    assert "unknown timezone `Mars/Base`" in mock_send_message.call_args.args[3]
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(lc=not-a-locale)}}", user, "")
-    assert "locale must look like" in mock_send_message.call_args.args[3]
-
-@pytest.mark.asyncio
-async def test_schedule_reply_renders_template_variables():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    config["reply_message"] = (
-        "Hi {{user}} ({{user_name}}) from {{team}} in {{channel}}/{{channel_name}}. "
-        "Config={{config}} Wait={{wait_minutes}} Ts={{timestamp}} "
-        "Message={{message}} Link={{message_link}}"
-    )
-
-    with patch('bot.send_message') as mock_send_message:
-        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
-
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "Hi <@U12345> (Test User) from Testers in #general/general. Config=alerts Wait=0 Ts=1234.1 Message=Original text Link=https://slack.test/message",
-            "1234.1"
-        )
-
-@pytest.mark.asyncio
-async def test_schedule_reply_cleans_up_scheduled_message_after_send():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    ts = "1234.1"
-    key = (channel.id, ts, "alerts")
-
-    scheduled_messages.clear()
-    scheduled_messages[key] = ScheduledReply(task=AsyncMock(), user_id=user.id)
-
-    with patch('bot.send_message') as mock_send_message:
-        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", ts)
-
-    mock_send_message.assert_called_once()
-    assert key not in scheduled_messages
-
-@pytest.mark.asyncio
-async def test_schedule_reply_renders_opsgenie_template_variables():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    config["opsgenie_schedule_name"] = "Team Primary"
-    config["reply_message"] = "On call: {{opsgenie_current_user}} / {{opsgenie_current_email}} / {{opsgenie_current_name}}"
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value={
-        "opsgenie_current_user": "<@U999>",
-        "opsgenie_current_email": "oncall@example.com",
-        "opsgenie_current_name": "On Call User",
-    })), patch('bot.send_message') as mock_send_message:
-        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
-
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "On call: <@U999> / oncall@example.com / On Call User",
-            "1234.1"
-        )
-
-@pytest.mark.asyncio
-async def test_get_opsgenie_template_variables_renders_current_and_next_periods():
-    import bot
-
-    app = AsyncMock()
-    current_user = User("U999", "oncall", "On Call User", "Ops")
-    next_user = User("U998", "next", "Next User", "Ops")
-    config = {
-        **DEFAULT_CONFIG.copy(),
-        "opsgenie_schedule_name": "Team Primary",
-        "date_format": "%d.%m.%Y",
-        "time_format": "%H:%M",
-        "datetime_timezone": "Europe/Berlin",
-    }
-    context = bot.OpsGenieContext(
-        "Team Primary",
-        bot.OpsGeniePeriod("oncall@example.com", current_user, "2026-04-26T08:00:00Z", "2026-04-26T16:00:00Z"),
-        bot.OpsGeniePeriod("next@example.com", next_user, "2026-04-27T08:00:00Z", "2026-04-27T16:00:00Z"),
-    )
-
-    with patch('bot.resolve_opsgenie_on_call_context', new=AsyncMock(return_value=context)):
-        variables = await bot.get_opsgenie_template_variables(app, "token", config)
-
-    assert variables["opsgenie_schedule_name"] == "Team Primary"
-    assert variables["opsgenie_current_user"] == "<@U999>"
-    assert variables["opsgenie_current_email"] == "oncall@example.com"
-    assert variables["opsgenie_current_name"] == "On Call User"
-    assert variables["opsgenie_current_start_datetime"] == "26.04.2026 10:00"
-    assert variables["opsgenie_current_end_time"] == "18:00"
-    assert variables["opsgenie_next_user"] == "<@U998>"
-    assert variables["opsgenie_next_email"] == "next@example.com"
-    assert variables["opsgenie_next_start_datetime"] == "27.04.2026 10:00"
-
-@pytest.mark.asyncio
-async def test_get_opsgenie_template_variables_keeps_current_placeholders_when_only_next_exists():
-    import bot
-
-    app = AsyncMock()
-    next_user = User("U998", "next", "Next User", "Ops")
-    config = {
-        **DEFAULT_CONFIG.copy(),
-        "opsgenie_schedule_name": "Team Primary",
-        "datetime_timezone": "UTC",
-    }
-    context = bot.OpsGenieContext(
-        "Team Primary",
-        bot.OpsGeniePeriod("", None, "", ""),
-        bot.OpsGeniePeriod("next@example.com", next_user, "2026-04-27T08:00:00Z", "2026-04-27T16:00:00Z"),
-    )
-
-    with patch('bot.resolve_opsgenie_on_call_context', new=AsyncMock(return_value=context)):
-        variables = await bot.get_opsgenie_template_variables(app, "token", config)
-
-    assert variables["opsgenie_current_user"] == "<no-user-set>"
-    assert variables["opsgenie_current_email"] == "<no-email-set>"
-    assert variables["opsgenie_current_start_datetime"] == "<unknown>"
-    assert variables["opsgenie_next_user"] == "<@U998>"
-    assert variables["opsgenie_next_start_datetime"] == "Mon, 27 Apr 2026 08:00"
-
-def test_render_reply_message_template_datetime_args_override_config():
-    import bot
-
-    config = {
-        **DEFAULT_CONFIG.copy(),
-        "date_format": "%d.%m.%Y",
-        "time_format": "%H:%M",
-        "datetime_timezone": "Europe/Berlin",
-    }
-    variables = bot.get_opsgenie_placeholder_variables(config)
-    raw_key = "__opsgenie_current_start_datetime_raw"
-    variables[raw_key] = "2026-04-26T08:00:00Z"
-
-    rendered = bot.render_reply_message_template(
-        "{{opsgenie_current_start_datetime(format='02.01.2006 15:04', timezone='UTC', locale='en_US')}}",
-        variables,
-        config,
-    )
-
-    assert rendered == "26.04.2026 08:00"
-
-@pytest.mark.asyncio
-async def test_schedule_reply_uses_placeholder_for_unmapped_opsgenie_user():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    config["opsgenie_schedule_name"] = "Team Primary"
-    config["reply_message"] = "On call: {{opsgenie_current_user}} / {{opsgenie_current_email}} / {{opsgenie_current_name}}"
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value={
-        "opsgenie_current_user": "<unknown-oncall>",
-        "opsgenie_current_email": "oncall@example.com",
-        "opsgenie_current_name": "oncall@example.com",
-    })), patch('bot.send_message') as mock_send_message:
-        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
-
-        mock_send_message.assert_called_with(
-            app,
-            channel,
-            user,
-            "On call: <unknown-oncall> / oncall@example.com / oncall@example.com",
-            "1234.1"
-        )
-
-@pytest.mark.asyncio
-async def test_schedule_reply_keeps_plain_message_unchanged():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    config["reply_message"] = "Anybody?"
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock()) as mock_get_opsgenie_template_variables, \
-         patch('bot.send_message') as mock_send_message:
-        await schedule_reply(app, "token", channel, config, "default", user, "Original text", "1234.1")
-
-        mock_get_opsgenie_template_variables.assert_not_awaited()
-        mock_send_message.assert_called_with(app, channel, user, "Anybody?", "1234.1")
-
-@pytest.mark.asyncio
-async def test_post_opsgenie_alert_uses_configured_priority():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["opsgenie_priority"] = "P2"
-
-    response = AsyncMock()
-    response.status = 202
-    response_context = AsyncMock()
-    response_context.__aenter__.return_value = response
-    response_context.__aexit__.return_value = None
-
-    session = MagicMock()
-    session.post.return_value = response_context
-    session_context = AsyncMock()
-    session_context.__aenter__.return_value = session
-    session_context.__aexit__.return_value = None
-
-    with patch('bot.aiohttp.ClientSession', return_value=session_context):
-        await bot.post_opsgenie_alert(app, "token", channel, config, user, "Original text", "1234.1", "https://slack.test/message")
-
-    payload = json.loads(session.post.call_args.kwargs["data"])
-    assert payload["priority"] == "P2"
-
-@pytest.mark.asyncio
-async def test_post_opsgenie_alert_defaults_to_p4_without_configured_priority():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config.pop("opsgenie_priority")
-
-    response = AsyncMock()
-    response.status = 202
-    response_context = AsyncMock()
-    response_context.__aenter__.return_value = response
-    response_context.__aexit__.return_value = None
-
-    session = MagicMock()
-    session.post.return_value = response_context
-    session_context = AsyncMock()
-    session_context.__aenter__.return_value = session
-    session_context.__aexit__.return_value = None
-
-    with patch('bot.aiohttp.ClientSession', return_value=session_context):
-        await bot.post_opsgenie_alert(app, "token", channel, config, user, "Original text", "1234.1", "https://slack.test/message")
-
-    payload = json.loads(session.post.call_args.kwargs["data"])
-    assert payload["priority"] == "P4"
-
-@pytest.mark.asyncio
-async def test_process_command_test_renders_default_reply_and_variables():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    channel.configs["default"]["wait_time"] = 600
-    channel.configs["default"]["reply_message"] = "Hi {{user}}, wait {{wait_minutes}} in {{channel}}: {{message_link}}"
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value={
-        "opsgenie_current_user": "<@U999>",
-        "opsgenie_current_email": "oncall@example.com",
-        "opsgenie_current_name": "On Call User",
-    })) as mock_get_opsgenie_template_variables, patch('bot.send_message') as mock_send_message:
-        await process_command(app, "test", channel, user)
-
-    mock_get_opsgenie_template_variables.assert_awaited_once()
-    app.client.chat_getPermalink.assert_not_called()
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Reply preview for configuration `default`:*" in sent_message
-    assert "Hi <@U12345>, wait 10 in #general: " in sent_message
-    assert "`{{channel}}`: #general" in sent_message
-    assert "`{{config}}`: default" in sent_message
-    assert "`{{message}}`: " in sent_message
-    assert "`{{message_link}}`: " in sent_message
-    assert "`{{opsgenie_current_user}}`: <@U999>" in sent_message
-    assert "`{{timestamp}}`: " in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_test_uses_selected_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={
-        "default": DEFAULT_CONFIG.copy(),
-        "alerts": DEFAULT_CONFIG.copy(),
-    })
-    channel.configs["alerts"]["wait_time"] = 120
-    channel.configs["alerts"]["reply_message"] = "Config {{config}} waits {{wait_minutes}}: {{message}}"
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value={})), patch('bot.send_message') as mock_send_message:
-        await process_command(app, "alerts test", channel, user)
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Reply preview for configuration `alerts`:*" in sent_message
-    assert "Config alerts waits 2: " in sent_message
-    assert "`{{config}}`: alerts" in sent_message
-    assert "`{{wait_minutes}}`: 2" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_mention_test_uses_trailing_text_as_message():
-    import bot
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["reply_message"] = "Preview: {{message}} {{timestamp}} {{message_link}}"
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch.object(bot, 'bot_user_id', "UBOT"), \
-         patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value={})), \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "<@UBOT> test hello world", channel, user, "1234.1", allow_test_message=True, command_ts="1234.1")
-
-    app.client.chat_getPermalink.assert_awaited_once_with(channel="C12345", message_ts="1234.1")
-    sent_message = mock_send_message.call_args.args[3]
-    assert "Preview: hello world 1234.1 https://slack.test/message" in sent_message
-    assert "`{{message}}`: hello world" in sent_message
-    assert "`{{timestamp}}`: 1234.1" in sent_message
-    assert "`{{message_link}}`: https://slack.test/message" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_slash_test_with_trailing_text_is_unknown():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock()) as mock_get_opsgenie_template_variables, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "test hello world", channel, user)
-
-    mock_get_opsgenie_template_variables.assert_not_awaited()
-    mock_send_message.assert_called_with(app, channel, user, "Huh? :thinking_face: Maybe type `/hutbot help` for a list of commands.", "")
-
-@pytest.mark.asyncio
-async def test_process_command_news_mentions_on_call_and_test_commands():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send_message:
-        await process_command(app, "news", channel, user)
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "`/hutbot [config] on-call [schedule name]`" in sent_message
-    assert "`/hutbot [config] test`" in sent_message
-    assert "`@Hutbot [config] test <message>`" in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_help_uses_compact_command_reference():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send_message:
-        await process_command(app, "help", channel, user)
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Show All Configurations:*" in sent_message
-    assert "Either use the command `/hutbot` or just `@Hutbot` me." in sent_message
-    assert "```/hutbot show config\n@Hutbot show config```" in sent_message
-    assert "Displays all configurations for `#team-asylum`." in sent_message
-    assert "*Commands:*\n```" in sent_message
-    assert "/hutbot [config] set wait-time <minutes>" in sent_message
-    assert "Set reminder delay." in sent_message
-    assert "@Hutbot [config] test <message>" in sent_message
-    assert "Preview reply with <message> as {{message}}." in sent_message
-    assert "*Enable OpsGenie Integration:*" not in sent_message
-
-@pytest.mark.asyncio
-async def test_process_command_test_uses_opsgenie_placeholders_when_unavailable():
-    import bot
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    channel.configs["default"]["reply_message"] = "Anybody?"
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.get_opsgenie_template_variables', new=AsyncMock(return_value=bot.get_opsgenie_placeholder_variables())) as mock_get_opsgenie_template_variables, \
-         patch('bot.send_message') as mock_send_message:
-        await process_command(app, "test", channel, user, opsgenie_token="token")
-
-    mock_get_opsgenie_template_variables.assert_awaited_once_with(app, "token", channel.configs["default"])
-    sent_message = mock_send_message.call_args.args[3]
-    assert "`{{opsgenie_current_user}}`: <no-user-set>" in sent_message
-    assert "`{{opsgenie_current_email}}`: <no-email-set>" in sent_message
-    assert "`{{opsgenie_current_name}}`: <no-name-set>" in sent_message
-
-@pytest.mark.asyncio
-async def test_load_and_flush_replies_cache_roundtrip():
-    import bot
-    entry = {
-        'channel_id': 'C123',
-        'ts': '1000.1',
-        'config_name': 'default',
-        'user_id': 'U456',
-        'text': 'hello',
-        'send_at': '2026-04-23T13:00:00',
-    }
-    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
-        json.dump([entry], f)
-        tmp_path = f.name
-
-    try:
-        with patch('bot.SCHEDULED_REPLIES_CACHE_FILE', tmp_path):
-            bot._scheduled_replies_cache.clear()
-            await load_replies_cache()
-            assert ('C123', '1000.1', 'default') in bot._scheduled_replies_cache
-
-            bot._scheduled_replies_cache[('C123', '1000.1', 'default')]['text'] = 'updated'
-            await flush_replies_cache()
-
-            with open(tmp_path) as f:
-                data = json.load(f)
-            assert data[0]['text'] == 'updated'
-    finally:
-        os.unlink(tmp_path)
-        bot._scheduled_replies_cache.clear()
-
-@pytest.mark.asyncio
-async def test_load_replies_cache_handles_missing_file():
-    import bot
-    with patch('bot.SCHEDULED_REPLIES_CACHE_FILE', '/nonexistent/path/to/cache.json'):
-        bot._scheduled_replies_cache.clear()
-        await load_replies_cache()
-        assert bot._scheduled_replies_cache == {}
-
-@pytest.mark.asyncio
-async def test_restore_scheduled_replies_skips_unknown_channel():
-    import bot
-    bot._scheduled_replies_cache.clear()
-    bot._scheduled_replies_cache[('C_GONE', '1000.1', 'default')] = {
-        'channel_id': 'C_GONE',
-        'ts': '1000.1',
-        'config_name': 'default',
-        'user_id': 'U1',
-        'text': 'msg',
-        'send_at': (datetime.datetime.now() + datetime.timedelta(seconds=60)).isoformat(),
-    }
-    app = AsyncMock()
-    scheduled_messages.clear()
-
-    with patch('bot.channel_config', {}), patch('bot.flush_replies_cache', new=AsyncMock()):
-        await restore_scheduled_replies(app, "token")
-
-    assert len(scheduled_messages) == 0
-    assert bot._scheduled_replies_cache == {}
-
-@pytest.mark.asyncio
-async def test_restore_scheduled_replies_schedules_with_remaining_time():
-    import bot
-    import asyncio
-    future = datetime.datetime.now() + datetime.timedelta(seconds=300)
-    bot._scheduled_replies_cache.clear()
-    bot._scheduled_replies_cache[('C123', '1000.1', 'default')] = {
-        'channel_id': 'C123',
-        'ts': '1000.1',
-        'config_name': 'default',
-        'user_id': 'U456',
-        'text': 'hello',
-        'send_at': future.isoformat(),
-    }
-    config = {**DEFAULT_CONFIG.copy(), 'wait_time': 1800}
-    app = AsyncMock()
-    app.client.conversations_info.return_value = {'channel': {'name': 'general'}}
-    scheduled_messages.clear()
-
-    captured_override = []
-
-    async def fake_schedule_reply(*args, wait_time_override=None, **kwargs):
-        captured_override.append(wait_time_override)
-
-    with patch('bot.channel_config', {'C123': {'default': config}}), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User('U456', 'user', 'User', 'Team'))), \
-         patch('bot.schedule_reply', side_effect=fake_schedule_reply), \
-         patch('bot.flush_replies_cache', new=AsyncMock()):
-        await restore_scheduled_replies(app, "token")
-        await asyncio.gather(*[sr.task for sr in scheduled_messages.values()])
-
-    assert len(captured_override) == 1
-    assert 290 <= captured_override[0] <= 310
-
-@pytest.mark.asyncio
-async def test_restore_scheduled_replies_sends_immediately_when_overdue():
-    import bot
-    import asyncio
-    past = datetime.datetime.now() - datetime.timedelta(seconds=60)
-    bot._scheduled_replies_cache.clear()
-    bot._scheduled_replies_cache[('C123', '1000.1', 'default')] = {
-        'channel_id': 'C123',
-        'ts': '1000.1',
-        'config_name': 'default',
-        'user_id': 'U456',
-        'text': 'hello',
-        'send_at': past.isoformat(),
-    }
-    config = {**DEFAULT_CONFIG.copy(), 'wait_time': 1800}
-    app = AsyncMock()
-    app.client.conversations_info.return_value = {'channel': {'name': 'general'}}
-    scheduled_messages.clear()
-
-    captured_override = []
-
-    async def fake_schedule_reply(*args, wait_time_override=None, **kwargs):
-        captured_override.append(wait_time_override)
-
-    with patch('bot.channel_config', {'C123': {'default': config}}), \
-         patch('bot.get_user_by_id', new=AsyncMock(return_value=User('U456', 'user', 'User', 'Team'))), \
-         patch('bot.schedule_reply', side_effect=fake_schedule_reply), \
-         patch('bot.flush_replies_cache', new=AsyncMock()):
-        await restore_scheduled_replies(app, "token")
-        await asyncio.gather(*[sr.task for sr in scheduled_messages.values()])
-
-    assert captured_override[0] == 0.0
-
-@pytest.mark.asyncio
-async def test_schedule_reply_removes_entry_from_cache():
-    import bot
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": ""}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = DEFAULT_CONFIG.copy()
-    config["wait_time"] = 0
-    ts = "9999.1"
-    key = (channel.id, ts, "default")
-
-    bot._scheduled_replies_cache.clear()
-    bot._scheduled_replies_cache[key] = {'channel_id': channel.id, 'ts': ts, 'config_name': 'default', 'user_id': user.id, 'text': 'x', 'send_at': '2026-01-01T00:00:00'}
-
-    with patch('bot.send_message'), patch('bot.flush_replies_cache', new=AsyncMock()):
-        await schedule_reply(app, "token", channel, config, "default", user, "x", ts)
-
-    assert key not in bot._scheduled_replies_cache
-
-
-@pytest.mark.asyncio
-async def test_set_forward_channel_with_mention():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_forward_channel(app, channel, "default", "<#CFWDCHAN|forward-channel>", user, thread_ts)
-
-    assert channel.configs["default"]["forward_channel"] == "CFWDCHAN"
-    app.client.chat_postMessage.assert_awaited_once_with(
-        channel="CFWDCHAN",
-        text="Reply messages from #general (config `default`) will now be forwarded here by Hutbot :palm_up_hand::tophat:",
-        mrkdwn=True,
-    )
-    mock_send_message.assert_called_with(app, channel, user, "*Forward channel* set to <#CFWDCHAN> in configuration `default`.", thread_ts)
-
-
-@pytest.mark.asyncio
-async def test_set_forward_channel_with_bare_id():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await set_forward_channel(app, channel, "default", "CFWDCHAN", user)
-
-    assert channel.configs["default"]["forward_channel"] == "CFWDCHAN"
-    mock_send_message.assert_called_with(app, channel, user, "*Forward channel* set to <#CFWDCHAN> in configuration `default`.", "")
-
-
-@pytest.mark.asyncio
-async def test_set_forward_channel_rejects_invalid_ref():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_forward_channel(app, channel, "default", "not-a-channel", user, thread_ts)
-
-    assert channel.configs["default"].get("forward_channel") == ""
-    app.client.chat_postMessage.assert_not_awaited()
-    mock_send_message.assert_called_with(app, channel, user, "Invalid channel: `not-a-channel`. Use a #channel mention.", thread_ts)
-
-
-@pytest.mark.asyncio
-async def test_set_forward_channel_reports_api_error():
-    app = AsyncMock()
-    app.client.chat_postMessage.side_effect = SlackApiError("not_in_channel", {"error": "not_in_channel"})
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.send_message') as mock_send_message:
-        await set_forward_channel(app, channel, "default", "<#CFWDCHAN|forward-channel>", user, thread_ts)
-
-    assert channel.configs["default"].get("forward_channel") == ""
-    mock_send_message.assert_called_with(app, channel, user, "Cannot post to <#CFWDCHAN>: `not_in_channel`.", thread_ts)
-
-
-@pytest.mark.asyncio
-async def test_clear_forward_channel():
-    app = AsyncMock()
-    config = {**DEFAULT_CONFIG.copy(), "forward_channel": "CFWDCHAN"}
-    channel = Channel(id="C12345", name="general", configs={"default": config})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send_message:
-        await clear_forward_channel(app, channel, "default", user, thread_ts)
-
-    assert "forward_channel" not in channel.configs["default"]
-    mock_send_message.assert_called_with(app, channel, user, "*Forward channel* cleared in configuration `default`.", thread_ts)
-
-
-@pytest.mark.asyncio
-async def test_show_config_displays_forward_channel():
-    app = AsyncMock()
-    config = {**DEFAULT_CONFIG.copy(), "forward_channel": "CFWDCHAN"}
-    channel = Channel(id="C123", name="general", configs={"default": config})
-    user = User(id="U123", name="test", real_name="Test User", team="A")
-
-    with patch('bot.send_message') as mock_send_message:
-        await show_config(app, channel, user, "")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Forward channel*: <#CFWDCHAN>" in sent_message
-
-
-@pytest.mark.asyncio
-async def test_show_config_displays_none_for_missing_forward_channel():
-    app = AsyncMock()
-    channel = Channel(id="C123", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User(id="U123", name="test", real_name="Test User", team="A")
-
-    with patch('bot.send_message') as mock_send_message:
-        await show_config(app, channel, user, "")
-
-    sent_message = mock_send_message.call_args.args[3]
-    assert "*Forward channel*: <None>" in sent_message
-
-
-@pytest.mark.asyncio
-async def test_schedule_reply_forwards_to_configured_channel():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/p123"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = {**DEFAULT_CONFIG.copy(), "wait_time": 0, "reply_message": "Anybody?", "forward_channel": "CFWDCHAN"}
-
-    with patch('bot.send_message'):
-        await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
-
-    app.client.chat_postMessage.assert_awaited_once_with(
-        channel="CFWDCHAN",
-        text="Anybody?\n\n*Original message in #general:* https://slack.test/p123",
-        mrkdwn=True,
-    )
-
-
-@pytest.mark.asyncio
-async def test_schedule_reply_skips_forward_when_not_configured():
-    app = AsyncMock()
-    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/p123"}
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-    config = {**DEFAULT_CONFIG.copy(), "wait_time": 0, "reply_message": "Anybody?"}
-
-    with patch('bot.send_message'):
-        await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
-
-    app.client.chat_postMessage.assert_not_awaited()
-
-
-@pytest.mark.asyncio
-async def test_process_command_set_forward_channel():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await process_command(app, "set forward-channel <#CFWDCHAN|logs>", channel, user, thread_ts)
-
-    assert channel.configs["default"]["forward_channel"] == "CFWDCHAN"
-
-
-@pytest.mark.asyncio
-async def test_process_command_clear_forward_channel():
-    app = AsyncMock()
-    config = {**DEFAULT_CONFIG.copy(), "forward_channel": "CFWDCHAN"}
-    channel = Channel(id="C12345", name="general", configs={"default": config})
-    user = User("U12345", "test", "Test User", "Testers")
-    thread_ts = "1234567890.123456"
-
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await process_command(app, "clear forward-channel", channel, user, thread_ts)
-
-    assert "forward_channel" not in channel.configs["default"]
-
-
-@pytest.mark.asyncio
-async def test_set_replies_enabled_enables():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send:
-        await set_replies_enabled(app, channel, "default", True, user)
-
-    assert channel.configs["default"]["enabled"] is True
-    mock_send.assert_awaited_once()
-    assert "enabled" in mock_send.call_args[0][3]
-
-
-@pytest.mark.asyncio
-async def test_set_replies_enabled_disables():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message') as mock_send:
-        await set_replies_enabled(app, channel, "default", False, user)
-
-    assert channel.configs["default"]["enabled"] is False
-    assert "disabled" in mock_send.call_args[0][3]
-
-
-@pytest.mark.asyncio
-async def test_set_replies_enabled_creates_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await set_replies_enabled(app, channel, "newcfg", False, user)
-
-    assert "newcfg" in channel.configs
-    assert channel.configs["newcfg"]["enabled"] is False
-
-
-@pytest.mark.asyncio
-async def test_handle_channel_message_skips_disabled_config():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={
-        "active": {**DEFAULT_CONFIG.copy(), "enabled": True, "wait_time": 0},
-        "silent": {**DEFAULT_CONFIG.copy(), "enabled": False, "wait_time": 0},
-    })
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.schedule_reply') as mock_schedule, patch('bot.flush_replies_cache'):
-        await handle_channel_message(app, "", channel, user, "hello", "1234.1")
-
-    called_config_names = [call[0][4] for call in mock_schedule.call_args_list]
-    assert "active" in called_config_names
-    assert "silent" not in called_config_names
-
-
-@pytest.mark.asyncio
-async def test_handle_channel_message_enabled_by_default():
-    app = AsyncMock()
-    config = DEFAULT_CONFIG.copy()
-    config.pop("enabled", None)
-    channel = Channel(id="C12345", name="general", configs={"default": {**config, "wait_time": 0}})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.schedule_reply') as mock_schedule, patch('bot.flush_replies_cache'):
-        await handle_channel_message(app, "", channel, user, "hello", "1234.1")
-
-    assert mock_schedule.called
-
-
-@pytest.mark.asyncio
-async def test_show_config_displays_replies_enabled():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": True}})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send:
-        await show_config(app, channel, user)
-
-    sent_message = mock_send.call_args[0][3]
-    assert "\n\n*Configuration*: `default` (enabled)" in sent_message
-
-
-@pytest.mark.asyncio
-async def test_show_config_displays_replies_disabled():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.send_message') as mock_send:
-        await show_config(app, channel, user)
-
-    sent_message = mock_send.call_args[0][3]
-    assert "\n\n*Configuration*: `default` (disabled)" in sent_message
-
-
-@pytest.mark.asyncio
-async def test_process_command_enable_replies():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await process_command(app, "enable", channel, user)
-
-    assert channel.configs["default"]["enabled"] is True
-
-
-@pytest.mark.asyncio
-async def test_process_command_disable_replies():
-    app = AsyncMock()
-    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
-    user = User("U12345", "test", "Test User", "Testers")
-
-    with patch('bot.save_configuration'), patch('bot.send_message'):
-        await process_command(app, "disable", channel, user)
-
-    assert channel.configs["default"]["enabled"] is False
diff --git a/tests/__init__.py b/tests/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/_common.py b/tests/_common.py
new file mode 100644
index 0000000..7032758
--- /dev/null
+++ b/tests/_common.py
@@ -0,0 +1,102 @@
+"""Shared imports, helpers, and hutbot module aliases for the test suite."""
+
+import os
+import re
+import json
+import base64
+import tempfile
+import asyncio
+import datetime
+from types import SimpleNamespace
+from zoneinfo import ZoneInfo
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, mock_open, patch, call
+
+import outlook
+from slack_sdk.errors import SlackApiError
+from employee_list import get_env_var
+
+from hutbot.models import Channel, User, Usergroup, ScheduledReply
+from hutbot.constants import (
+    ACTION_DM_USER,
+    ACTION_GROUP_DM,
+    ACTION_POST_CHANNEL,
+    ACTION_REPLY,
+    DEFAULT_CONFIG,
+    DISABLED_REASON_REMOVED,
+    ESCALATION_NONE,
+    TEAM_UNKNOWN,
+    TRIGGER_CRON,
+    bot_slug,
+    normalize_slash_command,
+)
+from hutbot.textutil import extract_message_text
+from hutbot.datetimefmt import parse_time, is_work_day, is_work_time
+from hutbot.persistence import migrate_and_apply_defaults, load_replies_cache, flush_replies_cache
+from hutbot.slackcache import get_channel_members, is_user_in_channel
+from hutbot.messaging import replace_ids, clean_slack_text, send_message
+from hutbot.scheduling import schedule_reply, restore_scheduled_replies
+from hutbot.routing import (
+    route_message, handle_channel_message, handle_thread_response,
+    handle_reaction_added, handle_message_deletion, register_app_handlers,
+    handle_bot_added_to_channel, handle_bot_removed_from_channel,
+    cancel_channel_scheduled_replies, is_bot_membership_event,
+)
+from hutbot.webui_backend import (
+    validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config, ui_meta,
+)
+from hutbot.commands.dispatch import process_command
+from hutbot.commands.setters import (
+    set_work_hours, set_pattern, set_reply_message,
+    set_replies_enabled,
+)
+from hutbot.commands.info import get_team_of, show_config
+
+import hutbot
+import hutbot.state
+import hutbot.constants
+import hutbot.models
+import hutbot.datetimefmt
+import hutbot.persistence
+import hutbot.slackcache
+import hutbot.messaging
+import hutbot.templating
+import hutbot.opsgenie
+import hutbot.actions
+import hutbot.buttons
+import hutbot.buttonutil
+import hutbot.scheduling
+import hutbot.routing
+import hutbot.webui_backend
+import hutbot.commands.dispatch
+import hutbot.commands.setters
+import hutbot.commands.info
+
+def _mk_channel(configs=None):
+    return Channel(id="C12345", name="general", configs=configs if configs is not None else {"default": DEFAULT_CONFIG.copy()})
+
+def _seed_user_caches():
+    """Pre-seed module caches so update_user_cache short-circuits (no Slack calls)."""
+    hutbot.state.team_cache = {"Platform", "Support"}
+    hutbot.state.user_id_cache = {"someuser": hutbot.models.User(id="U1", name="someuser", real_name="X", team="Platform")}
+    hutbot.state.user_email_cache = {"x@example.com": hutbot.models.User(id="U1", name="someuser", real_name="X", team="Platform")}
+    hutbot.state.id_user_cache = {"U1": hutbot.models.User(id="U1", name="someuser", real_name="X", team="Platform")}
+
+def _ui_app():
+    """A MagicMock app whose .client is an AsyncMock (won't be called if caches are seeded)."""
+    app = MagicMock()
+    app.client = AsyncMock()
+    return app
+
+
+def sent_messages(mock) -> str:
+    """Every text a patched `send_message` received, joined.
+
+    Long replies (help, `show config` for many configs) are split into several
+    messages, so assertions have to look at all of them.
+    """
+    return "\n".join(call.args[3] for call in mock.call_args_list)
+
+
+__all__ = [name for name in list(globals()) if not name.startswith('__')]
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..aa46986
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,12 @@
+"""Test fixtures: isolate the shared hutbot.state between tests."""
+
+import pytest
+
+import hutbot.state as state
+
+
+@pytest.fixture(autouse=True)
+def _reset_state():
+    state.reset()
+    yield
+    state.reset()
diff --git a/tests/test_actions.py b/tests/test_actions.py
new file mode 100644
index 0000000..0a0c740
--- /dev/null
+++ b/tests/test_actions.py
@@ -0,0 +1,164 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_multi_cancel_reaction_added():
+    app = AsyncMock()
+    channel_id = "C123"
+    user1_id = "U1"
+    user2 = User(id="U2", name="user2", real_name="User Two", team="B")
+    ts = "12345.6789"
+    event = {'item': {'channel': channel_id, 'ts': ts}, 'user': user2.id}
+    configs = {
+        "config1": {**DEFAULT_CONFIG.copy(), "included_teams": ["A"]},
+        "config2": {**DEFAULT_CONFIG.copy(), "included_teams": ["B"]},
+    }
+    channel = Channel(id=channel_id, name="test-ch", configs=configs)
+
+    task1 = AsyncMock()
+    task1.cancel = MagicMock()
+    task2 = AsyncMock()
+    task2.cancel = MagicMock()
+
+    hutbot.state.scheduled_messages.clear()
+    hutbot.state.scheduled_messages[(channel_id, ts, "config1")] = ScheduledReply(task=task1, user_id=user1_id)
+    hutbot.state.scheduled_messages[(channel_id, ts, "config2")] = ScheduledReply(task=task2, user_id=user1_id)
+
+    with patch('hutbot.slackcache.get_channel_by_id', return_value=channel), patch('hutbot.slackcache.get_user_by_id', side_effect=[user2, User(id=user1_id, name="user1", real_name="User One", team="A")]):
+        await handle_reaction_added(app, event)
+
+    task1.cancel.assert_called_once()
+    task2.cancel.assert_not_called()
+    assert list(hutbot.state.scheduled_messages.keys()) == [(channel_id, ts, "config2")]
+
+
+
+@pytest.mark.asyncio
+async def test_set_action_normalizes_dashes():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await process_command(app, "set action dm-user <@U999>", channel, user)
+        assert channel.configs["default"]["action"] == "dm_user"
+        await process_command(app, "set action group-dm @sre", channel, user)
+        assert channel.configs["default"]["action"] == "group_dm"
+
+
+
+@pytest.mark.asyncio
+async def test_set_condition_aliases():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await process_command(app, "set condition outlook", channel, user)
+        assert channel.configs["default"]["condition"] == hutbot.constants.CONDITION_OUTLOOK
+        await process_command(app, "set condition none", channel, user)
+        assert channel.configs["default"]["condition"] == ""
+
+
+
+# ----- Conditions -----
+
+@pytest.mark.asyncio
+async def test_evaluate_condition_none_is_true():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    assert await hutbot.actions.evaluate_condition(app, config) is True
+
+
+
+@pytest.mark.asyncio
+async def test_evaluate_condition_outlook_passes_negate():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["condition"] = hutbot.constants.CONDITION_OUTLOOK
+    config["outlook_subject_pattern"] = "standup"
+    config["condition_negate"] = True
+    with patch('hutbot.actions.outlook.calendar_condition_met', new=AsyncMock(return_value=False)) as met:
+        result = await hutbot.actions.evaluate_condition(app, config)
+        assert result is False
+        met.assert_awaited_once_with("standup", "", True)
+
+
+
+@pytest.mark.asyncio
+async def test_outlook_stub_reads_env(monkeypatch):
+    monkeypatch.setenv("HUTBOT_OUTLOOK_STUB_EVENTS", json.dumps([
+        {"subject": "Daily standup", "body": "join here"},
+        {"subject": "1:1", "body": "private"},
+    ]))
+    events = await outlook.find_calendar_events("standup")
+    assert len(events) == 1 and events[0]["subject"] == "Daily standup"
+    assert await outlook.calendar_condition_met("standup") is True
+    assert await outlook.calendar_condition_met("standup", negate=True) is False
+    assert await outlook.calendar_condition_met("no-such-meeting") is False
+    assert await outlook.calendar_condition_met("no-such-meeting", negate=True) is True
+
+
+
+@pytest.mark.asyncio
+async def test_action_dm_user_opens_dm_and_posts():
+    app = AsyncMock()
+    app.client.conversations_open.return_value = {"channel": {"id": "D999"}}
+    app.client.chat_postMessage.return_value = {"ts": "1.1"}
+    config = DEFAULT_CONFIG.copy()
+    config["action"] = hutbot.constants.ACTION_DM_USER
+    config["action_target"] = "<@U777>"
+    channel = _mk_channel({"src": config})
+    with patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U777", "alice", "Alice", "Team"))):
+        posted = await hutbot.actions.run_action(app, "token", channel, config, "src")
+    app.client.conversations_open.assert_awaited_once_with(users=["U777"])
+    assert app.client.chat_postMessage.call_args.kwargs["channel"] == "D999"
+    assert posted["channel"] == "D999"
+
+
+
+@pytest.mark.asyncio
+async def test_action_group_dm_resolves_members_and_opens_mpim():
+    app = AsyncMock()
+    app.client.conversations_open.return_value = {"channel": {"id": "G888"}}
+    app.client.chat_postMessage.return_value = {"ts": "2.2"}
+    config = DEFAULT_CONFIG.copy()
+    config["action"] = hutbot.constants.ACTION_GROUP_DM
+    config["action_target"] = "@oncall"
+    channel = _mk_channel({"src": config})
+    with patch('hutbot.slackcache.get_usergroup_by_handle', new=AsyncMock(return_value=Usergroup("S1", "oncall", "On Call"))), \
+         patch('hutbot.slackcache.get_usergroup_members', new=AsyncMock(return_value=["U1", "U2", "U3"])):
+        posted = await hutbot.actions.run_action(app, "token", channel, config, "src")
+    app.client.conversations_open.assert_awaited_once_with(users=["U1", "U2", "U3"])
+    assert app.client.chat_postMessage.call_args.kwargs["channel"] == "G888"
+    assert posted["channel"] == "G888"
+
+
+@pytest.mark.asyncio
+async def test_run_action_fires_opsgenie_when_slack_post_fails():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "opsgenie": True}
+    channel = _mk_channel({"src": config})
+
+    with patch('hutbot.actions.action_reply', new=AsyncMock(return_value=None)), \
+         patch('hutbot.actions.maybe_post_opsgenie_alert', new=AsyncMock()) as alert:
+        posted = await hutbot.actions.run_action(app, "token", channel, config, "src", {"text": "DB down"})
+
+    assert posted is None
+    alert.assert_awaited_once_with(app, "token", channel, config, "src", {"text": "DB down"}, "")
+
+
+
+# ----- action_reply threads only within the same channel -----
+
+@pytest.mark.asyncio
+async def test_action_reply_threads_only_in_same_channel():
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "9"}
+    channel = _mk_channel({"d": DEFAULT_CONFIG.copy()})
+    # Same channel as the original message → threads.
+    await hutbot.actions.action_reply(app, channel, {}, {"channel_id": "C12345", "message_ts": "7.7"}, "t", None)
+    assert app.client.chat_postMessage.call_args.kwargs.get("thread_ts") == "7.7"
+    # Different conversation (e.g. button on a DM) → must NOT thread.
+    app.client.chat_postMessage.reset_mock()
+    await hutbot.actions.action_reply(app, channel, {}, {"channel_id": "D999", "message_ts": "7.7"}, "t", None)
+    assert "thread_ts" not in app.client.chat_postMessage.call_args.kwargs
diff --git a/tests/test_buttons.py b/tests/test_buttons.py
new file mode 100644
index 0000000..189db69
--- /dev/null
+++ b/tests/test_buttons.py
@@ -0,0 +1,856 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_add_button_copy_on_write_and_clear():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    default_buttons_before = list(DEFAULT_CONFIG["buttons"])
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await process_command(app, 'add button "Approve" config approve-flow', channel, user)
+        assert channel.configs["default"]["buttons"] == [{"label": "Approve", "action": "config", "value": "approve-flow"}]
+        # DEFAULT_CONFIG's list must not have been mutated (copy-on-write).
+        assert DEFAULT_CONFIG["buttons"] == default_buttons_before
+        await process_command(app, "clear buttons", channel, user)
+        assert channel.configs["default"]["buttons"] == []
+
+
+
+@pytest.mark.asyncio
+async def test_add_button_typed_actions():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "Ack" ack "Got it"', channel, user)
+        await process_command(app, 'add button "FAQ" ack "See the wiki"', channel, user)
+        # A delay button needs something to postpone.
+        await process_command(app, "set escalation 5 config approve-flow", channel, user)
+        await process_command(app, 'add button "Wait" delay 3', channel, user)
+        await process_command(app, 'add button "Run" config approve-flow', channel, user)
+    assert channel.configs["default"]["buttons"] == [
+        {"label": "Ack", "action": "ack", "value": "Got it"},
+        {"label": "FAQ", "action": "ack", "value": "See the wiki"},
+        {"label": "Wait", "action": "delay", "value": "3"},
+        {"label": "Run", "action": "config", "value": "approve-flow"},
+    ]
+    # invalid delay rejected
+    await process_command(app, 'add button "Bad" delay nope', channel, user)
+    assert len(channel.configs["default"]["buttons"]) == 4
+
+
+
+@pytest.mark.asyncio
+async def test_migrate_keeps_buttons_to_label_action_value():
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["buttons"] = [
+        {"label": "Run", "action": "config", "value": "approve-flow", "stray": 1},
+        {"label": "Plain"},
+        "not-a-button",
+    ]
+    config = {"C12345": {"default": cfg}}
+    migrated = await migrate_and_apply_defaults(AsyncMock(), config)
+    assert migrated["C12345"]["default"]["buttons"] == [
+        {"label": "Run", "action": "config", "value": "approve-flow"},
+        {"label": "Plain", "action": "config", "value": ""},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_add_button_requires_an_action_keyword():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "Approve" approve-flow', channel, user)
+
+    assert channel.configs["default"]["buttons"] == []
+    assert send.call_args.args[3] == (
+        "Invalid *button action* `approve-flow`. Must be one of `ack`, `config`, `delay`."
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_set_escalation_stores_minutes_kind_and_target():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set escalation 15 config escalate", channel, user)
+        cfg = channel.configs["default"]
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (900, "config", "escalate")
+        assert "after `15` minutes without a press, run `escalate`" in send.call_args.args[3]
+
+        await process_command(app, 'add button "Yes" ack', channel, user)
+        await process_command(app, 'escalation 5 button "Yes"', channel, user)
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (300, "button", "Yes")
+
+        # `none` points at the clear command instead of doing it silently.
+        await process_command(app, "set escalation none", channel, user)
+        assert "use `/hutbot default clear escalation`" in send.call_args.args[3]
+        assert cfg["escalation_timeout"] == 300
+
+        await process_command(app, "clear escalation", channel, user)
+        assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+        assert "buttons stay open until pressed" in send.call_args.args[3]
+
+
+@pytest.mark.asyncio
+async def test_set_escalation_refuses_half_a_setting():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    cfg = channel.configs["default"]
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        # A timeout with nothing to escalate to used to be accepted and do nothing.
+        await process_command(app, "set escalation 5", channel, user)
+        assert "needs what to escalate to" in send.call_args.args[3]
+        # A button that does not exist would only fail at escalation time.
+        await process_command(app, 'set escalation 5 button "Nope"', channel, user)
+        assert "No button labelled `Nope`" in send.call_args.args[3]
+        await process_command(app, "set escalation 5 button", channel, user)
+        assert "needs a button label" in send.call_args.args[3]
+        await process_command(app, "set escalation 0 config escalate", channel, user)
+        assert "clear escalation" in send.call_args.args[3]
+        await process_command(app, "set escalation 5000 config escalate", channel, user)
+        assert "between 1 and 1440" in send.call_args.args[3]
+
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+
+
+# ----- Actions -----
+
+def test_build_button_blocks_structure():
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [
+        {"label": "Yes", "action": "config", "value": "yes-flow"},
+        {"label": "No", "action": "ack", "value": ""},
+    ]
+    blocks = hutbot.buttons.build_button_blocks(config, "C12345", "src", "Pick one")
+    assert blocks[0]["type"] == "section"
+    elements = blocks[1]["elements"]
+    assert [e["action_id"] for e in elements] == ["hutbot_btn:0", "hutbot_btn:1"]
+    # Payload only locates the button; the definition is resolved server-side.
+    payload = json.loads(elements[0]["value"])
+    assert payload == {"channel": "C12345", "config": "src", "index": 0}
+
+
+def test_build_button_blocks_respects_slack_block_limits():
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [
+        {"label": f"Button {i}", "action": "ack", "value": ""}
+        for i in range(26)
+    ]
+    text = "x" * 6001
+
+    blocks = hutbot.buttons.build_button_blocks(config, "C12345", "src", text)
+
+    sections = [block for block in blocks if block["type"] == "section"]
+    actions_blocks = [block for block in blocks if block["type"] == "actions"]
+    assert "".join(block["text"]["text"] for block in sections) == text
+    assert all(len(block["text"]["text"]) <= 3000 for block in sections)
+    assert [len(block["elements"]) for block in actions_blocks] == [25, 1]
+    assert actions_blocks[1]["elements"][0]["action_id"] == "hutbot_btn:25"
+
+
+
+@pytest.mark.asyncio
+async def test_run_action_reply_posts_with_buttons():
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "99.1"}
+    config = DEFAULT_CONFIG.copy()
+    config["action"] = hutbot.constants.ACTION_REPLY
+    config["reply_message"] = "Hi there"
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
+    config["escalation_timeout"] = 0  # no timeout watch
+    channel = _mk_channel({"src": config})
+    with patch('hutbot.buttons.register_escalation', new=AsyncMock()) as reg:
+        posted = await hutbot.actions.run_action(app, "token", channel, config, "src", context=None)
+    assert posted == {"channel": "C12345", "ts": "99.1", "text": "Hi there"}
+    reg.assert_awaited_once()  # buttons present ⇒ escalation registered
+    kwargs = app.client.chat_postMessage.call_args.kwargs
+    assert kwargs["channel"] == "C12345"
+    assert kwargs["text"] == "Hi there"
+    assert kwargs["blocks"][1]["type"] == "actions"
+
+
+
+# ----- Buttons: press + timeout -----
+
+@pytest.mark.asyncio
+async def test_handle_button_press_routes_to_target_and_cancels_timeout():
+    app = AsyncMock()
+    target_config = DEFAULT_CONFIG.copy()
+    target_config["trigger"] = "manual"
+    src_config = DEFAULT_CONFIG.copy()
+    src_config["buttons"] = [{"label": "Go", "action": "config", "value": "tgt"}]
+    channel = _mk_channel({"src": src_config, "tgt": target_config})
+    body = {
+        "channel": {"id": "C12345"},
+        "container": {"message_ts": "10.1"},
+        "user": {"id": "U9"},
+        "message": {"ts": "10.1"},
+    }
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons[key] = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    assert key not in hutbot.state.pending_buttons
+    assert run.await_count == 1
+    assert run.await_args.args[3] is target_config
+    assert run.await_args.args[4] == "tgt"
+
+
+
+@pytest.mark.asyncio
+async def test_button_press_ack_cancels_without_running_config():
+    app = AsyncMock()
+    src_config = DEFAULT_CONFIG.copy()
+    src_config["buttons"] = [{"label": "Got it", "action": "ack", "value": "Thanks!"}]
+    channel = _mk_channel({"src": src_config})
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons[key] = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.messaging._post_message', new=AsyncMock()) as post, \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    assert key not in hutbot.state.pending_buttons
+    run.assert_not_awaited()
+    post.assert_awaited_once_with(app, "C12345", "Thanks!", None, "10.1")
+
+
+
+@pytest.mark.asyncio
+async def test_button_press_config_passes_orig_context():
+    # A `config` button runs its target with the *original* message context, so a
+    # target with OpsGenie on alerts about the original message.
+    app = AsyncMock()
+    target_config = DEFAULT_CONFIG.copy()
+    target_config["trigger"] = "manual"
+    src_config = DEFAULT_CONFIG.copy()
+    src_config["buttons"] = [{"label": "Help needed", "action": "config", "value": "oncall"}]
+    channel = _mk_channel({"src": src_config, "oncall": target_config})
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[("C12345", "10.1")] = {"task": None, "orig": {"user_id": "U5", "text": "help", "ts": "9.9", "permalink": "p"}}
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    run.assert_awaited_once()
+    assert run.await_args.args[4] == "oncall"
+    ctx = run.await_args.kwargs["context"]
+    assert ctx["text"] == "help" and ctx["ts"] == "9.9" and ctx["permalink"] == "p"
+
+
+
+@pytest.mark.asyncio
+async def test_button_press_delay_reschedules():
+    app = AsyncMock()
+    src_config = DEFAULT_CONFIG.copy()
+    src_config["buttons"] = [{"label": "Wait", "action": "delay", "value": "3"}]
+    channel = _mk_channel({"src": src_config})
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    key = ("C12345", "10.1")
+    entry = {"task": None, "buttons": src_config["buttons"], "orig": {}}
+    hutbot.state.pending_buttons[key] = entry
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.buttons.reschedule_escalation', new=AsyncMock()) as resched:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    assert resched.await_args.args == (app, "token", "C12345", "10.1", 3)
+    assert resched.await_args.kwargs == {"_entry": entry}
+
+
+
+@pytest.mark.asyncio
+async def test_register_and_cancel_escalation():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
+    hutbot.state.pending_buttons.clear()
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        await hutbot.buttons.register_escalation(app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
+        entry = hutbot.state.pending_buttons.get(("C12345", "10.1"))
+        assert entry is not None
+        assert entry["escalation_kind"] == "config" and entry["escalation_target"] == "escalate"
+        await hutbot.buttons.cancel_pending_button("C12345", "10.1")
+        assert ("C12345", "10.1") not in hutbot.state.pending_buttons
+    await asyncio.sleep(0)  # let the cancelled task settle
+
+
+@pytest.mark.asyncio
+async def test_cancelled_timer_keeps_persisted_record_for_restart():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Ok", "action": "config", "value": "tgt"}]
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
+    key = ("C12345", "10.1")
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()) as flush:
+        await hutbot.buttons.register_escalation(
+            app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
+        task = hutbot.state.pending_buttons[key]["task"]
+        await asyncio.sleep(0)
+        flush.reset_mock()
+
+        task.cancel()
+        await task
+
+        assert key in hutbot.state.pending_buttons
+        assert key in hutbot.state._button_states_cache
+        flush.assert_not_awaited()
+        await hutbot.buttons.cancel_pending_button(*key)
+
+
+@pytest.mark.asyncio
+async def test_button_record_is_consumed_once_for_duplicate_and_stale_presses():
+    app = AsyncMock()
+    target = {**DEFAULT_CONFIG.copy(), "trigger": "manual"}
+    src = {**DEFAULT_CONFIG.copy(), "buttons": [{"label": "Go", "action": "config", "value": "tgt"}]}
+    channel = _mk_channel({"src": src, "tgt": target})
+    key = ("C12345", "10.1")
+    record = {"task": None, "buttons": src["buttons"], "orig": {}}
+    hutbot.state.pending_buttons[key] = record
+    hutbot.state._button_states_cache[key] = {k: v for k, v in record.items() if k != "task"}
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    button_action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await asyncio.gather(
+            hutbot.buttons.handle_button_press(app, "token", body, button_action),
+            hutbot.buttons.handle_button_press(app, "token", body, button_action),
+        )
+        await hutbot.buttons.handle_button_press(app, "token", body, button_action)
+
+    run.assert_awaited_once()
+    assert key not in hutbot.state.pending_buttons
+    assert key not in hutbot.state._button_states_cache
+
+
+
+@pytest.mark.asyncio
+async def test_escalation_task_runs_config_target():
+    app = AsyncMock()
+    escalate = DEFAULT_CONFIG.copy()
+    escalate["trigger"] = "manual"
+    channel = _mk_channel({"escalate": escalate})
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "10.1",
+        "def_channel_id": "C12345", "config_name": "src",
+        "escalation_kind": "config", "escalation_target": "escalate", "orig": {},
+    }
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons._escalation_task(app, "token", key, 0)
+    assert run.await_count == 1
+    assert run.await_args.args[4] == "escalate"
+
+
+
+@pytest.mark.asyncio
+async def test_escalation_task_config_passes_orig_context():
+    # Timeout → run the target config with the original message context (so an
+    # OpsGenie-enabled target alerts about the original message).
+    app = AsyncMock()
+    oncall = DEFAULT_CONFIG.copy()
+    oncall["trigger"] = "manual"
+    oncall["opsgenie"] = True
+    channel = _mk_channel({"oncall": oncall})
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "10.1",
+        "def_channel_id": "C12345", "config_name": "src",
+        "escalation_kind": "config", "escalation_target": "oncall",
+        "orig": {"user_id": "U5", "text": "DB down", "ts": "9.9", "permalink": "p"},
+    }
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U5", "carol", "Carol", "T"))), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons._escalation_task(app, "token", key, 0)
+    run.assert_awaited_once()
+    assert run.await_args.args[4] == "oncall"
+    ctx = run.await_args.kwargs["context"]
+    assert ctx["text"] == "DB down" and ctx["ts"] == "9.9" and ctx["permalink"] == "p"
+
+
+
+@pytest.mark.asyncio
+async def test_register_escalation_keeps_record_with_orig():
+    # No default-button / timeout-target ⇒ nothing to escalate to (kind none), but a
+    # record is still kept so button presses get the original message context.
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["escalation_timeout"] = 0
+    cfg["buttons"] = [{"label": "Yes", "action": "config", "value": "flow"}]
+    hutbot.state.pending_buttons.clear()
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        await hutbot.buttons.register_escalation(app, "tok", "C12345", "1.1", "C12345", "src", cfg, {"text": "t", "ts": "1.1", "permalink": "p"})
+    entry = hutbot.state.pending_buttons.get(("C12345", "1.1"))
+    assert entry is not None
+    assert entry["escalation_kind"] == "none"
+    assert entry["task"] is None and entry["run_at"] == ""
+    assert entry["orig"]["text"] == "t" and entry["orig"]["ts"] == "1.1"
+
+
+
+# ----- Default button: auto-press on timeout -----
+
+@pytest.mark.asyncio
+async def test_the_old_three_commands_are_gone():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        for gone in ('set default-button "Yes"', "clear default-button", "set button-timeout 5",
+                     "set button-timeout-target alarm"):
+            await process_command(app, gone, channel, user)
+            assert "Huh?" in send.call_args.args[3], gone
+    cfg = channel.configs["default"]
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+
+
+def test_escalation_kind_reads_what_was_stored():
+    import hutbot
+    cfg = DEFAULT_CONFIG.copy()
+    assert hutbot.buttons._escalation_kind(cfg) == (ESCALATION_NONE, "")
+
+    cfg["escalation_kind"], cfg["escalation_target"] = "button", "Yes"
+    assert hutbot.buttons._escalation_kind(cfg) == ("button", "Yes")
+
+    cfg["escalation_kind"], cfg["escalation_target"] = "config", "some-config"
+    assert hutbot.buttons._escalation_kind(cfg) == ("config", "some-config")
+
+    # Half a setting escalates nothing.
+    cfg["escalation_target"] = ""
+    assert hutbot.buttons._escalation_kind(cfg) == (ESCALATION_NONE, "")
+
+
+
+@pytest.mark.asyncio
+async def test_escalation_task_auto_presses_default_button():
+    app = AsyncMock()
+    src = DEFAULT_CONFIG.copy()
+    src["buttons"] = [
+        {"label": "Yes", "action": "ack", "value": "Here is the help"},
+        {"label": "No", "action": "ack", "value": ""},
+    ]
+    channel = _mk_channel({"src": src})
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "10.1",
+        "def_channel_id": "C12345", "config_name": "src",
+        "escalation_kind": "button", "escalation_target": "Yes", "orig": {},
+    }
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock()) as post:
+        await hutbot.buttons._escalation_task(app, "token", key, 0)
+    # auto-pressed "Yes" (message) ⇒ posts the help text in the thread
+    post.assert_awaited_once_with(app, "C12345", "Here is the help", None, "10.1")
+
+
+@pytest.mark.asyncio
+async def test_delay_press_does_not_clobber_rescheduled_escalation():
+    # Regression (F2): a `delay` press cancels the active timer and stores a fresh
+    # one under the same key. The cancelled task's cleanup must not remove the new
+    # entry, or the delayed escalation would never fire.
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config["buttons"] = [{"label": "Wait", "action": "delay", "value": "3"}]
+    config["escalation_timeout"] = 3600
+    config["escalation_kind"] = "config"
+    config["escalation_target"] = "escalate"
+    key = ("C12345", "10.1")
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        await hutbot.buttons.register_escalation(
+            app, "token", "C12345", "10.1", "C12345", "src", config, {"text": "x", "ts": "9.1"})
+        first = hutbot.state.pending_buttons[key]["task"]
+        assert await hutbot.buttons.reschedule_escalation(app, "token", "C12345", "10.1", 5)
+        try:
+            await first  # wait for the cancelled timer to run its finally
+        except asyncio.CancelledError:
+            pass
+        assert key in hutbot.state.pending_buttons        # not clobbered by cancelled task
+        entry = hutbot.state.pending_buttons[key]
+        assert entry["task"] is not first
+        assert entry["timeout"] == 300                    # the rescheduled 5-minute timer
+        await hutbot.buttons.cancel_pending_button("C12345", "10.1")
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_config_button_attributes_to_original_author_not_presser():
+    # F3: a config-running button pressed by someone else runs with the ORIGINAL
+    # author as {{user}}/{{team}}, not the clicker.
+    app = AsyncMock()
+    target = DEFAULT_CONFIG.copy(); target["trigger"] = "manual"
+    src = DEFAULT_CONFIG.copy(); src["buttons"] = [{"label": "Go", "action": "config", "value": "tgt"}]
+    channel = _mk_channel({"src": src, "tgt": target})
+    users = {"U9": User("U9", "bob", "Bob", "Ops"), "U5": User("U5", "carol", "Carol", "Platform")}
+    hutbot.state.pending_buttons[("C12345", "10.1")] = {
+        "task": None, "orig": {"user_id": "U5", "text": "help", "ts": "9.9", "permalink": "p"},
+        "buttons": src["buttons"], "posted_text": "Need help?",
+    }
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(side_effect=lambda app, uid, *a, **k: users[uid])), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    ctx = run.await_args.kwargs["context"]
+    assert ctx["user"].id == "U5"   # original author, not presser U9
+    assert ctx["text"] == "help"
+
+
+@pytest.mark.asyncio
+async def test_button_resolves_from_snapshot_and_strips_after_press():
+    # F6: a press resolves against the buttons snapshotted at post time (not a
+    # since-edited config), and the message is de-buttoned once handled.
+    app = AsyncMock()
+    src = DEFAULT_CONFIG.copy(); src["buttons"] = [{"label": "Ack", "action": "ack", "value": "ok"}]
+    channel = _mk_channel({"src": src})
+    key = ("C12345", "10.1")
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "orig": {}, "posted_text": "Approve?",
+        "buttons": [{"label": "Ack", "action": "ack", "value": "ok"}],
+    }
+    # config edited AFTER posting: index 0 now maps to a dangerous config action
+    channel.configs["src"]["buttons"] = [{"label": "Run", "action": "config", "value": "danger"}]
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "10.1"}, "user": {"id": "U9"}}
+    action = {"action_id": "hutbot_btn:0", "value": json.dumps({"channel": "C12345", "config": "src", "index": 0})}
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U9", "bob", "Bob", "T"))), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock()) as post, \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    run.assert_not_awaited()                                   # snapshot ack, not the edited config action
+    post.assert_awaited_once_with(app, "C12345", "ok", None, "10.1")
+    app.client.chat_update.assert_awaited_once()               # buttons stripped
+    kw = app.client.chat_update.await_args.kwargs
+    # The buttons are replaced by a note saying who took the message.
+    assert kw["ts"] == "10.1" and kw["text"] == "Approve?\n\n---\n_Bob: [Ack]_"
+
+
+@pytest.mark.asyncio
+async def test_cancel_channel_pending_buttons():
+    task = MagicMock()
+    task.done.return_value = False
+    posted_here = ("C12345", "1.1")
+    defined_here = ("C99999", "2.2")
+    unrelated = ("C99999", "3.3")
+
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[posted_here] = {
+        "task": task, "posted_channel_id": "C12345", "def_channel_id": "C12345", "orig": {}}
+    hutbot.state.pending_buttons[defined_here] = {
+        # posted elsewhere by a rule that lives in the removed channel
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C12345", "orig": {}}
+    hutbot.state.pending_buttons[unrelated] = {
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C99999", "orig": {}}
+    hutbot.state._button_states_cache.clear()
+    for key, entry in hutbot.state.pending_buttons.items():
+        hutbot.state._button_states_cache[key] = {k: v for k, v in entry.items() if k != "task"}
+    # A cached record with no live counterpart (never restored) goes too.
+    hutbot.state._button_states_cache[("C12345", "4.4")] = {
+        "posted_channel_id": "C12345", "def_channel_id": "C12345"}
+
+    with patch('hutbot.persistence.flush_button_cache') as mock_flush:
+        cancelled = await hutbot.buttons.cancel_channel_pending_buttons("C12345")
+
+    assert cancelled == 3
+    assert list(hutbot.state.pending_buttons.keys()) == [unrelated]
+    assert list(hutbot.state._button_states_cache.keys()) == [unrelated]
+    task.cancel.assert_called_once()
+    mock_flush.assert_awaited_once()
+
+
+@pytest.mark.asyncio
+async def test_cancel_channel_pending_buttons_without_matches_does_not_flush():
+    hutbot.state.pending_buttons[("C99999", "1.1")] = {
+        "task": None, "posted_channel_id": "C99999", "def_channel_id": "C99999", "orig": {}}
+    with patch('hutbot.persistence.flush_button_cache') as mock_flush:
+        assert await hutbot.buttons.cancel_channel_pending_buttons("C12345") == 0
+        assert await hutbot.buttons.cancel_channel_pending_buttons("") == 0
+    mock_flush.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_button_message_is_a_template_rendered_against_the_original_message():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "datetime_timezone": "Europe/Berlin"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    author = User("UAUTH", "author", "Ada Author", "Platform")
+    entry = {
+        'posted_channel_id': "C1", 'message_ts': "R1", 'def_channel_id': "C1", 'config_name': "default",
+        'orig': {'user_id': author.id, 'text': "the server is down", 'ts': "1786453297.645799", 'permalink': "https://slack.test/p1"},
+    }
+    button = {'label': "help", 'action': "ack",
+              'value': "Help <@UAUTH> with {{message}} from {{date}} ({{user_name}}) — {{message_link}}"}
+
+    with patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=author)), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C1", "ts": "R2"})) as post:
+        run_context = await hutbot.buttons._escalation_context(app, entry, "C1", "R1")
+        await hutbot.buttons.dispatch_button_action(app, "tok", channel, "C1", "R1", button, run_context, config, "default")
+
+    assert post.await_args.args[2] == (
+        "Help <@UAUTH> with the server is down from 11.08.2026 (Ada Author) — https://slack.test/p1"
+    )
+    # Posted in the thread of the buttoned message.
+    assert post.await_args.args[4] == "R1"
+
+
+@pytest.mark.asyncio
+async def test_add_button_resolves_mentions_and_rejects_unknown_variables():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+    author = User("UAUTH", "author", "Ada Author", "Platform")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=author)), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "help" ack "Help @author with {{message}}"', channel, user)
+        assert config["buttons"] == [
+            {"label": "help", "action": "ack", "value": "Help <@UAUTH> with {{message}}"}
+        ]
+
+        await process_command(app, 'add button "bad" ack "{{nope}}"', channel, user)
+        assert "unsupported template variable(s) `{{nope}}`" in send.call_args.args[3]
+        # Nothing added for the rejected button.
+        assert len(config["buttons"]) == 1
+
+        # `ack` text gets the same treatment.
+        await process_command(app, 'add button "ok" ack "Thanks @author"', channel, user)
+        assert config["buttons"][1]["value"] == "Thanks <@UAUTH>"
+
+
+@pytest.mark.asyncio
+async def test_add_button_reports_an_unknown_mention():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.slackcache.get_user_by_name', new=AsyncMock(return_value=User(None, "ghost", "", "T"))), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "help" ack "Help @ghost"', channel, user)
+
+    assert send.call_args.args[3] == "Invalid *button* message: ghost not found."
+    assert config["buttons"] == []
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["clear escalation", "unset escalation", "remove escalation"])
+async def test_clear_escalation_switches_it_off(command):
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    config.update({"escalation_timeout": 300, "escalation_kind": "config", "escalation_target": "alarm"})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, command, channel, user)
+
+    assert (config["escalation_timeout"], config["escalation_kind"], config["escalation_target"]) == (0, ESCALATION_NONE, "")
+    assert send.call_args.args[3] == (
+        "*Escalation* cleared in configuration `default`; buttons stay open until pressed."
+    )
+
+
+@pytest.mark.asyncio
+async def test_delay_press_without_an_escalation_keeps_the_buttons_and_starts_no_timer():
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel()
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state._button_states_cache.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "posted_channel_id": "C12345", "message_ts": "R1",
+        "def_channel_id": "C12345", "config_name": "default",
+        "escalation_kind": ESCALATION_NONE, "escalation_target": "",
+        "buttons": [{"label": "Later", "action": "delay", "value": "10"}],
+        "orig": {"user_id": "U1", "text": "x", "ts": "9.9", "permalink": "p"},
+    }
+
+    with patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        delayed = await hutbot.buttons.reschedule_escalation(app, "tok", "C12345", "R1", 10)
+
+    assert delayed is False
+    entry = hutbot.state.pending_buttons[key]
+    # Record kept so the other buttons still resolve, but no timer was created.
+    assert entry["task"] is None
+    assert entry["escalation_kind"] == ESCALATION_NONE
+
+
+@pytest.mark.asyncio
+async def test_add_delay_button_requires_an_escalation():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+        assert send.call_args.args[3] == (
+            'A `delay` button needs an escalation to postpone. Set one first with '
+            '`/hutbot default set escalation <minutes> <button "<label>"|config <name>>`.'
+        )
+        assert config["buttons"] == []
+
+        await process_command(app, "set escalation 5 config alarm", channel, user)
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+
+    assert config["buttons"] == [{"label": "Later", "action": "delay", "value": "10"}]
+
+
+@pytest.mark.asyncio
+async def test_clear_escalation_warns_about_a_stranded_delay_button():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set escalation 5 config alarm", channel, user)
+        await process_command(app, 'add button "Later" delay 10', channel, user)
+        await process_command(app, "clear escalation", channel, user)
+
+    assert send.call_args.args[3] == (
+        "*Escalation* cleared in configuration `default`; buttons stay open until pressed "
+        ":warning: (`Later` now has nothing to postpone)."
+    )
+
+
+@pytest.mark.asyncio
+async def test_add_is_optional_for_button_commands():
+    app = AsyncMock()
+    channel = _mk_channel()
+    config = channel.configs["default"]
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, 'button "Yes" ack "Got it"', channel, user)
+        await process_command(app, 'add button "FAQ" ack "See the wiki"', channel, user)
+        # A label alone is not a command.
+        await process_command(app, "button", channel, user)
+        assert "Huh?" in send.call_args.args[3]
+
+    assert config["buttons"] == [
+        {"label": "Yes", "action": "ack", "value": "Got it"},
+        {"label": "FAQ", "action": "ack", "value": "See the wiki"},
+    ]
+
+
+@pytest.mark.asyncio
+async def test_a_config_named_button_still_gets_its_own_commands():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy(), "button": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        # `wait-time 5` is a command, so the leading word is the config.
+        await process_command(app, "button wait-time 5", channel, user)
+        # `"Yes" ack` is not, so this adds a button to `default`.
+        await process_command(app, 'button "Yes" ack', channel, user)
+
+    assert configs["button"]["wait_time"] == 300
+    assert configs["button"]["buttons"] == []
+    assert [b["label"] for b in configs["default"]["buttons"]] == ["Yes"]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("button,expected", [
+    ({"label": "I've got it", "action": "ack", "value": "On it"}, "_Dave Grieser: [I've got it]_"),
+    ({"label": "No", "action": "ack", "value": ""}, "_Dave Grieser: [No]_"),
+    ({"label": "Page", "action": "config", "value": "alarm"}, "_Dave Grieser: [Page] ▶︎ alarm_"),
+])
+async def test_a_press_leaves_a_note_in_place_of_the_buttons(button, expected):
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel({"default": DEFAULT_CONFIG.copy(), "alarm": DEFAULT_CONFIG.copy()})
+    dave = User("U1", "dave", "Dave Grieser", "T")
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "orig": {}, "posted_text": "Incident — on it?",
+        "posted_channel_id": "C12345", "message_ts": "R1", "def_channel_id": "C12345",
+        "config_name": "default", "buttons": [button],
+    }
+    body = {"channel": {"id": "C12345"}, "container": {"message_ts": "R1"}, "user": {"id": "U1"}}
+    action = {"value": json.dumps({"channel": "C12345", "config": "default", "index": 0})}
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=dave)), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C12345", "ts": "R2"})), \
+         patch('hutbot.actions.run_action', new=AsyncMock()):
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n---\n{expected}"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("escalation,expected", [
+    ({"escalation_kind": "button", "escalation_target": "I've got it", "timeout": 60}, "_⌛︎ 1m_"),
+    ({"escalation_kind": "config", "escalation_target": "alarm", "timeout": 300}, "_⌛︎ 5m ▶︎ alarm_"),
+])
+async def test_an_escalation_leaves_a_note_in_place_of_the_buttons(escalation, expected):
+    import hutbot
+    app = AsyncMock()
+    channel = _mk_channel({"default": DEFAULT_CONFIG.copy(), "alarm": DEFAULT_CONFIG.copy()})
+    key = ("C12345", "R1")
+    hutbot.state.pending_buttons.clear()
+    hutbot.state.pending_buttons[key] = {
+        "task": None, "orig": {}, "posted_text": "Incident — on it?",
+        "posted_channel_id": "C12345", "message_ts": "R1", "def_channel_id": "C12345",
+        "config_name": "default", "buttons": [{"label": "I've got it", "action": "ack", "value": "On it"}],
+        **escalation,
+    }
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User("U1", "dave", "Dave", "T"))), \
+         patch('hutbot.persistence.flush_button_cache', new=AsyncMock()), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C12345", "ts": "R2"})), \
+         patch('hutbot.actions.run_action', new=AsyncMock()):
+        await hutbot.buttons._escalation_task(app, "token", key, 0)
+
+    assert app.client.chat_update.await_args.kwargs["text"] == f"Incident — on it?\n\n---\n{expected}"
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
new file mode 100644
index 0000000..31a704d
--- /dev/null
+++ b/tests/test_commands_info.py
@@ -0,0 +1,447 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_show_config():
+    app = AsyncMock()
+    configs = {
+        "alarms": {"pattern": ".*alarm.*", "wait_time": 300, "reply_message": "Alarm message", "opsgenie": True},
+        "default": {"wait_time": 600, "reply_message": "Default message"}
+    }
+    for name, cfg in configs.items():
+        for k, v in DEFAULT_CONFIG.items():
+            if k not in cfg:
+                cfg[k] = v
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+        sent_message = sent_messages(mock_send_message)
+        assert "\n\n*Configuration*: `default` (enabled)" in sent_message
+        assert "> *Trigger*: `message`\n>\n> *Reply message*:\n> Default message\n>\n> *Replied in* <#C123> (in thread)\n>\n> *Settings*:\n```" in sent_message
+        assert "\nTrigger" not in sent_message
+        # Details only where OpsGenie is on; the disabled config shows just the one row.
+        assert "OpsGenie schedule" in sent_message
+        assert "OpsGenie priority" in sent_message
+        assert any(line.startswith("OpsGenie ") and line.endswith("disabled (not configured)") for line in sent_message.splitlines())
+        # Settings are grouped, each group separated by a blank line.
+        assert (
+            "Wait time       10 minutes\n"
+            "Only work days  disabled\n"
+            "Work hours      any hour"
+        ) in sent_message
+        assert "Wait time       10 minutes" in sent_message
+        assert "Default message" in sent_message
+        assert "\n\n*Configuration*: `alarms` (enabled)" in sent_message
+        assert "Wait time          5 minutes" in sent_message  # wider column: the OpsGenie rows
+        assert "Pattern            .*alarm.* (case-insensitive)" in sent_message
+        assert "Alarm message" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_show_config_resolves_the_server_timezone_and_locale():
+    app = AsyncMock()
+    configs = {
+        "default": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}"},
+        "tokyo": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}",
+                  "datetime_timezone": "Asia/Tokyo", "datetime_locale": "de-DE"},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch.dict(os.environ, {"TZ": "Europe/Berlin"}), \
+         patch('hutbot.datetimefmt.get_server_locale_name', return_value="de_DE"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    lines = sent_messages(mock_send_message).splitlines()
+    assert any(line.startswith("Date/time timezone  Europe/Berlin (") and line.endswith(", server local time)") for line in lines)
+    assert "Date/time locale    English names (server locale de_DE not applied)" in lines
+    assert "Date/time timezone  Asia/Tokyo (JST, UTC+09:00)" in lines
+    assert "Date/time locale    de_DE" in lines
+    assert "<server local>" not in sent_messages(mock_send_message)
+
+
+
+@pytest.mark.asyncio
+async def test_show_config_displays_multiline_team_values():
+    app = AsyncMock()
+    config = {
+        **DEFAULT_CONFIG.copy(),
+        "excluded_teams": [
+            "Cloud Hosting",
+            "m-kubed (m³)",
+            "Systemarchitektur Infrastruktur/Technik",
+            "Site Reliability",
+        ],
+    }
+    channel = Channel(id="C123", name="general", configs={"default": config})
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = sent_messages(mock_send_message)
+    first = next(line for line in sent_message.splitlines() if line.startswith("Excluded teams"))
+    indent = " " * (len(first) - len("Cloud Hosting"))
+    assert (
+        f"{first}\n"
+        f"{indent}m-kubed (m³)\n"
+        f"{indent}Systemarchitektur Infrastruktur/Technik\n"
+        f"{indent}Site Reliability"
+    ) in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_mention_test_uses_trailing_text_as_message():
+    import hutbot
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["reply_message"] = "Preview: {{message}} {{timestamp}} {{message_link}}"
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch.object(hutbot.state, 'bot_user_id', "UBOT"), \
+         patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={})), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "<@UBOT> test hello world", channel, user, "1234.1", allow_test_message=True, command_ts="1234.1")
+
+    app.client.chat_getPermalink.assert_awaited_once_with(channel="C12345", message_ts="1234.1")
+    sent_message = sent_messages(mock_send_message)
+    assert "Preview: hello world 1234.1 https://slack.test/message" in sent_message
+    assert "`{{message}}`: hello world" in sent_message
+    assert "`{{timestamp}}`: 1234.1" in sent_message
+    assert "`{{message_link}}`: https://slack.test/message" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_help_uses_compact_command_reference():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    sent_message = sent_messages(mock_send_message)
+    assert "*Show All Configurations:*" in sent_message
+    assert "Either use the command `/hutbot` or just `@Hutbot` me." in sent_message
+    assert "```/hutbot show config\n@Hutbot show config```" in sent_message
+    assert "Displays all configurations for `#team-asylum`." in sent_message
+    assert "*Commands:*\n```" in sent_message
+    assert "/hutbot [config] set wait-time <minutes>" in sent_message
+    assert "Set reminder delay." in sent_message
+    # Commands are grouped, each group headed and separated by a blank line.
+    assert "# Configurations\n/hutbot show config" in sent_message
+    assert "\n\n# Trigger\n" in sent_message
+    assert "\n\n# OpsGenie\n" in sent_message
+    assert "\n\n# Help\n/hutbot news" in sent_message
+    assert sent_message.index("# Trigger") < sent_message.index("# When to react") < sent_message.index("# Buttons")
+    assert "/hutbot [config] clear work-hours" in sent_message
+    assert "/hutbot [config] set trigger cron \"<expr>\"" in sent_message
+    # Removed commands are gone from the reference.
+    for stale in ("set target", "set cron <", "set schedule-timezone", "forward-channel",
+                  "button-timeout", "default-button"):
+        assert stale not in sent_message, stale
+    # Every dispatched command is documented.
+    assert "/hutbot [config] clear opsgenie-message" in sent_message
+    assert '/hutbot [config] set escalation <minutes> button "<label>"' in sent_message
+    assert "/hutbot [config] clear escalation" in sent_message
+    assert "/hutbot [config] clear pattern" in sent_message
+    assert "@Hutbot [config] test <message>" in sent_message
+    assert "Preview reply with <message> as {{message}}." in sent_message
+    assert "*Enable OpsGenie Integration:*" not in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_help_uses_configured_slash_command():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.slash_command', '/hutbot_dev'), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    sent_message = sent_messages(mock_send_message)
+    assert "Either use the command `/hutbot_dev` or just `@Hutbot` me." in sent_message
+    assert "/hutbot_dev [config] set wait-time <minutes>" in sent_message
+    assert "/hutbot " not in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_help_uses_configured_bot_name():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="team-asylum", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.state.bot_user_name', 'hutbot_dev'), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    sent_message = sent_messages(mock_send_message)
+    assert "I am *Hutbot (DEV)*" in sent_message
+    assert "or just `@hutbot_dev` me." in sent_message
+    assert "@hutbot_dev show config```" in sent_message
+    assert "@hutbot_dev [config] test <message>" in sent_message
+    assert "@Hutbot" not in sent_message
+
+
+@pytest.mark.asyncio
+async def test_show_config_names_the_destination_per_action():
+    app = AsyncMock()
+    configs = {
+        "post": {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL, "action_target": "<#CTARGET|targets>"},
+        "dm": {**DEFAULT_CONFIG.copy(), "action": ACTION_DM_USER, "action_target": "d.grieser@mittwald.de"},
+        "group": {**DEFAULT_CONFIG.copy(), "action": ACTION_GROUP_DM, "action_target": "SGROUP"},
+        "scheduled": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5"},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = sent_messages(mock_send_message)
+    assert "*Posted in* <#CTARGET>" in sent_message
+    assert "*Sent to* `d.grieser@mittwald.de` (direct message)" in sent_message
+    assert "*Sent to* <!subteam^SGROUP> (group message)" in sent_message
+    # No message to thread on for a schedule trigger.
+    assert "*Replied in* <#C123>\n" in sent_message
+    # The cron expression rides with the trigger, not as a settings row.
+    assert "> *Trigger*: `cron` `0 9 * * 1-5`" in sent_message
+    assert "\nCron " not in sent_message
+    # Non-reply actions title their template "Message", not "Reply message".
+    assert "*Message*:" in sent_message
+    assert "Action target" not in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_show_config_displays_replies_enabled():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": True}})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send:
+        await show_config(app, channel, user)
+
+    sent_message = sent_messages(mock_send)
+    assert "\n\n*Configuration*: `default` (enabled)" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_show_config_displays_replies_disabled():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send:
+        await show_config(app, channel, user)
+
+    sent_message = sent_messages(mock_send)
+    assert "\n\n*Configuration*: `default` (disabled)" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_need_help_yes_no_workflow_end_to_end():
+    # "Need help?" with Yes (message) / No (ack); wait 5m ⇒ auto-press Yes.
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "p"}
+    app.client.chat_postMessage.return_value = {"ts": "R1"}
+    ch = Channel(id="C1", name="support", configs={})
+    u = User("U1", "dave", "Dave", "T")
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), patch('hutbot.messaging.send_message', new=AsyncMock()), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), patch('hutbot.persistence.flush_button_cache', new=AsyncMock()):
+        await process_command(app, 'set message Need help?', ch, u)
+        await process_command(app, 'add button "Yes" ack "Here is the help doc"', ch, u)
+        await process_command(app, 'add button "No" ack', ch, u)
+        await process_command(app, 'set escalation 5 button "Yes"', ch, u)
+        cfg = ch.configs["default"]
+
+        # Fire the reply; an auto-press-Yes escalation is registered (no inline message yet).
+        hutbot.state.pending_buttons.clear()
+        await hutbot.scheduling.schedule_reply(app, "tok", ch, cfg, "default", u, "orig", "M1", wait_time_override=0)
+        entry = hutbot.state.pending_buttons.get(("C1", "R1"))
+        assert entry is not None and entry["escalation_kind"] == "button" and entry["escalation_target"] == "Yes"
+        # Drop the live 5-minute timer; we trigger the escalation manually below.
+        if entry["task"]:
+            entry["task"].cancel()
+
+        # No press within timeout ⇒ escalation auto-presses Yes ⇒ posts the help message.
+        with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=Channel("C1", "support", ch.configs))), \
+             patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=u)), \
+             patch('hutbot.messaging._post_message', new=AsyncMock()) as post:
+            await hutbot.buttons._escalation_task(app, "tok", ("C1", "R1"), 0)
+        post.assert_awaited_once_with(app, "C1", "Here is the help doc", None, "R1")
+    await asyncio.sleep(0)  # let the cancelled timer settle
+
+
+@pytest.mark.asyncio
+async def test_show_config_explains_an_automatic_disable():
+    app = AsyncMock()
+    configs = {
+        "removed": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+    }
+    channel = Channel(id="C123", name="general", configs=configs)
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+    hutbot.state.bot_name = "Hutbot"
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = sent_messages(mock_send_message)
+    assert "*Configuration*: `removed` (disabled, because Hutbot was removed from this channel)" in sent_message
+    assert "*Configuration*: `by-hand` (disabled)" in sent_message
+
+
+@pytest.mark.asyncio
+async def test_show_config_marks_the_instance_default_locale():
+    app = AsyncMock()
+    channel = Channel(id="C123", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User(id="U123", name="test", real_name="Test User", team="A")
+
+    channel.configs["default"]["reply_message"] = "at {{time}}"
+    with patch('hutbot.state.default_datetime_locale', "de_DE"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    assert "Date/time locale    de_DE (instance default)" in sent_messages(mock_send_message).splitlines()
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["help", "news"])
+async def test_help_and_news_name_the_running_version(command):
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.state.version', "v1.2.3"), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert "I am *Hutbot* `v1.2.3` :palm_up_hand::tophat:" in sent_messages(mock_send_message)
+
+
+@pytest.mark.asyncio
+async def test_help_is_split_into_messages_slack_will_not_cut_apart():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "help", channel, user)
+
+    texts = [call.args[3] for call in mock_send_message.call_args_list]
+    assert len(texts) > 1
+    for text in texts:
+        assert len(text) <= hutbot.messaging.SLACK_MESSAGE_CHARACTER_LIMIT, len(text)
+        # Every code fence a message opens, it also closes.
+        assert text.count("```") % 2 == 0, text
+    assert "*Commands:*" in texts[1]
+    assert "*Commands (continued):*" in texts[2]
+
+
+@pytest.mark.asyncio
+async def test_show_config_splits_many_configs_into_several_messages():
+    import hutbot
+    app = AsyncMock()
+    configs = {f"config-{index}": {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}}"} for index in range(8)}
+    channel = Channel(id="C1", name="general", configs=configs)
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    texts = [call.args[3] for call in mock_send_message.call_args_list]
+    assert len(texts) > 1
+    for text in texts:
+        assert len(text) <= hutbot.messaging.SLACK_MESSAGE_CHARACTER_LIMIT, len(text)
+        assert text.count("```") % 2 == 0, text
+    # No config is spread over two messages.
+    joined = sent_messages(mock_send_message)
+    for name in configs:
+        assert joined.count(f"*Configuration*: `{name}`") == 1
+
+
+def test_pack_message_chunks_keeps_an_oversized_part_whole():
+    import hutbot
+    parts = ["a" * 3000, "b" * 3000, "c" * 5000]
+
+    chunks = hutbot.messaging.pack_message_chunks(parts)
+
+    assert chunks == ["a" * 3000, "b" * 3000, "c" * 5000]
+    assert hutbot.messaging.pack_message_chunks(["x", "y"]) == ["x\n\ny"]
+    assert hutbot.messaging.pack_message_chunks([]) == []
+
+
+@pytest.mark.asyncio
+async def test_show_config_hides_settings_that_do_not_apply():
+    app = AsyncMock()
+    configs = {
+        # manual: no matching, no reminder delay, no work hours, nothing renders a date
+        "post": {**DEFAULT_CONFIG.copy(), "trigger": "manual", "reply_message": ":x: pressed"},
+        # cron with a date in its message: condition + full date/time block
+        "standup": {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5",
+                    "reply_message": "Standup at {{time}}", "condition": "outlook_calendar"},
+        # message trigger with work hours: timezone only, no formats
+        "watch": {**DEFAULT_CONFIG.copy(), "hours": ["9:00", "17:00"]},
+    }
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sections = {name: part for name, part in
+                ((p.split("`")[1], p) for p in sent_messages(mock_send_message).split("*Configuration*: ")[1:])}
+
+    manual = sections["post"]
+    for mute in ("Pattern", "Included teams", "Include bots", "Wait time", "Only work days",
+                 "Work hours", "Date format", "Date/time timezone", "Condition"):
+        assert mute not in manual, mute
+    assert "OpsGenie" in manual
+
+    cron = sections["standup"]
+    assert "Condition           outlook_calendar" in cron
+    assert "Date format" in cron and "Date/time locale" in cron
+    for mute in ("Pattern", "Wait time", "Work hours", "Include bots"):
+        assert mute not in cron, mute
+
+    watch = sections["watch"]
+    assert "Work hours          9:00 - 17:00" in watch
+    # Work hours are counted in that timezone, but nothing renders a date.
+    assert "Date/time timezone" in watch
+    assert "Date format" not in watch and "Date/time locale" not in watch
+
+    assert "_Only the settings that apply to each configuration are shown._" in sent_messages(mock_send_message)
+
+
+@pytest.mark.asyncio
+async def test_show_config_hides_a_condition_on_a_non_cron_trigger():
+    app = AsyncMock()
+    # A condition is only evaluated when a cron fires, so it is noise elsewhere.
+    config = {**DEFAULT_CONFIG.copy(), "condition": "outlook_calendar", "outlook_subject_pattern": ".*x.*"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await show_config(app, channel, user, "")
+
+    sent_message = sent_messages(mock_send_message)
+    assert "Condition" not in sent_message
+    assert "Outlook subject" not in sent_message
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
new file mode 100644
index 0000000..d07e593
--- /dev/null
+++ b/tests/test_commands_setters.py
@@ -0,0 +1,713 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_wait_time():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set wait-time 10", channel, user, thread_ts)
+        assert channel.configs["default"]["wait_time"] == 600
+        mock_send_message.assert_called_with(app, channel, user, "*Wait time* set to `10` minutes in configuration `default`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_wait_time_custom_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "my-config set wait-time 20", channel, user, thread_ts)
+        assert channel.configs["my-config"]["wait_time"] == 1200
+        mock_send_message.assert_called_with(app, channel, user, "*Wait time* set to `20` minutes in configuration `my-config`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_wait_time_invalid_value():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+    original_wait_time = channel.configs["default"]["wait_time"]
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set wait-time 30s", channel, user, thread_ts)
+        assert channel.configs["default"]["wait_time"] == original_wait_time
+        mock_send_message.assert_called_with(app, channel, user, "Invalid wait time. Must be a number between 0 and 1440.", thread_ts)
+
+
+@pytest.mark.asyncio
+async def test_process_command_reports_unexpected_errors():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.messaging.send_message') as mock_send_message, \
+            patch('hutbot.commands.dispatch.parse_and_execute_command', side_effect=RuntimeError("boom")):
+        await process_command(app, "set wait-time 10", channel, user, thread_ts)
+        assert mock_send_message.await_count == 1
+        assert "something went wrong" in mock_send_message.await_args.args[3]
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_datetime_format_with_quotes_timezone_and_locale():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set datetime-format \"%a, %d %b %Y\" \"%H:%M\" Europe/Berlin de-DE", channel, user, thread_ts)
+
+    assert channel.configs["default"]["date_format"] == "%a, %d %b %Y"
+    assert channel.configs["default"]["time_format"] == "%H:%M"
+    assert channel.configs["default"]["datetime_timezone"] == "Europe/Berlin"
+    assert channel.configs["default"]["datetime_locale"] == "de_DE"
+    mock_send_message.assert_called_with(
+        app,
+        channel,
+        user,
+        "*Date/time format* set to date `%a, %d %b %Y` and time `%H:%M`, timezone `Europe/Berlin`, locale `de_DE` in configuration `default`.",
+        thread_ts
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_datefmt_alias_rejects_invalid_timezone():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration') as mock_save, patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set datefmt %Y %H:%M Mars/Base de-DE", channel, user, thread_ts)
+
+    mock_save.assert_not_called()
+    sent_message = mock_send_message.call_args.args[3]
+    assert "Invalid *date/time format*" in sent_message
+    assert "unknown timezone `Mars/Base`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_delete_config():
+    app = AsyncMock()
+    configs = {
+        "default": DEFAULT_CONFIG.copy(),
+        "todelete": DEFAULT_CONFIG.copy()
+    }
+    channel = Channel(id="C12345", name="general", configs=configs)
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        # Test deleting a config
+        await process_command(app, "delete config todelete", channel, user, thread_ts)
+        assert "todelete" not in channel.configs
+        mock_send_message.assert_called_with(app, channel, user, "Configuration `todelete` has been deleted.", thread_ts)
+
+        # Test deleting default config
+        await process_command(app, "delete config default", channel, user, thread_ts)
+        assert "default" in channel.configs
+        mock_send_message.assert_called_with(app, channel, user, "The `default` configuration cannot be deleted.", thread_ts)
+
+        # Test deleting non-existent config
+        await process_command(app, "delete config non-existent", channel, user, thread_ts)
+        mock_send_message.assert_called_with(app, channel, user, "Configuration `non-existent` not found.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_set_reply_message_rejects_malformed_datetime_args():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(fmt='%Y',)}}", user, "")
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "Invalid *reply message*: malformed template expression" in sent_message
+    assert "missing argument after `,`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_set_reply_message_rejects_unknown_arg_invalid_timezone_and_locale():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(foo=bar)}}", user, "")
+    assert "unknown argument `foo`" in mock_send_message.call_args.args[3]
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(tz=Mars/Base)}}", user, "")
+    assert "unknown timezone `Mars/Base`" in mock_send_message.call_args.args[3]
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", "{{opsgenie_current_start_datetime(lc=not-a-locale)}}", user, "")
+    assert "locale must look like" in mock_send_message.call_args.args[3]
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_test_renders_default_reply_and_variables():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    channel.configs["default"]["wait_time"] = 600
+    channel.configs["default"]["reply_message"] = "Hi {{user}}, wait {{wait_minutes}} in {{channel}}: {{message_link}}"
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={
+        "opsgenie_current_user": "<@U999>",
+        "opsgenie_current_email": "oncall@example.com",
+        "opsgenie_current_name": "On Call User",
+    })) as mock_get_opsgenie_template_variables, patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "test", channel, user)
+
+    mock_get_opsgenie_template_variables.assert_awaited_once()
+    app.client.chat_getPermalink.assert_not_called()
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Reply preview for configuration `default`:*" in sent_message
+    assert "Hi <@U12345>, wait 10 in #general: " in sent_message
+    assert "`{{channel}}`: #general" in sent_message
+    assert "`{{config}}`: default" in sent_message
+    assert "`{{message}}`: " in sent_message
+    assert "`{{message_link}}`: " in sent_message
+    assert "`{{opsgenie_current_user}}`: <@U999>" in sent_message
+    assert "`{{timestamp}}`: " in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_test_uses_selected_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={
+        "default": DEFAULT_CONFIG.copy(),
+        "alerts": DEFAULT_CONFIG.copy(),
+    })
+    channel.configs["alerts"]["wait_time"] = 120
+    channel.configs["alerts"]["reply_message"] = "Config {{config}} waits {{wait_minutes}}: {{message}}"
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={})), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "alerts test", channel, user)
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Reply preview for configuration `alerts`:*" in sent_message
+    assert "Config alerts waits 2: " in sent_message
+    assert "`{{config}}`: alerts" in sent_message
+    assert "`{{wait_minutes}}`: 2" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_slash_test_with_trailing_text_is_unknown():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock()) as mock_get_opsgenie_template_variables, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "test hello world", channel, user)
+
+    mock_get_opsgenie_template_variables.assert_not_awaited()
+    mock_send_message.assert_called_with(app, channel, user, "Huh? :thinking_face: Maybe type `/hutbot help` for a list of commands.", "")
+
+
+
+@pytest.mark.asyncio
+async def test_set_replies_enabled_enables():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send:
+        await set_replies_enabled(app, channel, "default", True, user)
+
+    assert channel.configs["default"]["enabled"] is True
+    mock_send.assert_awaited_once()
+    assert "enabled" in mock_send.call_args[0][3]
+
+
+
+@pytest.mark.asyncio
+async def test_set_replies_enabled_disables():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send:
+        await set_replies_enabled(app, channel, "default", False, user)
+
+    assert channel.configs["default"]["enabled"] is False
+    assert "disabled" in mock_send.call_args[0][3]
+
+
+
+@pytest.mark.asyncio
+async def test_set_replies_enabled_creates_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await set_replies_enabled(app, channel, "newcfg", False, user)
+
+    assert "newcfg" in channel.configs
+    assert channel.configs["newcfg"]["enabled"] is False
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_enable_replies():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "enabled": False}})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await process_command(app, "enable", channel, user)
+
+    assert channel.configs["default"]["enabled"] is True
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_disable_replies():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await process_command(app, "disable", channel, user)
+
+    assert channel.configs["default"]["enabled"] is False
+
+
+
+# ----- Setters -----
+
+@pytest.mark.asyncio
+async def test_set_trigger_valid_and_invalid():
+    app = AsyncMock()
+    channel = _mk_channel()
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set trigger cron \"0 9 * * 1-5\"", channel, user)
+        assert channel.configs["default"]["trigger"] == TRIGGER_CRON
+        assert channel.configs["default"]["cron"] == "0 9 * * 1-5"
+        # `schedule` still resolves to the cron trigger.
+        await process_command(app, "set trigger schedule \"0 8 * * *\"", channel, user)
+        assert channel.configs["default"]["cron"] == "0 8 * * *"
+        await process_command(app, "set trigger bogus", channel, user)
+        assert channel.configs["default"]["trigger"] == TRIGGER_CRON  # unchanged
+        assert "Invalid *trigger*" in send.call_args_list[-1].args[3]
+
+
+@pytest.mark.asyncio
+async def test_set_trigger_cron_requires_a_valid_expression():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set trigger cron", channel, user)
+        assert send.call_args.args[3] == (
+            'Trigger `cron` needs an expression: `/hutbot default set trigger cron "0 9 * * 1-5"`.'
+        )
+        await process_command(app, "set trigger cron not a cron", channel, user)
+        assert "Invalid *cron* expression: `not a cron`" in send.call_args.args[3]
+
+    # Neither attempt stored anything, so no rule sits there never firing.
+    assert config["trigger"] == "message"
+    assert config["cron"] == ""
+
+
+@pytest.mark.asyncio
+async def test_set_trigger_message_takes_no_expression_and_clears_the_cron():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "trigger": TRIGGER_CRON, "cron": "0 9 * * 1-5"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as send:
+        await process_command(app, "set trigger message 0 9 * * 1-5", channel, user)
+        assert send.call_args.args[3] == "Trigger `message` takes no expression; only `cron` does."
+        assert config["cron"] == "0 9 * * 1-5"
+
+        await process_command(app, "set trigger message", channel, user)
+
+    assert send.call_args.args[3] == "*Trigger* set to `message` in configuration `default`."
+    assert config["cron"] == ""
+
+
+@pytest.mark.asyncio
+async def test_set_replies_enabled_clears_the_automatic_disable_reason():
+    app = AsyncMock()
+    configs = {"default": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED}}
+    channel = Channel(id="C12345", name="general", configs=configs)
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message'):
+        await set_replies_enabled(app, channel, "default", True, user)
+
+    assert channel.configs["default"]["enabled"] is True
+    assert channel.configs["default"]["disabled_reason"] == ""
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["clear work-hours", "unset hours", "remove work hours"])
+async def test_clear_work_hours_reacts_at_any_hour(command):
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": {**DEFAULT_CONFIG.copy(), "hours": ["8:00", "16:00"]}})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert channel.configs["default"]["hours"] == []
+    assert mock_send_message.call_args.args[3] == (
+        "*Work hours* cleared in configuration `default`; messages are handled at any hour."
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_work_hours_all_day_points_at_the_clear_command():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "hours": ["8:00", "16:00"]}
+    channel = Channel(id="C1", name="general", configs={"default": config})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set work-hours all day", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "To handle messages at any hour, use `/hutbot default clear work-hours`."
+    )
+    assert config["hours"] == ["8:00", "16:00"]
+
+
+@pytest.mark.asyncio
+async def test_set_work_hours_still_takes_two_times():
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U1", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set work-hours 9 17", channel, user)
+
+    assert channel.configs["default"]["hours"] == ["09:00", "17:00"]
+    assert mock_send_message.call_args.args[3] == "*Work hours* set to `09:00` - `17:00` in configuration `default`"
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["test", "run"])
+async def test_test_and_run_populate_the_time_variables(command):
+    import hutbot
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "R1"}
+    config = {**DEFAULT_CONFIG.copy(), "reply_message": "at {{time}} on {{date}}, ts {{timestamp}}"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={})), \
+         patch('hutbot.messaging._post_message', new=AsyncMock(return_value={"channel": "C1", "ts": "R1"})) as post, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    rendered = mock_send_message.call_args.args[3] if command == "test" else post.await_args.args[2]
+    assert "at  on , ts \n" not in rendered
+    assert "ts {{timestamp}}" not in rendered
+    assert re.search(r"at \d{2}:\d{2} on \w{3}, \d{2} \w{3} \d{4}, ts \d+\.\d+", rendered), rendered
+
+
+@pytest.mark.asyncio
+async def test_set_action_requires_a_target_in_the_same_command():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action post-channel", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "Action `post_channel` needs a target: `/hutbot default set action post-channel <#channel>`."
+    )
+    # Nothing was stored, so the config cannot end up in a state that fails when it runs.
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command,action,target", [
+    ("set action post-channel <#CTARGET|targets>", ACTION_POST_CHANNEL, "<#CTARGET|targets>"),
+    ("set action dm-user <@U999>", ACTION_DM_USER, "<@U999>"),
+    ("set action group-dm @sre", ACTION_GROUP_DM, "@sre"),
+])
+async def test_set_action_stores_action_and_target_together(command, action, target):
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["action"] == action
+    assert config["action_target"] == target
+    assert mock_send_message.call_args.args[3] == (
+        f"*Action* set to `{action}` sending to `{target}` in configuration `default`."
+    )
+
+
+@pytest.mark.asyncio
+async def test_set_action_reply_takes_no_target_and_clears_the_old_one():
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL, "action_target": "<#CTARGET|targets>"}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action reply <#CTARGET|targets>", channel, user)
+        assert mock_send_message.call_args.args[3] == "Action `reply` posts in this channel and takes no target."
+        assert config["action"] == ACTION_POST_CHANNEL
+
+        await process_command(app, "set action reply", channel, user)
+
+    assert mock_send_message.call_args.args[3] == "*Action* set to `reply` in configuration `default`."
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+async def test_set_action_rejects_a_non_channel_target_for_post_channel():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set action post-channel @dave", channel, user)
+
+    assert "Invalid *target* `@dave` for action `post_channel`" in mock_send_message.call_args.args[3]
+    assert config["action"] == ACTION_REPLY
+    assert config["action_target"] == ""
+
+
+@pytest.mark.asyncio
+async def test_run_refuses_a_config_whose_action_has_no_target():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.messaging._post_message', new=AsyncMock()) as post, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "run", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "Cannot run configuration `default`: action `post_channel` has no target. "
+        "Set one with `/hutbot default set action post-channel <#channel>`."
+    )
+    post.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_run_action_refuses_instead_of_posting_with_an_empty_target():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "action": ACTION_POST_CHANNEL}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+
+    with patch('hutbot.messaging._post_message', new=AsyncMock()) as post:
+        posted = await hutbot.actions.run_action(app, "tok", channel, config, "default", context={'channel_id': channel.id})
+
+    assert posted is None
+    post.assert_not_awaited()
+    assert hutbot.actions.missing_target_reason({**DEFAULT_CONFIG.copy()}) == ""
+    assert hutbot.actions.missing_target_reason({**config, "action_target": "not-a-channel"}) == (
+        "action `post_channel` target `not-a-channel` is not a channel"
+    )
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", [
+    "action post-channel <#CTARGET|targets>",
+    "set action post-channel <#CTARGET|targets>",
+])
+async def test_action_command_works_with_and_without_set(command):
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["action"] == ACTION_POST_CHANNEL
+    assert config["action_target"] == "<#CTARGET|targets>"
+    assert mock_send_message.call_args.args[3] == (
+        "*Action* set to `post_channel` sending to `<#CTARGET|targets>` in configuration `default`."
+    )
+
+
+@pytest.mark.asyncio
+async def test_bare_action_command_still_takes_a_config_name():
+    app = AsyncMock()
+    configs = {"logs": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "logs action dm-user <@U999>", channel, user)
+        assert configs["logs"]["action"] == ACTION_DM_USER
+        assert configs["logs"]["action_target"] == "<@U999>"
+
+        # `action` alone is not a command.
+        await process_command(app, "action", channel, user)
+
+    assert "Huh?" in mock_send_message.call_args.args[3]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command", ["clear pattern", "unset pattern", "remove pattern"])
+async def test_clear_pattern_makes_every_message_match_again(command):
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "pattern": ".*alarm.*", "pattern_case_sensitive": True}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, command, channel, user)
+
+    assert config["pattern"] is None
+    # Case sensitivity is part of the pattern, so it goes back to the default too.
+    assert config["pattern_case_sensitive"] is False
+    assert mock_send_message.call_args.args[3] == (
+        "*Pattern* cleared in configuration `default`; every message matches now."
+    )
+
+
+@pytest.mark.asyncio
+async def test_clear_pattern_does_not_shadow_setting_one():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message'):
+        await process_command(app, 'set pattern ".*alarm.*" 1', channel, user)
+
+    assert config["pattern"] == ".*alarm.*"
+    assert config["pattern_case_sensitive"] is True
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command,field,value", [
+    ('trigger cron "0 9 * * 1-5"', "cron", "0 9 * * 1-5"),
+    ("condition outlook", "condition", "outlook_calendar"),
+    ('pattern ".*alarm.*"', "pattern", ".*alarm.*"),
+    ("opsgenie-schedule SRE", "opsgenie_schedule_name", "SRE"),
+    ("opsgenie-priority P2", "opsgenie_priority", "P2"),
+    ("opsgenie-message Alert!", "opsgenie_message", "Alert!"),
+    ("outlook-subject .*urlaub.*", "outlook_subject_pattern", ".*urlaub.*"),
+    ("outlook-body .*ooo.*", "outlook_body_pattern", ".*ooo.*"),
+    ("escalation 5 config alarm", "escalation_timeout", 300),
+])
+async def test_every_setting_command_works_without_the_word_set(command, field, value):
+    app = AsyncMock()
+    user = User("U1", "dave", "Dave", "T")
+
+    for text in (command, f"set {command}"):
+        config = DEFAULT_CONFIG.copy()
+        channel = Channel(id="C1", name="davetest", configs={"default": config})
+        with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+             patch('hutbot.messaging.send_message'):
+            await process_command(app, text, channel, user)
+        assert config[field] == value, text
+
+
+@pytest.mark.asyncio
+async def test_an_existing_config_wins_an_ambiguous_first_word():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy(), "trigger": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        # Both readings fit: the `trigger` config's message, or the default config's
+        # trigger. The named config wins.
+        await process_command(app, "trigger message hello", channel, user)
+        assert configs["trigger"]["reply_message"] == "hello"
+        assert configs["default"]["reply_message"] == DEFAULT_CONFIG["reply_message"]
+
+        # `cron "…"` is not a command on its own, so this can only be the command.
+        await process_command(app, 'trigger cron "0 9 * * 1-5"', channel, user)
+
+    assert configs["default"]["trigger"] == TRIGGER_CRON
+    assert configs["trigger"]["trigger"] == "message"
+    assert "in configuration `default`" in mock_send_message.call_args.args[3]
+
+
+@pytest.mark.asyncio
+async def test_a_command_word_is_not_taken_as_a_config_name():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set enable", channel, user)
+
+    assert mock_send_message.call_args.args[3] == (
+        "`set` cannot be a configuration name; it starts a command. Check the syntax with `/hutbot help`."
+    )
+    assert sorted(configs) == ["default"]
+
+
+@pytest.mark.asyncio
+async def test_a_typo_does_not_create_a_config():
+    app = AsyncMock()
+    configs = {"default": DEFAULT_CONFIG.copy()}
+    channel = Channel(id="C1", name="davetest", configs=configs)
+    user = User("U1", "dave", "Dave", "T")
+
+    with patch('hutbot.persistence.save_configuration', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "wiat-time 5", channel, user)
+        assert "Huh?" in mock_send_message.call_args.args[3]
+        # A real command behind a new name still creates it.
+        await process_command(app, "alarms wait-time 5", channel, user)
+
+    assert configs["alarms"]["wait_time"] == 300
+    assert sorted(configs) == ["alarms", "default"]
diff --git a/tests/test_datetimefmt.py b/tests/test_datetimefmt.py
new file mode 100644
index 0000000..df6c07d
--- /dev/null
+++ b/tests/test_datetimefmt.py
@@ -0,0 +1,176 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+def test_format_datetime_value_supports_python_format_timezone_and_locale():
+    import hutbot
+    config = {
+        **DEFAULT_CONFIG.copy(),
+        "date_format": "%A, %d %B %Y",
+        "time_format": "%H:%M",
+        "datetime_timezone": "Europe/Berlin",
+        "datetime_locale": "de-DE",
+    }
+
+    assert hutbot.datetimefmt.format_datetime_value("2026-04-26T08:00:00Z", "datetime", config) == "Sonntag, 26 April 2026 10:00"
+
+
+
+def test_format_datetime_value_supports_go_layout_args():
+    import hutbot
+    rendered = hutbot.datetimefmt.format_datetime_value(
+        "2026-04-26T08:00:00Z",
+        "datetime",
+        DEFAULT_CONFIG.copy(),
+        {"fmt": "02.01.2006 15:04", "tz": "UTC", "lc": "en-us"},
+    )
+
+    assert rendered == "26.04.2026 08:00"
+
+
+
+def test_describe_timezone_names_the_zone_and_its_current_offset():
+    import hutbot
+    assert hutbot.datetimefmt.describe_timezone("Asia/Tokyo") == "Asia/Tokyo (JST, UTC+09:00)"
+    assert hutbot.datetimefmt.describe_timezone("Nowhere/Sometime") == "Nowhere/Sometime (unknown timezone)"
+
+
+
+def test_describe_timezone_falls_back_to_the_server_timezone():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "Australia/Sydney"}):
+        described = hutbot.datetimefmt.describe_timezone()
+
+    assert described.startswith("Australia/Sydney (")
+    assert described.endswith(", server local time)")
+
+
+
+def test_get_local_timezone_name_prefers_tz_then_etc_timezone():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "America/New_York"}):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "America/New_York"
+
+    with patch.dict(os.environ, {}, clear=True), \
+         patch('builtins.open', mock_open(read_data="Etc/UTC\n")):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "Etc/UTC"
+
+
+
+def test_get_local_timezone_name_reads_the_localtime_symlink():
+    import hutbot
+    with patch.dict(os.environ, {}, clear=True), \
+         patch('builtins.open', side_effect=OSError), \
+         patch('os.path.realpath', return_value="/usr/share/zoneinfo/Europe/Berlin"):
+        assert hutbot.datetimefmt.get_local_timezone_name() == "Europe/Berlin"
+
+
+
+def test_describe_locale_explains_what_names_a_config_gets():
+    import hutbot
+    assert hutbot.datetimefmt.describe_locale("de_DE") == "de_DE"
+    assert hutbot.datetimefmt.describe_locale("fr_FR") == "fr_FR (no translations, English names)"
+
+    with patch('hutbot.datetimefmt.get_server_locale_name', return_value="de_DE"):
+        assert hutbot.datetimefmt.describe_locale() == "English names (server locale de_DE not applied)"
+
+    with patch('hutbot.datetimefmt.get_server_locale_name', return_value=""):
+        assert hutbot.datetimefmt.describe_locale() == "English names (no server locale set)"
+
+
+
+def test_get_server_locale_name_uses_lc_time_then_the_environment():
+    import hutbot
+    with patch('locale.getlocale', return_value=("de_DE", "UTF-8")):
+        assert hutbot.datetimefmt.get_server_locale_name() == "de_DE"
+
+    with patch('locale.getlocale', return_value=(None, None)), \
+         patch.dict(os.environ, {"LANG": "en_GB.UTF-8"}, clear=True):
+        assert hutbot.datetimefmt.get_server_locale_name() == "en_GB"
+
+    with patch('locale.getlocale', return_value=("C", None)), \
+         patch.dict(os.environ, {"LANG": "C.UTF-8"}, clear=True):
+        assert hutbot.datetimefmt.get_server_locale_name() == ""
+
+
+
+def test_describe_timezone_does_not_repeat_the_abbreviation_in_the_zone_name():
+    import hutbot
+    with patch.dict(os.environ, {"TZ": "Etc/UTC"}), \
+         patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Etc/UTC")):
+        assert hutbot.datetimefmt.describe_timezone() == "Etc/UTC (UTC+00:00, server local time)"
+    assert hutbot.datetimefmt.describe_timezone("UTC") == "UTC (UTC+00:00)"
+
+
+
+def frozen_datetime_module(moment: datetime.datetime):
+    """Stand-in for the `datetime` module whose `now()` always returns `moment`."""
+    class Frozen(datetime.datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return moment.astimezone(tz) if tz else moment
+
+    return SimpleNamespace(datetime=Frozen, date=datetime.date, time=datetime.time, timezone=datetime.timezone)
+
+
+
+def test_work_hours_are_counted_in_the_configured_timezone():
+    import hutbot
+    # 23:30 in Berlin is 06:30 the next day in Tokyo: inside 6-18 Tokyo hours,
+    # outside 6-18 Berlin hours.
+    berlin_late_evening = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=ZoneInfo("Europe/Berlin"))
+
+    with patch.object(hutbot.datetimefmt, 'datetime', frozen_datetime_module(berlin_late_evening)):
+        assert hutbot.datetimefmt.is_work_time("6", "18", {"datetime_timezone": "Asia/Tokyo"}) is True
+        assert hutbot.datetimefmt.is_work_time("6", "18", {"datetime_timezone": "Europe/Berlin"}) is False
+        # No configured timezone: the server's, as before.
+        with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Asia/Tokyo")):
+            assert hutbot.datetimefmt.is_work_time("6", "18", {}) is True
+
+
+
+def test_work_days_are_counted_in_the_configured_timezone():
+    import hutbot
+    # Friday 23:30 in Berlin is already Saturday in Tokyo.
+    berlin_friday_night = datetime.datetime(2026, 4, 24, 23, 30, tzinfo=ZoneInfo("Europe/Berlin"))
+
+    with patch.object(hutbot.datetimefmt, 'datetime', frozen_datetime_module(berlin_friday_night)):
+        assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Europe/Berlin"}) is True
+        assert hutbot.datetimefmt.is_work_day({"datetime_timezone": "Asia/Tokyo"}) is False
+
+
+
+def test_instance_default_locale_applies_to_configs_without_one():
+    import hutbot
+    with patch('hutbot.state.default_datetime_locale', "de_DE"):
+        assert hutbot.datetimefmt.get_config_locale({}) == "de_DE"
+        assert hutbot.datetimefmt.get_config_locale({"datetime_locale": "en-US"}) == "en_US"
+        # An unusable config locale falls back to the default, not to English.
+        assert hutbot.datetimefmt.get_config_locale({"datetime_locale": "nonsense!"}) == "de_DE"
+        assert hutbot.datetimefmt.describe_locale("") == "de_DE (instance default)"
+        assert hutbot.datetimefmt.describe_locale("en_US") == "en_US (no translations, English names)"
+
+    rendered = hutbot.datetimefmt.format_datetime_value(
+        "2026-04-26T08:00:00Z", "date", {"date_format": "%A, %d %B %Y", "datetime_timezone": "Europe/Berlin"},
+    )
+    assert rendered == "Sunday, 26 April 2026"
+    with patch('hutbot.state.default_datetime_locale', "de_DE"):
+        rendered = hutbot.datetimefmt.format_datetime_value(
+            "2026-04-26T08:00:00Z", "date", {"date_format": "%A, %d %B %Y", "datetime_timezone": "Europe/Berlin"},
+        )
+    assert rendered == "Sonntag, 26 April 2026"
+
+
+
+def test_resolve_default_locale_rejects_garbage():
+    import hutbot
+    assert hutbot.datetimefmt.resolve_default_locale(" de-de ") == "de_DE"
+    assert hutbot.datetimefmt.resolve_default_locale("") == ""
+    assert hutbot.datetimefmt.resolve_default_locale("Deutsch (Deutschland)") == ""
+
+
+
+def test_describe_locale_flags_an_invalid_config_locale():
+    import hutbot
+    with patch('hutbot.state.default_datetime_locale', ""):
+        assert hutbot.datetimefmt.describe_locale("nonsense!") == "nonsense! (invalid locale, English names)"
diff --git a/tests/test_deployment_validation.py b/tests/test_deployment_validation.py
new file mode 100644
index 0000000..1eb8db2
--- /dev/null
+++ b/tests/test_deployment_validation.py
@@ -0,0 +1,103 @@
+import subprocess
+from pathlib import Path
+
+import pytest
+
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def _helm_template_command(tag):
+    return [
+        "helm", "template", "hutbot", str(ROOT / "charts/hutbot"),
+        "--show-only", "templates/deployment.yaml",
+        "--set", f"image.tag={tag}",
+        "--set", "networkPolicy.rules[0].port=443",
+        "--set-string", "networkPolicy.rules[0].cidrs[0]=0.0.0.0/0",
+    ]
+
+
+@pytest.mark.parametrize("script", ["deploy-dev.sh", "deploy-prod.sh"])
+@pytest.mark.parametrize("tag", ["latest", "main", "MAIN"])
+def test_deploy_scripts_reject_floating_tags(script, tag):
+    result = subprocess.run(
+        [str(ROOT / script), tag],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "must be pinned" in result.stderr
+
+
+@pytest.mark.parametrize("tag", ["latest", "main", "MAIN"])
+def test_chart_rejects_floating_tags(tag):
+    result = subprocess.run(
+        _helm_template_command(tag),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode != 0
+    assert "floating tags" in result.stderr
+
+
+def test_chart_accepts_pinned_tag():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "image: \"hutbot:v1.2.3\"" in result.stdout
+
+
+def test_chart_forces_timezone_and_default_locale_when_set():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3") + [
+            "--set", "time.timezone=Europe/Berlin",
+            "--set", "time.locale=de_DE",
+        ],
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "- name: TZ\n              value: \"Europe/Berlin\"" in result.stdout
+    assert "- name: HUTBOT_DEFAULT_DATETIME_LOCALE\n              value: \"de_DE\"" in result.stdout
+
+
+def test_chart_omits_timezone_and_locale_by_default():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "name: TZ" not in result.stdout
+    assert "HUTBOT_DEFAULT_DATETIME_LOCALE" not in result.stdout
+
+
+def test_chart_passes_the_image_tag_as_the_bot_version():
+    result = subprocess.run(
+        _helm_template_command("v1.2.3"),
+        cwd=ROOT,
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+
+    assert result.returncode == 0, result.stderr
+    assert "- name: HUTBOT_VERSION\n              value: \"v1.2.3\"" in result.stdout
diff --git a/tests/test_entrypoint.py b/tests/test_entrypoint.py
new file mode 100644
index 0000000..a5e9a31
--- /dev/null
+++ b/tests/test_entrypoint.py
@@ -0,0 +1,46 @@
+"""Compatibility checks for runtime entry points."""
+
+
+def test_legacy_bot_entrypoint_delegates_to_package_main():
+    import bot
+    from hutbot.__main__ import main
+
+    assert bot.main is main
+
+
+import pytest
+from unittest.mock import AsyncMock, patch
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_prefers_the_profile_display_name():
+    import hutbot
+    app = AsyncMock()
+    app.client.users_info.return_value = {
+        "user": {"name": "hutbotdev", "profile": {"display_name": "Hutbot_DEV", "display_name_normalized": "Hutbot_DEV"}}
+    }
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == "Hutbot_DEV"
+    app.client.users_info.assert_awaited_once_with(user="UBOT")
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_falls_back_to_the_username():
+    import hutbot
+    app = AsyncMock()
+    app.client.users_info.return_value = {"user": {"name": "hutbotdev", "profile": {"display_name": "  "}}}
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == "hutbotdev"
+
+
+@pytest.mark.asyncio
+async def test_fetch_bot_handle_returns_empty_without_a_bot_user_or_on_error():
+    import hutbot
+    from slack_sdk.errors import SlackApiError
+    app = AsyncMock()
+
+    assert await hutbot.slackcache.fetch_bot_handle(app, "") == ""
+    app.client.users_info.assert_not_awaited()
+
+    app.client.users_info.side_effect = SlackApiError("nope", {"error": "user_not_found"})
+    assert await hutbot.slackcache.fetch_bot_handle(app, "UBOT") == ""
diff --git a/tests/test_opsgenie.py b/tests/test_opsgenie.py
new file mode 100644
index 0000000..514e41e
--- /dev/null
+++ b/tests/test_opsgenie.py
@@ -0,0 +1,847 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_opsgenie_schedule():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set opsgenie-schedule Team Primary", channel, user, thread_ts)
+        assert channel.configs["default"]["opsgenie_schedule_name"] == "Team Primary"
+        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie schedule* set to `Team Primary` in configuration `default`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_opsgenie_priority():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set opsgenie-priority P2", channel, user, thread_ts)
+        assert channel.configs["default"]["opsgenie_priority"] == "P2"
+        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie priority* set to `P2` in configuration `default`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_opsgenie_priority_custom_config_normalizes_case():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "alerts set opsgenie-priority p1", channel, user, thread_ts)
+        assert channel.configs["alerts"]["opsgenie_priority"] == "P1"
+        mock_send_message.assert_called_with(app, channel, user, "*OpsGenie priority* set to `P1` in configuration `alerts`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_opsgenie_priority_rejects_invalid_value():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.persistence.save_configuration') as mock_save, patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "set opsgenie-priority P0", channel, user, thread_ts)
+
+    assert channel.configs["default"]["opsgenie_priority"] == "P4"
+    mock_save.assert_not_called()
+    sent_message = mock_send_message.call_args.args[3]
+    assert "Invalid *OpsGenie priority*" in sent_message
+    assert "`P1`, `P2`, `P3`, `P4`, `P5`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_list_opsgenie_schedules():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    response = AsyncMock()
+    response.status = 200
+    response.json = AsyncMock(return_value={
+        "data": [
+            {"name": "Zulu"},
+            {"name": "alpha"},
+        ]
+    })
+    response_context = AsyncMock()
+    response_context.__aenter__.return_value = response
+    response_context.__aexit__.return_value = None
+
+    session = MagicMock()
+    session.get.return_value = response_context
+    session_context = AsyncMock()
+    session_context.__aenter__.return_value = session
+    session_context.__aexit__.return_value = None
+
+    with patch('hutbot.commands.info.get_env_var', return_value="token"), \
+         patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=session_context), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "list opsgenie-schedules", channel, user, thread_ts)
+
+        mock_send_message.assert_called_with(
+            app,
+            channel,
+            user,
+            "*OpsGenie schedules*:\n`alpha`\n`Zulu`",
+            thread_ts
+        )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_list_opsgenie_schedules_without_token():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.commands.info.get_env_var', return_value=""), patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "list opsgenie-schedules", channel, user, thread_ts)
+
+        mock_send_message.assert_called_with(
+            app,
+            channel,
+            user,
+            "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.",
+            thread_ts
+        )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_uses_configured_schedule():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
+    user = User("U12345", "test", "Test User", "Testers")
+    on_call_user = User("U999", "oncall", "On Call User", "Ops")
+    thread_ts = "1234567890.123456"
+    start = "2026-04-26T08:00:00Z"
+    end = "2026-04-27T08:00:00Z"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=(start, end))) as mock_period, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_resolve.assert_awaited_once_with(app, "token", "Team Primary")
+    mock_period.assert_awaited_once_with("token", "Team Primary", "oncall@example.com")
+    mock_send_message.assert_called_with(
+        app,
+        channel,
+        user,
+        "*Schedule*: `Team Primary`\n"
+        "*On-call*: <@U999>\n"
+        f"*Start*: `{hutbot.datetimefmt.format_opsgenie_datetime(start)}`\n"
+        f"*End*: `{hutbot.datetimefmt.format_opsgenie_datetime(end)}`",
+        thread_ts
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_uses_explicit_schedule():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Configured Schedule"
+    user = User("U12345", "test", "Test User", "Testers")
+    on_call_user = User("U999", "oncall", "On Call User", "Ops")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-27T08:00:00Z"))) as mock_period, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call Team Secondary", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_resolve.assert_awaited_once_with(app, "token", "Team Secondary")
+    mock_period.assert_awaited_once_with("token", "Team Secondary", "oncall@example.com")
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Schedule*: `Team Secondary`" in sent_message
+    assert "*On-call*: <@U999>" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_uses_selected_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={
+        "default": DEFAULT_CONFIG.copy(),
+        "alerts": DEFAULT_CONFIG.copy(),
+    })
+    channel.configs["default"]["opsgenie_schedule_name"] = "Default Schedule"
+    channel.configs["alerts"]["opsgenie_schedule_name"] = "Alerts Schedule"
+    user = User("U12345", "test", "Test User", "Testers")
+    on_call_user = User("U999", "oncall", "On Call User", "Ops")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-27T08:00:00Z"))) as mock_period, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "alerts on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_resolve.assert_awaited_once_with(app, "token", "Alerts Schedule")
+    mock_period.assert_awaited_once_with("token", "Alerts Schedule", "oncall@example.com")
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Schedule*: `Alerts Schedule`" in sent_message
+    assert "*On-call*: <@U999>" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_falls_back_to_email_when_unmapped():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+    start = "2026-04-26T08:00:00Z"
+    end = "2026-04-27T08:00:00Z"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", None))), \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=(start, end))), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*On-call*: oncall@example.com" in sent_message
+    assert f"*Start*: `{hutbot.datetimefmt.format_opsgenie_datetime(start)}`" in sent_message
+    assert f"*End*: `{hutbot.datetimefmt.format_opsgenie_datetime(end)}`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_uses_upcoming_period_when_no_current_on_call():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Cloud Hosting_schedule"
+    user = User("U12345", "test", "Test User", "Testers")
+    upcoming_user = User("U999", "next", "Next User", "Ops")
+    thread_ts = "1234567890.123456"
+    start = "2026-04-28T08:00:00Z"
+    end = "2026-04-29T08:00:00Z"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("", None))) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_upcoming_on_call_period', new=AsyncMock(return_value=("next@example.com", start, end))) as mock_upcoming, \
+         patch('hutbot.opsgenie.resolve_slack_user_for_opsgenie_recipient', new=AsyncMock(return_value=upcoming_user)) as mock_slack_user, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_resolve.assert_awaited_once_with(app, "token", "Cloud Hosting_schedule")
+    mock_upcoming.assert_awaited_once_with("token", "Cloud Hosting_schedule")
+    mock_slack_user.assert_awaited_once_with(app, "next@example.com")
+    mock_send_message.assert_called_with(
+        app,
+        channel,
+        user,
+        "*Schedule*: `Cloud Hosting_schedule`\n"
+        "*On-call*: <@U999>\n"
+        f"*Start*: `{hutbot.datetimefmt.format_opsgenie_datetime(start)}`\n"
+        f"*End*: `{hutbot.datetimefmt.format_opsgenie_datetime(end)}`",
+        thread_ts
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_uses_configured_datetime_defaults():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
+    channel.configs["default"]["date_format"] = "%d.%m.%Y"
+    channel.configs["default"]["time_format"] = "%H:%M"
+    channel.configs["default"]["datetime_timezone"] = "Europe/Berlin"
+    user = User("U12345", "test", "Test User", "Testers")
+    on_call_user = User("U999", "oncall", "On Call User", "Ops")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("oncall@example.com", on_call_user))), \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock(return_value=("2026-04-26T08:00:00Z", "2026-04-26T16:00:00Z"))), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "*Start*: `26.04.2026 10:00`" in sent_message
+    assert "*End*: `26.04.2026 18:00`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_errors_when_no_current_or_upcoming_on_call():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Cloud Hosting_schedule"
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock(return_value=("", None))), \
+         patch('hutbot.opsgenie.resolve_opsgenie_upcoming_on_call_period', new=AsyncMock(return_value=("", "", ""))), \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_send_message.assert_called_with(app, channel, user, "Failed to resolve on-call user for OpsGenie schedule `Cloud Hosting_schedule`.", thread_ts)
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_without_schedule():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock()) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock()) as mock_period, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts, opsgenie_token="token")
+
+    mock_resolve.assert_not_awaited()
+    mock_period.assert_not_awaited()
+    mock_send_message.assert_called_with(
+        app,
+        channel,
+        user,
+        "No OpsGenie schedule configured. Use `/hutbot [config] set opsgenie-schedule <name>` or `/hutbot [config] on-call <schedule name>`.",
+        thread_ts
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_on_call_without_token():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["opsgenie_schedule_name"] = "Team Primary"
+    user = User("U12345", "test", "Test User", "Testers")
+    thread_ts = "1234567890.123456"
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call', new=AsyncMock()) as mock_resolve, \
+         patch('hutbot.opsgenie.resolve_opsgenie_on_call_period', new=AsyncMock()) as mock_period, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "on-call", channel, user, thread_ts)
+
+    mock_resolve.assert_not_awaited()
+    mock_period.assert_not_awaited()
+    mock_send_message.assert_called_with(app, channel, user, "OpsGenie is not configured. Missing `OPSGENIE_TOKEN`.", thread_ts)
+
+
+
+def test_find_opsgenie_on_call_period_prefers_matching_current_period():
+    import hutbot
+    data = {
+        "finalTimeline": {
+            "rotations": [{
+                "periods": [
+                    {
+                        "startDate": "2026-04-26T06:00:00Z",
+                        "endDate": "2026-04-26T08:00:00Z",
+                        "recipient": {"name": "previous@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-26T08:00:00Z",
+                        "endDate": "2026-04-27T08:00:00Z",
+                        "recipient": {"name": "oncall@example.com"},
+                    },
+                ],
+            }],
+        },
+    }
+    now = datetime.datetime(2026, 4, 26, 10, 0, tzinfo=datetime.timezone.utc)
+
+    assert hutbot.opsgenie.find_opsgenie_on_call_period(data, "oncall@example.com", now) == (
+        "2026-04-26T08:00:00Z",
+        "2026-04-27T08:00:00Z",
+    )
+
+
+
+def test_format_opsgenie_datetime_uses_local_timezone():
+    import hutbot
+    local_tz = datetime.timezone(datetime.timedelta(hours=2), "CEST")
+
+    assert hutbot.datetimefmt.format_opsgenie_datetime("2026-04-26T08:00:00Z", local_tz) == "Sun, 26 Apr 2026 10:00"
+
+
+
+def test_find_opsgenie_on_call_period_merges_adjacent_matching_periods():
+    import hutbot
+    data = {
+        "finalTimeline": {
+            "rotations": [{
+                "periods": [
+                    {
+                        "startDate": "2026-04-24T16:00:00Z",
+                        "endDate": "2026-04-26T17:19:04.912Z",
+                        "recipient": {"name": "oncall@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-26T17:19:04.912Z",
+                        "endDate": "2026-05-14T06:00:00Z",
+                        "recipient": {"name": "oncall@example.com"},
+                    },
+                    {
+                        "startDate": "2026-05-14T06:00:00Z",
+                        "endDate": "2026-05-31T22:00:00Z",
+                        "recipient": {"name": "next@example.com"},
+                    },
+                ],
+            }],
+        },
+    }
+    now = datetime.datetime(2026, 4, 26, 16, 35, tzinfo=datetime.timezone.utc)
+
+    assert hutbot.opsgenie.find_opsgenie_on_call_period(data, "oncall@example.com", now) == (
+        "2026-04-24T16:00:00Z",
+        "2026-05-14T06:00:00Z",
+    )
+
+
+
+def test_find_opsgenie_upcoming_on_call_period_selects_next_period():
+    import hutbot
+    data = {
+        "finalTimeline": {
+            "rotations": [{
+                "periods": [
+                    {
+                        "startDate": "2026-04-26T08:00:00Z",
+                        "endDate": "2026-04-26T10:00:00Z",
+                        "recipient": {"name": "past@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-27T08:00:00Z",
+                        "endDate": "2026-04-27T12:00:00Z",
+                        "recipient": {"name": "next@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-27T12:00:00Z",
+                        "endDate": "2026-04-27T18:00:00Z",
+                        "recipient": {"name": "next@example.com"},
+                    },
+                ],
+            }],
+        },
+    }
+    now = datetime.datetime(2026, 4, 26, 12, 0, tzinfo=datetime.timezone.utc)
+
+    assert hutbot.opsgenie.find_opsgenie_upcoming_on_call_period(data, now) == (
+        "next@example.com",
+        "2026-04-27T08:00:00Z",
+        "2026-04-27T18:00:00Z",
+    )
+
+
+
+def test_find_opsgenie_upcoming_on_call_period_skips_current_period():
+    import hutbot
+    data = {
+        "finalTimeline": {
+            "rotations": [{
+                "periods": [
+                    {
+                        "startDate": "2026-04-26T08:00:00Z",
+                        "endDate": "2026-04-26T12:00:00Z",
+                        "recipient": {"name": "current@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-26T12:00:00Z",
+                        "endDate": "2026-04-26T18:00:00Z",
+                        "recipient": {"name": "current@example.com"},
+                    },
+                    {
+                        "startDate": "2026-04-26T18:00:00Z",
+                        "endDate": "2026-04-26T20:00:00Z",
+                        "recipient": {"name": "next@example.com"},
+                    },
+                ],
+            }],
+        },
+    }
+    now = datetime.datetime(2026, 4, 26, 10, 0, tzinfo=datetime.timezone.utc)
+
+    assert hutbot.opsgenie.find_opsgenie_upcoming_on_call_period(data, now) == (
+        "next@example.com",
+        "2026-04-26T18:00:00Z",
+        "2026-04-26T20:00:00Z",
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_resolve_opsgenie_on_call_period_requests_past_anchored_wide_timeline():
+    import hutbot
+    response = AsyncMock()
+    response.status = 200
+    response.json = AsyncMock(return_value={"data": {}})
+    response_context = AsyncMock()
+    response_context.__aenter__.return_value = response
+    response_context.__aexit__.return_value = None
+
+    session = MagicMock()
+    session.get.return_value = response_context
+    session_context = AsyncMock()
+    session_context.__aenter__.return_value = session
+    session_context.__aexit__.return_value = None
+
+    with patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=session_context):
+        await hutbot.opsgenie.resolve_opsgenie_on_call_period("token", "Team Primary", "oncall@example.com")
+
+    params = session.get.call_args.kwargs["params"]
+    assert params["identifierType"] == "name"
+    assert params["interval"] == "6"
+    assert params["intervalUnit"] == "months"
+    assert params["date"].endswith("Z")
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_renders_opsgenie_template_variables():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    config["opsgenie_schedule_name"] = "Team Primary"
+    config["reply_message"] = "On call: {{opsgenie_current_user}} / {{opsgenie_current_email}} / {{opsgenie_current_name}}"
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={
+        "opsgenie_current_user": "<@U999>",
+        "opsgenie_current_email": "oncall@example.com",
+        "opsgenie_current_name": "On Call User",
+    })), patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
+
+    app.client.chat_postMessage.assert_awaited_once_with(
+        channel="C12345",
+        text="On call: <@U999> / oncall@example.com / On Call User",
+        mrkdwn=True,
+        thread_ts="1234.1",
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_get_opsgenie_template_variables_renders_current_and_next_periods():
+    import hutbot
+    app = AsyncMock()
+    current_user = User("U999", "oncall", "On Call User", "Ops")
+    next_user = User("U998", "next", "Next User", "Ops")
+    config = {
+        **DEFAULT_CONFIG.copy(),
+        "opsgenie_schedule_name": "Team Primary",
+        "date_format": "%d.%m.%Y",
+        "time_format": "%H:%M",
+        "datetime_timezone": "Europe/Berlin",
+    }
+    context = hutbot.models.OpsGenieContext(
+        "Team Primary",
+        hutbot.models.OpsGeniePeriod("oncall@example.com", current_user, "2026-04-26T08:00:00Z", "2026-04-26T16:00:00Z"),
+        hutbot.models.OpsGeniePeriod("next@example.com", next_user, "2026-04-27T08:00:00Z", "2026-04-27T16:00:00Z"),
+    )
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call_context', new=AsyncMock(return_value=context)):
+        variables = await hutbot.opsgenie.get_opsgenie_template_variables(app, "token", config)
+
+    assert variables["opsgenie_schedule_name"] == "Team Primary"
+    assert variables["opsgenie_current_user"] == "<@U999>"
+    assert variables["opsgenie_current_email"] == "oncall@example.com"
+    assert variables["opsgenie_current_name"] == "On Call User"
+    assert variables["opsgenie_current_start_datetime"] == "26.04.2026 10:00"
+    assert variables["opsgenie_current_end_time"] == "18:00"
+    assert variables["opsgenie_next_user"] == "<@U998>"
+    assert variables["opsgenie_next_email"] == "next@example.com"
+    assert variables["opsgenie_next_start_datetime"] == "27.04.2026 10:00"
+
+
+
+@pytest.mark.asyncio
+async def test_get_opsgenie_template_variables_keeps_current_placeholders_when_only_next_exists():
+    import hutbot
+    app = AsyncMock()
+    next_user = User("U998", "next", "Next User", "Ops")
+    config = {
+        **DEFAULT_CONFIG.copy(),
+        "opsgenie_schedule_name": "Team Primary",
+        "datetime_timezone": "UTC",
+    }
+    context = hutbot.models.OpsGenieContext(
+        "Team Primary",
+        hutbot.models.OpsGeniePeriod("", None, "", ""),
+        hutbot.models.OpsGeniePeriod("next@example.com", next_user, "2026-04-27T08:00:00Z", "2026-04-27T16:00:00Z"),
+    )
+
+    with patch('hutbot.opsgenie.resolve_opsgenie_on_call_context', new=AsyncMock(return_value=context)):
+        variables = await hutbot.opsgenie.get_opsgenie_template_variables(app, "token", config)
+
+    assert variables["opsgenie_current_user"] == "<no-user-set>"
+    assert variables["opsgenie_current_email"] == "<no-email-set>"
+    assert variables["opsgenie_current_start_datetime"] == "<unknown>"
+    assert variables["opsgenie_next_user"] == "<@U998>"
+    assert variables["opsgenie_next_start_datetime"] == "Mon, 27 Apr 2026 08:00"
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_uses_placeholder_for_unmapped_opsgenie_user():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    config["opsgenie_schedule_name"] = "Team Primary"
+    config["reply_message"] = "On call: {{opsgenie_current_user}} / {{opsgenie_current_email}} / {{opsgenie_current_name}}"
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value={
+        "opsgenie_current_user": "<unknown-oncall>",
+        "opsgenie_current_email": "oncall@example.com",
+        "opsgenie_current_name": "oncall@example.com",
+    })), patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
+
+    app.client.chat_postMessage.assert_awaited_once_with(
+        channel="C12345",
+        text="On call: <unknown-oncall> / oncall@example.com / oncall@example.com",
+        mrkdwn=True,
+        thread_ts="1234.1",
+    )
+
+
+
+@pytest.mark.asyncio
+async def test_post_opsgenie_alert_uses_configured_priority():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["opsgenie_priority"] = "P2"
+
+    response = AsyncMock()
+    response.status = 202
+    response_context = AsyncMock()
+    response_context.__aenter__.return_value = response
+    response_context.__aexit__.return_value = None
+
+    session = MagicMock()
+    session.post.return_value = response_context
+    session_context = AsyncMock()
+    session_context.__aenter__.return_value = session
+    session_context.__aexit__.return_value = None
+
+    with patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=session_context):
+        await hutbot.opsgenie.post_opsgenie_alert(app, "token", channel, config, user, "Original text", "1234.1", "https://slack.test/message")
+
+    payload = json.loads(session.post.call_args.kwargs["data"])
+    assert payload["priority"] == "P2"
+
+
+
+@pytest.mark.asyncio
+async def test_post_opsgenie_alert_defaults_to_p4_without_configured_priority():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config.pop("opsgenie_priority")
+
+    response = AsyncMock()
+    response.status = 202
+    response_context = AsyncMock()
+    response_context.__aenter__.return_value = response
+    response_context.__aexit__.return_value = None
+
+    session = MagicMock()
+    session.post.return_value = response_context
+    session_context = AsyncMock()
+    session_context.__aenter__.return_value = session
+    session_context.__aexit__.return_value = None
+
+    with patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=session_context):
+        await hutbot.opsgenie.post_opsgenie_alert(app, "token", channel, config, user, "Original text", "1234.1", "https://slack.test/message")
+
+    payload = json.loads(session.post.call_args.kwargs["data"])
+    assert payload["priority"] == "P4"
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_news_mentions_on_call_and_test_commands():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "news", channel, user)
+
+    sent_message = mock_send_message.call_args.args[3]
+    assert "`/hutbot [config] on-call [schedule name]`" in sent_message
+    assert "`/hutbot [config] test`" in sent_message
+    assert "`@Hutbot [config] test <message>`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_test_uses_opsgenie_placeholders_when_unavailable():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    channel.configs["default"]["reply_message"] = "Anybody?"
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock(return_value=hutbot.opsgenie.get_opsgenie_placeholder_variables())) as mock_get_opsgenie_template_variables, \
+         patch('hutbot.messaging.send_message') as mock_send_message:
+        await process_command(app, "test", channel, user, opsgenie_token="token")
+
+    mock_get_opsgenie_template_variables.assert_awaited_once_with(app, "token", channel.configs["default"])
+    sent_message = mock_send_message.call_args.args[3]
+    assert "`{{opsgenie_current_user}}`: <no-user-set>" in sent_message
+    assert "`{{opsgenie_current_email}}`: <no-email-set>" in sent_message
+    assert "`{{opsgenie_current_name}}`: <no-name-set>" in sent_message
+
+
+
+# ----- OpsGenie gating: inline when no buttons, escalation when buttons present -----
+
+@pytest.mark.asyncio
+async def test_schedule_reply_fires_opsgenie_inline_without_buttons():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "p"}
+    app.client.chat_postMessage.return_value = {"ts": "1"}
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('hutbot.state.opsgenie_configured', True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.opsgenie.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await hutbot.scheduling.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+    alert.assert_awaited_once()
+
+
+
+@pytest.mark.asyncio
+async def test_run_action_fires_opsgenie_for_opsgenie_config():
+    # OpsGenie is now a property of any config that runs (no inline special-casing).
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "1"}
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    cfg["reply_message"] = "ping"
+    channel = _mk_channel({"src": cfg})
+    ctx = {"channel_id": "C12345", "user": User("U5", "carol", "Carol", "T"), "text": "DB down", "ts": "9.9", "permalink": "link"}
+    with patch('hutbot.state.opsgenie_configured', True), \
+         patch('hutbot.opsgenie.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await hutbot.actions.run_action(app, "tok", channel, cfg, "src", context=ctx)
+    alert.assert_awaited_once()
+    args = alert.await_args.args
+    # default alert text = original message; ts/permalink from context
+    assert args[5] == "DB down" and args[6] == "9.9" and args[7] == "link"
+
+
+
+@pytest.mark.asyncio
+async def test_run_action_opsgenie_message_template_overrides():
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "1"}
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    cfg["reply_message"] = "ping"
+    cfg["opsgenie_message"] = "Unanswered in {{channel}}: {{message}}"
+    channel = _mk_channel({"src": cfg})
+    ctx = {"channel_id": "C12345", "user": User("U5", "carol", "Carol", "T"), "text": "DB down", "ts": "9.9", "permalink": "link"}
+    with patch('hutbot.state.opsgenie_configured', True), \
+         patch('hutbot.opsgenie.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await hutbot.actions.run_action(app, "tok", channel, cfg, "src", context=ctx)
+    alert.assert_awaited_once()
+    assert alert.await_args.args[5] == "Unanswered in #general: DB down"
+
+
+
+@pytest.mark.asyncio
+async def test_run_action_no_opsgenie_when_disabled():
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "1"}
+    cfg = DEFAULT_CONFIG.copy()  # opsgenie off
+    channel = _mk_channel({"src": cfg})
+    with patch('hutbot.state.opsgenie_configured', True), \
+         patch('hutbot.opsgenie.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await hutbot.actions.run_action(app, "tok", channel, cfg, "src", context={"channel_id": "C12345"})
+    alert.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_scheduled_opsgenie_alert_uses_posted_ts_for_unique_alias():
+    # F5: a scheduled run has no original ts; the alert must use the posted message
+    # ts so recurrences don't collapse via OpsGenie alias de-duplication.
+    app = AsyncMock()
+    app.client.chat_postMessage.return_value = {"ts": "111.222"}
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["opsgenie"] = True
+    cfg["reply_message"] = "scheduled ping"
+    channel = _mk_channel({"sched": cfg})
+    ctx = {"channel_id": "C12345"}  # scheduled trigger: no original message ts
+    with patch('hutbot.state.opsgenie_configured', True), \
+         patch('hutbot.opsgenie.post_opsgenie_alert', new=AsyncMock()) as alert:
+        await hutbot.actions.run_action(app, "tok", channel, cfg, "sched", context=ctx)
+    alert.assert_awaited_once()
+    assert alert.await_args.args[6] == "111.222"  # ts arg for the alias = posted ts, not empty
+
+
+# ----- Per-instance naming -----
+
+def test_bot_slug():
+    assert bot_slug("Hutbot") == "hutbot"
+    assert bot_slug("Hutbot (DEV)") == "hutbot-dev"
+    assert bot_slug("") == "hutbot"
+    assert bot_slug(None) == "hutbot"
+
+
+@pytest.mark.asyncio
+async def test_post_opsgenie_alert_uses_bot_name_for_tag_and_alias():
+    app = AsyncMock()
+    channel = Channel(id="C1", name="general", configs={})
+    user = User("U1", "test", "Test User", "Testers")
+
+    class _Response:
+        status = 202
+        async def __aenter__(self): return self
+        async def __aexit__(self, *args): return False
+
+    posted = {}
+
+    class _Session:
+        async def __aenter__(self): return self
+        async def __aexit__(self, *args): return False
+        def post(self, url, headers=None, data=None):
+            posted['data'] = json.loads(data)
+            return _Response()
+
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.opsgenie.aiohttp.ClientSession', return_value=_Session()), \
+         patch('hutbot.messaging.clean_slack_text', new=AsyncMock(return_value="hello")):
+        await hutbot.opsgenie.post_opsgenie_alert(app, "token", channel, None, user, "hello", "1.1", "https://slack.test/m")
+
+    assert posted['data']["tags"] == ["Hutbot (DEV)"]
+    assert posted['data']["alias"] == "hutbot-dev: Test User in #general 1.1"
+    assert posted['data']["details"]["bot"] == "hutbot-dev"
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
new file mode 100644
index 0000000..508ee35
--- /dev/null
+++ b/tests/test_persistence.py
@@ -0,0 +1,137 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_migrate_and_apply_defaults():
+    app = AsyncMock()
+    app.client.conversations_info.return_value = {"channel": {"id": "C123", "name": "general"}}
+
+    old_config = {
+        "C123": {
+            "wait_time": 60,
+            "reply_message": "Old message"
+        }
+    }
+
+    migrated_config = await migrate_and_apply_defaults(app, old_config)
+
+    assert "default" in migrated_config["C123"]
+    assert migrated_config["C123"]["default"]["wait_time"] == 60
+    assert migrated_config["C123"]["default"]["reply_message"] == "Old message"
+    assert migrated_config["C123"]["default"]["opsgenie"] is False
+    assert migrated_config["C123"]["default"]["opsgenie_schedule_name"] == ""
+    assert migrated_config["C123"]["default"]["opsgenie_priority"] == "P4"
+    assert migrated_config["C123"]["default"]["pattern"] is None
+
+
+@pytest.mark.asyncio
+async def test_migrate_preserves_configs_named_after_new_default_fields():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "trigger": {"wait_time": 60},
+            "action": {"reply_message": "Action config"},
+            "buttons": {"enabled": False},
+        }
+    }
+
+    migrated_config = await migrate_and_apply_defaults(app, config)
+
+    assert set(migrated_config["C123"]) == {"trigger", "action", "buttons"}
+    assert migrated_config["C123"]["trigger"]["wait_time"] == 60
+    assert migrated_config["C123"]["action"]["reply_message"] == "Action config"
+    assert migrated_config["C123"]["buttons"]["enabled"] is False
+    assert all("trigger" in value for value in migrated_config["C123"].values())
+
+
+
+@pytest.mark.asyncio
+async def test_load_and_flush_replies_cache_roundtrip():
+    import hutbot
+    entry = {
+        'channel_id': 'C123',
+        'ts': '1000.1',
+        'config_name': 'default',
+        'user_id': 'U456',
+        'text': 'hello',
+        'send_at': '2026-04-23T13:00:00',
+    }
+    with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+        json.dump([entry], f)
+        tmp_path = f.name
+
+    try:
+        with patch('hutbot.constants.SCHEDULED_REPLIES_CACHE_FILE', tmp_path):
+            hutbot.state._scheduled_replies_cache.clear()
+            await load_replies_cache()
+            assert ('C123', '1000.1', 'default') in hutbot.state._scheduled_replies_cache
+
+            hutbot.state._scheduled_replies_cache[('C123', '1000.1', 'default')]['text'] = 'updated'
+            await flush_replies_cache()
+
+            with open(tmp_path) as f:
+                data = json.load(f)
+            assert data[0]['text'] == 'updated'
+    finally:
+        os.unlink(tmp_path)
+        hutbot.state._scheduled_replies_cache.clear()
+
+
+
+@pytest.mark.asyncio
+async def test_load_replies_cache_handles_missing_file():
+    import hutbot
+    with patch('hutbot.constants.SCHEDULED_REPLIES_CACHE_FILE', '/nonexistent/path/to/cache.json'):
+        hutbot.state._scheduled_replies_cache.clear()
+        await load_replies_cache()
+        assert hutbot.state._scheduled_replies_cache == {}
+
+
+@pytest.mark.asyncio
+async def test_migration_drops_the_legacy_forward_channel():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "default": {**DEFAULT_CONFIG.copy(), "forward_channel": "CFWDCHAN"},
+            "clean": DEFAULT_CONFIG.copy(),
+        }
+    }
+
+    with patch('hutbot.persistence.log_warning') as mock_log_warning:
+        migrated = await migrate_and_apply_defaults(app, config)
+
+    assert "forward_channel" not in migrated["C123"]["default"]
+    assert "forward_channel" not in migrated["C123"]["clean"]
+    warning = mock_log_warning.call_args.args[0]
+    assert "Dropping the forward channel CFWDCHAN of config 'default' in channel C123" in warning
+    assert "set action post-channel <#CFWDCHAN>" in warning
+    assert "{{message_link}}" in warning
+    # Only the config that had one is reported.
+    assert mock_log_warning.call_count == 1
+
+
+@pytest.mark.asyncio
+async def test_migration_moves_a_schedule_timezone_into_the_datetime_timezone():
+    app = AsyncMock()
+    config = {
+        "C123": {
+            "own": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Asia/Tokyo"},
+            "both": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Asia/Tokyo", "datetime_timezone": "Europe/Berlin"},
+            "same": {**DEFAULT_CONFIG.copy(), "schedule_timezone": "Europe/Berlin", "datetime_timezone": "Europe/Berlin"},
+        }
+    }
+
+    with patch('hutbot.persistence.log_warning') as mock_log_warning:
+        migrated = await migrate_and_apply_defaults(app, config)
+
+    assert all("schedule_timezone" not in cfg for cfg in migrated["C123"].values())
+    # No date/time timezone of its own: the cron keeps its wall-clock time.
+    assert migrated["C123"]["own"]["datetime_timezone"] == "Asia/Tokyo"
+    # Both set: the date/time one wins and the shift is reported.
+    assert migrated["C123"]["both"]["datetime_timezone"] == "Europe/Berlin"
+    warnings = [call.args[0] for call in mock_log_warning.call_args_list]
+    assert any("moved the schedule timezone Asia/Tokyo" in w for w in warnings)
+    assert any("dropping the schedule timezone Asia/Tokyo; its cron now fires in Europe/Berlin" in w for w in warnings)
+    # Identical values are not worth a warning.
+    assert len(warnings) == 2
diff --git a/tests/test_routing.py b/tests/test_routing.py
new file mode 100644
index 0000000..62c762d
--- /dev/null
+++ b/tests/test_routing.py
@@ -0,0 +1,484 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_pattern():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_pattern(app, channel, "default", '".*alarm.*"', "true", user, "")
+        assert channel.configs["default"]["pattern"] == ".*alarm.*"
+        assert channel.configs["default"]["pattern_case_sensitive"] is True
+        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `.*alarm.*` for configuration `default`. (case-sensitive)", "")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_pattern(app, channel, "default", '"*"', None, user, "")
+        mock_send_message.assert_called_with(app, channel, user, "Invalid pattern: `nothing to repeat at position 0`", "")
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_pattern_empty():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_pattern(app, channel, "default", '""', "true", user, "")
+        assert channel.configs["default"]["pattern"] == ""
+        assert channel.configs["default"]["pattern_case_sensitive"] is True
+        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `` for configuration `default`. (case-sensitive)", "")
+
+
+
+@pytest.mark.asyncio
+async def test_process_command_set_pattern_custom_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_pattern(app, channel, "my-config", '".*alarm.*"', "true", user, "")
+        assert channel.configs["my-config"]["pattern"] == ".*alarm.*"
+        assert channel.configs["my-config"]["pattern_case_sensitive"] is True
+        mock_send_message.assert_called_with(app, channel, user, "Pattern set to `.*alarm.*` for configuration `my-config`. (case-sensitive)", "")
+
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_multi_config_and_pattern():
+    app = AsyncMock()
+    configs = {
+        "config1": {"pattern": ".*alarm.*", "reply_message": "Alarm message"},
+        "config2": {"pattern": ".*report.*", "reply_message": "Report message"},
+        "config3": {"pattern": ".*nothing.*", "reply_message": "Nothing message"}
+    }
+
+    for name, cfg in configs.items():
+        for k, v in DEFAULT_CONFIG.items():
+            if k not in cfg:
+                cfg[k] = v
+
+    channel = Channel(id="C12345", name="general", configs=configs)
+    user = User(id="U12345", name="test", real_name="Test User", team="team1")
+
+    with patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+
+        hutbot.state.scheduled_messages.clear()
+        await handle_channel_message(app, "token", channel, user, "This is an alarm and a report", "1234.1")
+
+        assert mock_schedule_reply.call_count == 2
+
+        calls = [
+            call(app, "token", channel, configs["config1"], "config1", user, "This is an alarm and a report", "1234.1"),
+            call(app, "token", channel, configs["config2"], "config2", user, "This is an alarm and a report", "1234.1")
+        ]
+        mock_schedule_reply.assert_has_calls(calls, any_order=True)
+
+
+
+@pytest.mark.asyncio
+async def test_multi_cancel_thread_response():
+    app = AsyncMock()
+    configs = {
+        "config1": {**DEFAULT_CONFIG.copy(), "included_teams": ["A"]},
+        "config2": {**DEFAULT_CONFIG.copy(), "included_teams": ["B"]},
+    }
+    channel = Channel(id="C123", name="test-ch", configs=configs)
+    user1 = User(id="U1", name="user1", real_name="User One", team="A")
+    user2 = User(id="U2", name="user2", real_name="User Two", team="B")
+    ts = "12345.6789"
+
+    task1 = AsyncMock()
+    task1.cancel = MagicMock()
+    task2 = AsyncMock()
+    task2.cancel = MagicMock()
+
+    hutbot.state.scheduled_messages.clear()
+    hutbot.state.scheduled_messages[(channel.id, ts, "config1")] = ScheduledReply(task=task1, user_id=user1.id)
+    hutbot.state.scheduled_messages[(channel.id, ts, "config2")] = ScheduledReply(task=task2, user_id=user1.id)
+
+    with patch('hutbot.slackcache.get_user_by_id', return_value=user1):
+        await handle_thread_response(app, channel, user2, ts)
+
+    task1.cancel.assert_called_once()
+    task2.cancel.assert_not_called()
+    assert list(hutbot.state.scheduled_messages.keys()) == [(channel.id, ts, "config2")]
+
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_ignores_bot_for_configs_without_include_bots():
+    app = AsyncMock()
+    configs = {
+        "bots": {**DEFAULT_CONFIG.copy(), "include_bots": True},
+        "humans": {**DEFAULT_CONFIG.copy(), "include_bots": False},
+    }
+    channel = Channel(id="C12345", name="general", configs=configs)
+    bot_user = User(id="B12345", name="alert-bot", real_name="Alert Bot", team="Bots")
+
+    with patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        await handle_channel_message(app, "token", channel, bot_user, "Alarm", "1234.1", actor_is_bot=True)
+
+    mock_schedule_reply.assert_called_once_with(app, "token", channel, configs["bots"], "bots", bot_user, "Alarm", "1234.1")
+
+
+
+@pytest.mark.asyncio
+async def test_route_message_schedules_bot_attachment_text_when_bots_included():
+    app = AsyncMock()
+    configs = {
+        "alerts": {
+            **DEFAULT_CONFIG.copy(),
+            "include_bots": True,
+            "pattern": "FailedTemporalExecutions",
+        },
+    }
+    channel = Channel(id="C12345", name="general", configs=configs)
+    bot_user = User(id="B12345", name="alertmanager", real_name="Alertmanager", team="Bots")
+    event = {
+        "type": "message",
+        "subtype": "bot_message",
+        "text": "",
+        "attachments": [{
+            "fallback": "[FIRING:1] FailedTemporalExecutions noisy fallback",
+            "text": "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating.",
+            "title": "[FIRING:1] FailedTemporalExecutions",
+        }],
+        "ts": "1234.1",
+        "bot_id": bot_user.id,
+        "channel": channel.id,
+        "event_ts": "1234.1",
+        "channel_type": "channel",
+    }
+
+    extracted_text = (
+        "[FIRING:1] FailedTemporalExecutions\n"
+        "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
+    )
+
+    with patch('hutbot.slackcache.get_channel_by_id', return_value=channel), \
+         patch('hutbot.slackcache.get_user_by_id', return_value=bot_user), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        hutbot.state._scheduled_replies_cache.clear()
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_called_once_with(app, "token", channel, configs["alerts"], "alerts", bot_user, extracted_text, "1234.1")
+    assert hutbot.state._scheduled_replies_cache[(channel.id, "1234.1", "alerts")]["text"] == extracted_text
+
+
+
+@pytest.mark.asyncio
+async def test_thread_response_by_bot_cancels_only_configs_without_include_bots():
+    app = AsyncMock()
+    configs = {
+        "bots": {**DEFAULT_CONFIG.copy(), "include_bots": True},
+        "humans": {**DEFAULT_CONFIG.copy(), "include_bots": False},
+    }
+    channel = Channel(id="C123", name="test-ch", configs=configs)
+    bot_user = User(id="B1", name="alert-bot", real_name="Alert Bot", team="Bots")
+    message_user = User(id="U1", name="user1", real_name="User One", team="A")
+    ts = "12345.6789"
+
+    task1 = AsyncMock()
+    task1.cancel = MagicMock()
+    task2 = AsyncMock()
+    task2.cancel = MagicMock()
+
+    hutbot.state.scheduled_messages.clear()
+    hutbot.state.scheduled_messages[(channel.id, ts, "bots")] = ScheduledReply(task=task1, user_id=message_user.id)
+    hutbot.state.scheduled_messages[(channel.id, ts, "humans")] = ScheduledReply(task=task2, user_id=message_user.id)
+
+    with patch('hutbot.slackcache.get_user_by_id', return_value=message_user):
+        await handle_thread_response(app, channel, bot_user, ts, actor_is_bot=True)
+
+    task1.cancel.assert_not_called()
+    task2.cancel.assert_called_once()
+    assert list(hutbot.state.scheduled_messages.keys()) == [(channel.id, ts, "bots")]
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_skips_disabled_config():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={
+        "active": {**DEFAULT_CONFIG.copy(), "enabled": True, "wait_time": 0},
+        "silent": {**DEFAULT_CONFIG.copy(), "enabled": False, "wait_time": 0},
+    })
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.scheduling.schedule_reply') as mock_schedule, patch('hutbot.persistence.flush_replies_cache'):
+        await handle_channel_message(app, "", channel, user, "hello", "1234.1")
+
+    called_config_names = [call[0][4] for call in mock_schedule.call_args_list]
+    assert "active" in called_config_names
+    assert "silent" not in called_config_names
+
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_enabled_by_default():
+    app = AsyncMock()
+    config = DEFAULT_CONFIG.copy()
+    config.pop("enabled", None)
+    channel = Channel(id="C12345", name="general", configs={"default": {**config, "wait_time": 0}})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.scheduling.schedule_reply') as mock_schedule, patch('hutbot.persistence.flush_replies_cache'):
+        await handle_channel_message(app, "", channel, user, "hello", "1234.1")
+
+    assert mock_schedule.called
+
+
+
+# ----- Trigger gating -----
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_skips_non_message_trigger():
+    app = AsyncMock()
+    msg_cfg = DEFAULT_CONFIG.copy()
+    sched_cfg = DEFAULT_CONFIG.copy()
+    sched_cfg["trigger"] = "schedule"
+    channel = _mk_channel({"msg": msg_cfg, "sched": sched_cfg})
+    user = User("U1", "test", "Test User", "Testers")
+    with patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache'), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule:
+        hutbot.state.scheduled_messages.clear()
+        await handle_channel_message(app, "token", channel, user, "hello", "1.1")
+        assert mock_schedule.call_count == 1  # only the message-trigger config
+
+
+
+# ----- Slash command registration -----
+
+def test_normalize_slash_command():
+    assert normalize_slash_command("") == "/hutbot"
+    assert normalize_slash_command("   ") == "/hutbot"
+    assert normalize_slash_command(None) == "/hutbot"
+    assert normalize_slash_command("/hutbot_dev") == "/hutbot_dev"
+    assert normalize_slash_command("hutbot_dev") == "/hutbot_dev"
+    assert normalize_slash_command(" hutbot_dev ") == "/hutbot_dev"
+
+
+def test_register_app_handlers_uses_configured_slash_command():
+    app = MagicMock()
+    with patch('hutbot.state.slash_command', '/hutbot_dev'):
+        register_app_handlers(app)
+    assert app.command.call_args.args[0] == "/hutbot_dev"
+
+
+# ----- Channel membership (bot added / removed) -----
+
+def _membership_configs():
+    return {
+        "default": {**DEFAULT_CONFIG.copy(), "enabled": True},
+        "nightly": {**DEFAULT_CONFIG.copy(), "enabled": True, "trigger": "schedule"},
+        "off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+    }
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_removed_disables_configs_and_cancels_replies():
+    app = AsyncMock()
+    channel_id = "C12345"
+    hutbot.state.channel_config[channel_id] = _membership_configs()
+    hutbot.state.channel_config["C99999"] = {"default": {**DEFAULT_CONFIG.copy(), "enabled": True}}
+
+    task = AsyncMock()
+    task.cancel = MagicMock()
+    other_task = AsyncMock()
+    other_task.cancel = MagicMock()
+    hutbot.state.scheduled_messages[(channel_id, "1.1", "default")] = ScheduledReply(task=task, user_id="U1")
+    hutbot.state.scheduled_messages[("C99999", "2.2", "default")] = ScheduledReply(task=other_task, user_id="U1")
+    hutbot.state._scheduled_replies_cache[(channel_id, "1.1", "default")] = {'channel_id': channel_id}
+
+    with patch('hutbot.persistence.save_configuration') as mock_save, \
+         patch('hutbot.persistence.flush_replies_cache') as mock_flush, \
+         patch('hutbot.buttons.cancel_channel_pending_buttons') as mock_cancel_buttons:
+        await handle_bot_removed_from_channel(app, channel_id)
+
+    mock_cancel_buttons.assert_awaited_once_with(channel_id)
+
+    configs = hutbot.state.channel_config[channel_id]
+    assert configs["default"]["enabled"] is False
+    assert configs["default"]["disabled_reason"] == DISABLED_REASON_REMOVED
+    assert configs["nightly"]["enabled"] is False
+    assert configs["nightly"]["disabled_reason"] == DISABLED_REASON_REMOVED
+    # A config a user had disabled keeps its (empty) reason.
+    assert configs["off-by-hand"]["disabled_reason"] == ""
+    # Other channels are untouched.
+    assert hutbot.state.channel_config["C99999"]["default"]["enabled"] is True
+
+    task.cancel.assert_called_once()
+    other_task.cancel.assert_not_called()
+    assert list(hutbot.state.scheduled_messages.keys()) == [("C99999", "2.2", "default")]
+    assert hutbot.state._scheduled_replies_cache == {}
+    mock_save.assert_called_once()
+    mock_flush.assert_called_once()
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_removed_without_configs_saves_nothing():
+    app = AsyncMock()
+    with patch('hutbot.persistence.save_configuration') as mock_save, \
+         patch('hutbot.persistence.flush_replies_cache') as mock_flush:
+        await handle_bot_removed_from_channel(app, "C-unknown")
+    assert "C-unknown" not in hutbot.state.channel_config
+    mock_save.assert_not_called()
+    mock_flush.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_added_reports_configs_disabled_by_removal():
+    app = AsyncMock()
+    channel_id = "C12345"
+    hutbot.state.channel_config[channel_id] = {
+        "default": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "nightly": {**DEFAULT_CONFIG.copy(), "enabled": False, "disabled_reason": DISABLED_REASON_REMOVED},
+        "off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False},
+        "running": {**DEFAULT_CONFIG.copy(), "enabled": True},
+    }
+
+    with patch('hutbot.messaging._post_message') as mock_post:
+        await handle_bot_added_to_channel(app, channel_id)
+
+    mock_post.assert_called_once()
+    text = mock_post.call_args.args[2]
+    assert "`default`, `nightly`" in text
+    assert "off-by-hand" not in text
+    assert f"{hutbot.state.slash_command} [config] enable" in text
+    # Nothing is re-enabled automatically.
+    assert hutbot.state.channel_config[channel_id]["default"]["enabled"] is False
+
+
+@pytest.mark.asyncio
+async def test_handle_bot_added_stays_silent_without_auto_disabled_configs():
+    app = AsyncMock()
+    hutbot.state.channel_config["C12345"] = {"off-by-hand": {**DEFAULT_CONFIG.copy(), "enabled": False}}
+    with patch('hutbot.messaging._post_message') as mock_post:
+        await handle_bot_added_to_channel(app, "C12345")
+    mock_post.assert_not_called()
+
+
+def test_is_bot_membership_event():
+    hutbot.state.bot_user_id = "UBOT"
+    assert is_bot_membership_event({"user": "UBOT", "channel": "C1"}) is True
+    assert is_bot_membership_event({"user": "U1", "channel": "C1"}) is False
+    hutbot.state.bot_user_id = None
+    assert is_bot_membership_event({"user": "UBOT"}) is False
+
+
+@pytest.mark.asyncio
+async def test_membership_handlers_only_react_to_the_bot():
+    app = MagicMock()
+    handlers = {}
+
+    def event_decorator(name):
+        def register(fn):
+            handlers[name] = fn
+            return fn
+        return register
+
+    app.event = MagicMock(side_effect=event_decorator)
+    register_app_handlers(app)
+    assert "member_left_channel" in handlers and "member_joined_channel" in handlers
+
+    hutbot.state.bot_user_id = "UBOT"
+    with patch('hutbot.routing.handle_bot_removed_from_channel') as mock_removed, \
+         patch('hutbot.routing.handle_bot_added_to_channel') as mock_added:
+        await handlers["member_left_channel"]({"event": {"user": "U1", "channel": "C1"}}, None)
+        await handlers["member_joined_channel"]({"event": {"user": "U1", "channel": "C1"}}, None)
+        mock_removed.assert_not_called()
+        mock_added.assert_not_called()
+
+        await handlers["member_left_channel"]({"event": {"user": "UBOT", "channel": "C1"}}, None)
+        await handlers["member_joined_channel"]({"event": {"user": "UBOT", "channel": "C2"}}, None)
+        mock_removed.assert_called_once_with(app, "C1")
+        mock_added.assert_called_once_with(app, "C2")
+
+
+@pytest.mark.asyncio
+async def test_route_message_treats_an_app_bot_user_as_a_bot():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="davetest", configs={"default": DEFAULT_CONFIG.copy()})
+    # An app posting through its bot user sends `user` *and* `bot_id`, and users.info
+    # reports is_bot — none of which used to count as "a bot wrote this".
+    bot_user = User(id="U0A9NGY2U5B", name="mping", real_name="mPing", team=TEAM_UNKNOWN, is_bot=True)
+    event = {
+        "type": "message", "text": "mr-merged m3-helmfile", "ts": "1786709950.634419",
+        "user": bot_user.id, "bot_id": "B0A9NGY2U5B", "app_id": "A0A9",
+        "channel": channel.id, "channel_type": "channel",
+    }
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        hutbot.state._scheduled_replies_cache.clear()
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_not_called()
+
+    # With include_bots the same message is handled.
+    channel.configs["default"]["include_bots"] = True
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_called_once()
+    for scheduled in list(hutbot.state.scheduled_messages.values()):
+        scheduled.task.cancel()
+
+
+@pytest.mark.asyncio
+async def test_route_message_treats_a_bot_user_without_bot_id_as_a_bot():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="davetest", configs={"default": DEFAULT_CONFIG.copy()})
+    bot_user = User(id="UBOTUSER", name="somebot", real_name="Some Bot", team=TEAM_UNKNOWN, is_bot=True)
+    event = {"type": "message", "text": "beep", "ts": "1234.1", "user": bot_user.id,
+             "channel": channel.id, "channel_type": "channel"}
+
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=bot_user)), \
+         patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply') as mock_schedule_reply:
+        hutbot.state.scheduled_messages.clear()
+        await route_message(app, "token", event)
+
+    mock_schedule_reply.assert_not_called()
+
+
+def test_build_user_marks_bots_and_skips_employee_mapping():
+    import hutbot
+    employees = {"d.grieser": {"fullname": "David Grieser", "group": "Platform"}}
+
+    with patch('hutbot.slackcache.log_warning') as mock_log_warning:
+        _, bot = hutbot.slackcache.build_user(
+            {"id": "U0A9NGY2U5B", "name": "mping", "is_bot": True, "real_name": "mPing"}, employees, {})
+        _, slackbot = hutbot.slackcache.build_user({"id": "USLACKBOT", "name": "slackbot"}, employees, {})
+        _, human = hutbot.slackcache.build_user(
+            {"id": "U1", "name": "nobody", "real_name": "No Body"}, employees, {})
+
+    assert bot.is_bot is True and bot.team == TEAM_UNKNOWN
+    assert slackbot.is_bot is True
+    assert human.is_bot is False
+    # Only the human is worth an employee-mapping warning.
+    assert mock_log_warning.call_count == 1
+    assert "@nobody" in mock_log_warning.call_args.args[0]
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
new file mode 100644
index 0000000..74d600d
--- /dev/null
+++ b/tests/test_scheduling.py
@@ -0,0 +1,360 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_cleans_up_scheduled_message_after_send():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    ts = "1234.1"
+    key = (channel.id, ts, "alerts")
+
+    hutbot.state.scheduled_messages.clear()
+    hutbot.state.scheduled_messages[key] = ScheduledReply(task=AsyncMock(), user_id=user.id)
+
+    with patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", ts)
+
+    app.client.chat_postMessage.assert_awaited_once()
+    assert key not in hutbot.state.scheduled_messages
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_keeps_plain_message_unchanged():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    config["reply_message"] = "Anybody?"
+
+    with patch('hutbot.opsgenie.get_opsgenie_template_variables', new=AsyncMock()) as mock_get_opsgenie_template_variables, \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "default", user, "Original text", "1234.1")
+
+    mock_get_opsgenie_template_variables.assert_not_awaited()
+    app.client.chat_postMessage.assert_awaited_once_with(channel="C12345", text="Anybody?", mrkdwn=True, thread_ts="1234.1")
+
+
+
+@pytest.mark.asyncio
+async def test_restore_scheduled_replies_skips_unknown_channel():
+    import hutbot
+    hutbot.state._scheduled_replies_cache.clear()
+    hutbot.state._scheduled_replies_cache[('C_GONE', '1000.1', 'default')] = {
+        'channel_id': 'C_GONE',
+        'ts': '1000.1',
+        'config_name': 'default',
+        'user_id': 'U1',
+        'text': 'msg',
+        'send_at': (datetime.datetime.now() + datetime.timedelta(seconds=60)).isoformat(),
+    }
+    app = AsyncMock()
+    hutbot.state.scheduled_messages.clear()
+
+    with patch('hutbot.state.channel_config', {}), patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await restore_scheduled_replies(app, "token")
+
+    assert len(hutbot.state.scheduled_messages) == 0
+    assert hutbot.state._scheduled_replies_cache == {}
+
+
+
+@pytest.mark.asyncio
+async def test_restore_scheduled_replies_schedules_with_remaining_time():
+    import hutbot
+    import asyncio
+    future = datetime.datetime.now() + datetime.timedelta(seconds=300)
+    hutbot.state._scheduled_replies_cache.clear()
+    hutbot.state._scheduled_replies_cache[('C123', '1000.1', 'default')] = {
+        'channel_id': 'C123',
+        'ts': '1000.1',
+        'config_name': 'default',
+        'user_id': 'U456',
+        'text': 'hello',
+        'send_at': future.isoformat(),
+    }
+    config = {**DEFAULT_CONFIG.copy(), 'wait_time': 1800}
+    app = AsyncMock()
+    app.client.conversations_info.return_value = {'channel': {'name': 'general'}}
+    hutbot.state.scheduled_messages.clear()
+
+    captured_override = []
+
+    async def fake_schedule_reply(*args, wait_time_override=None, **kwargs):
+        captured_override.append(wait_time_override)
+
+    with patch('hutbot.state.channel_config', {'C123': {'default': config}}), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User('U456', 'user', 'User', 'Team'))), \
+         patch('hutbot.scheduling.schedule_reply', side_effect=fake_schedule_reply), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await restore_scheduled_replies(app, "token")
+        await asyncio.gather(*[sr.task for sr in hutbot.state.scheduled_messages.values()])
+
+    assert len(captured_override) == 1
+    assert 290 <= captured_override[0] <= 310
+
+
+
+@pytest.mark.asyncio
+async def test_restore_scheduled_replies_sends_immediately_when_overdue():
+    import hutbot
+    import asyncio
+    past = datetime.datetime.now() - datetime.timedelta(seconds=60)
+    hutbot.state._scheduled_replies_cache.clear()
+    hutbot.state._scheduled_replies_cache[('C123', '1000.1', 'default')] = {
+        'channel_id': 'C123',
+        'ts': '1000.1',
+        'config_name': 'default',
+        'user_id': 'U456',
+        'text': 'hello',
+        'send_at': past.isoformat(),
+    }
+    config = {**DEFAULT_CONFIG.copy(), 'wait_time': 1800}
+    app = AsyncMock()
+    app.client.conversations_info.return_value = {'channel': {'name': 'general'}}
+    hutbot.state.scheduled_messages.clear()
+
+    captured_override = []
+
+    async def fake_schedule_reply(*args, wait_time_override=None, **kwargs):
+        captured_override.append(wait_time_override)
+
+    with patch('hutbot.state.channel_config', {'C123': {'default': config}}), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=User('U456', 'user', 'User', 'Team'))), \
+         patch('hutbot.scheduling.schedule_reply', side_effect=fake_schedule_reply), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await restore_scheduled_replies(app, "token")
+        await asyncio.gather(*[sr.task for sr in hutbot.state.scheduled_messages.values()])
+
+    assert captured_override[0] == 0.0
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_removes_entry_from_cache():
+    import hutbot
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": ""}
+    app.client.chat_postMessage.return_value = {"ts": "reply-ts"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    ts = "9999.1"
+    key = (channel.id, ts, "default")
+
+    hutbot.state._scheduled_replies_cache.clear()
+    hutbot.state._scheduled_replies_cache[key] = {'channel_id': channel.id, 'ts': ts, 'config_name': 'default', 'user_id': user.id, 'text': 'x', 'send_at': '2026-01-01T00:00:00'}
+
+    with patch('hutbot.messaging.send_message'), patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "default", user, "x", ts)
+
+    assert key not in hutbot.state._scheduled_replies_cache
+
+
+
+
+# ----- Scheduler -----
+
+@pytest.mark.asyncio
+async def test_scheduler_tick_fires_due_schedule_when_condition_met():
+    app = AsyncMock()
+    sched = DEFAULT_CONFIG.copy()
+    sched["trigger"] = TRIGGER_CRON
+    sched["cron"] = "* * * * *"
+    channel = _mk_channel({"sched": sched})
+    hutbot.state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('hutbot.state.channel_config', {"C12345": {"sched": sched}}, clear=True), \
+         patch('hutbot.scheduling._cron_due', return_value=True), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.actions.evaluate_condition', new=AsyncMock(return_value=True)), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.scheduling.scheduler_tick(app, "token")
+    assert run.await_count == 1
+    assert run.await_args.args[4] == "sched"
+
+
+
+@pytest.mark.asyncio
+async def test_scheduler_tick_skips_when_condition_not_met():
+    app = AsyncMock()
+    sched = DEFAULT_CONFIG.copy()
+    sched["trigger"] = TRIGGER_CRON
+    sched["cron"] = "* * * * *"
+    channel = _mk_channel({"sched": sched})
+    hutbot.state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('hutbot.state.channel_config', {"C12345": {"sched": sched}}, clear=True), \
+         patch('hutbot.scheduling._cron_due', return_value=True), \
+         patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.actions.evaluate_condition', new=AsyncMock(return_value=False)), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.scheduling.scheduler_tick(app, "token")
+    assert run.await_count == 0
+
+
+
+@pytest.mark.asyncio
+async def test_scheduler_tick_ignores_message_trigger():
+    app = AsyncMock()
+    msg = DEFAULT_CONFIG.copy()  # trigger defaults to "message"
+    hutbot.state._scheduler_last_check = datetime.datetime.now(datetime.timezone.utc)
+    with patch.dict('hutbot.state.channel_config', {"C12345": {"default": msg}}, clear=True), \
+         patch('hutbot.scheduling._cron_due', return_value=True), \
+         patch('hutbot.actions.run_action', new=AsyncMock()) as run:
+        await hutbot.scheduling.scheduler_tick(app, "token")
+    assert run.await_count == 0
+
+
+
+# ----- Message-triggered rules honor actions/buttons -----
+
+@pytest.mark.asyncio
+async def test_schedule_reply_routes_to_action_for_non_reply_action():
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["action"] = hutbot.constants.ACTION_DM_USER
+    cfg["action_target"] = "<@U1>"
+    cfg["reply_message"] = "hi"
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('hutbot.slackcache.get_message_permalink', new=AsyncMock(return_value='')), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.actions.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
+        await hutbot.scheduling.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+    assert run.await_count == 1
+    assert run.await_args.args[4] == "src"
+    assert run.await_args.kwargs["context"]["thread_ts"] == "1.1"
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_always_routes_through_run_action():
+    # Even a plain default config (action=reply, no buttons) now uses the unified engine.
+    app = AsyncMock()
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["reply_message"] = "hi"
+    channel = _mk_channel({"src": cfg})
+    user = User("U2", "x", "X", "T")
+    with patch('hutbot.slackcache.get_message_permalink', new=AsyncMock(return_value='')), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.messaging.send_message', new=AsyncMock()) as send, \
+         patch('hutbot.actions.run_action', new=AsyncMock(return_value={"channel": "C", "ts": "1", "text": "hi"})) as run:
+        await hutbot.scheduling.schedule_reply(app, "tok", channel, cfg, "src", user, "orig", "1.1", wait_time_override=0)
+    assert run.await_count == 1
+    assert send.await_count == 0
+
+
+@pytest.mark.asyncio
+async def test_restore_logs_the_original_wait_time_not_the_current_one():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={"default": {**DEFAULT_CONFIG.copy(), "wait_time": 60}})
+    user = User("U1", "d.grieser", "Dave", "T")
+    hutbot.state.channel_config[channel.id] = channel.configs
+    future = datetime.datetime.now() + datetime.timedelta(seconds=223)
+    hutbot.state._scheduled_replies_cache[(channel.id, "M1", "default")] = {
+        'channel_id': channel.id, 'ts': "M1", 'config_name': "default",
+        'user_id': user.id, 'text': "x", 'send_at': future.isoformat(), 'wait_time': 1800,
+    }
+
+    logged = []
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=user)), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.log', side_effect=lambda *a: logged.append(" ".join(str(x) for x in a))):
+        await hutbot.scheduling.restore_scheduled_replies(app, "tok")
+        await asyncio.sleep(0)
+        for entry in list(hutbot.state.scheduled_messages.values()):
+            entry.task.cancel()
+
+    rescheduled = next(line for line in logged if line.startswith("Rescheduling"))
+    assert "223s remaining of the original 30 mins" in rescheduled
+    assert "config now 1 min" in rescheduled
+    assert not any("wait time 1 min," in line for line in logged)
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_restore_omits_the_original_wait_time_for_legacy_cache_entries():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={"default": {**DEFAULT_CONFIG.copy(), "wait_time": 60}})
+    user = User("U1", "d.grieser", "Dave", "T")
+    hutbot.state.channel_config[channel.id] = channel.configs
+    future = datetime.datetime.now() + datetime.timedelta(seconds=90)
+    hutbot.state._scheduled_replies_cache[(channel.id, "M2", "default")] = {
+        'channel_id': channel.id, 'ts': "M2", 'config_name': "default",
+        'user_id': user.id, 'text': "x", 'send_at': future.isoformat(),
+    }
+
+    logged = []
+    with patch('hutbot.slackcache.get_channel_by_id', new=AsyncMock(return_value=channel)), \
+         patch('hutbot.slackcache.get_user_by_id', new=AsyncMock(return_value=user)), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.log', side_effect=lambda *a: logged.append(" ".join(str(x) for x in a))):
+        await hutbot.scheduling.restore_scheduled_replies(app, "tok")
+        await asyncio.sleep(0)
+        for entry in list(hutbot.state.scheduled_messages.values()):
+            entry.task.cancel()
+
+    rescheduled = next(line for line in logged if line.startswith("Rescheduling"))
+    assert "90s remaining," in rescheduled
+    assert "original" not in rescheduled
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_handle_channel_message_caches_the_wait_time_it_scheduled_with():
+    import hutbot
+    app = AsyncMock()
+    config = {**DEFAULT_CONFIG.copy(), "wait_time": 1800}
+    channel = Channel(id="C1", name="davetest", configs={"default": config})
+    user = User("U1", "d.grieser", "Dave", "T")
+
+    with patch('hutbot.datetimefmt.is_work_day', return_value=True), \
+         patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()), \
+         patch('hutbot.scheduling.schedule_reply', new=AsyncMock()):
+        await hutbot.routing.handle_channel_message(app, "tok", channel, user, "hello", "M3")
+
+    entry = hutbot.state._scheduled_replies_cache[(channel.id, "M3", "default")]
+    assert entry['wait_time'] == 1800
+    for scheduled in list(hutbot.state.scheduled_messages.values()):
+        scheduled.task.cancel()
+    await asyncio.sleep(0)
+
+
+@pytest.mark.asyncio
+async def test_cron_fires_in_the_configured_datetime_timezone():
+    import hutbot
+    # 09:00 in Tokyo is 00:00 UTC; a daily 9am cron is due at that instant for a
+    # Tokyo config and not for a Berlin one (where 9am is still 7 hours away).
+    last = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=datetime.timezone.utc)
+    now = datetime.datetime(2026, 4, 27, 0, 5, tzinfo=datetime.timezone.utc)
+
+    tokyo = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Asia/Tokyo"}
+    berlin = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Europe/Berlin"}
+
+    assert hutbot.scheduling._cron_due("0 9 * * *", tokyo, last, now) is True
+    assert hutbot.scheduling._cron_due("0 9 * * *", berlin, last, now) is False
+
+
+@pytest.mark.asyncio
+async def test_cron_falls_back_to_server_local_time():
+    import hutbot
+    last = datetime.datetime(2026, 4, 26, 23, 30, tzinfo=datetime.timezone.utc)
+    now = datetime.datetime(2026, 4, 27, 0, 5, tzinfo=datetime.timezone.utc)
+    config = DEFAULT_CONFIG.copy()
+
+    with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Asia/Tokyo")):
+        assert hutbot.scheduling._cron_due("0 9 * * *", config, last, now) is True
+    with patch('hutbot.datetimefmt.get_local_timezone', return_value=ZoneInfo("Europe/Berlin")):
+        assert hutbot.scheduling._cron_due("0 9 * * *", config, last, now) is False
diff --git a/tests/test_templating.py b/tests/test_templating.py
new file mode 100644
index 0000000..3469de0
--- /dev/null
+++ b/tests/test_templating.py
@@ -0,0 +1,193 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_set_reply_message_template():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(
+            app,
+            channel,
+            "default",
+            "Hi {{user}}, {{user_name}}, {{team}}, {{channel}}, {{channel_name}}, {{message}}, {{message_link}}, {{config}}, {{wait_minutes}}, {{timestamp}}, {{opsgenie_current_user}}, {{opsgenie_current_email}}, {{opsgenie_current_name}}",
+            user,
+            ""
+        )
+
+        assert "{{user}}" in channel.configs["default"]["reply_message"]
+        mock_send_message.assert_called_with(
+            app,
+            channel,
+            user,
+            "*Reply message* set to: Hi {{user}}, {{user_name}}, {{team}}, {{channel}}, {{channel_name}}, {{message}}, {{message_link}}, {{config}}, {{wait_minutes}}, {{timestamp}}, {{opsgenie_current_user}}, {{opsgenie_current_email}}, {{opsgenie_current_name}} in configuration `default`.",
+            ""
+        )
+
+
+
+@pytest.mark.asyncio
+async def test_set_reply_message_template_accepts_datetime_args():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+    message = (
+        "{{opsgenie_current_start_datetime(fmt=\"%d.%m.%Y %H:%M\", tz='Europe/Berlin', lc=de-DE)}} "
+        "{{opsgenie_next_start_datetime(format=02.01.2006 15:04, timezone=UTC, locale=en_us)}}"
+    )
+
+    with patch('hutbot.persistence.save_configuration'), patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", message, user, "")
+
+    assert channel.configs["default"]["reply_message"] == message
+    assert mock_send_message.call_args.args[3] == f"*Reply message* set to: {message} in configuration `default`."
+
+
+
+@pytest.mark.asyncio
+async def test_set_reply_message_rejects_unknown_template_variable():
+    app = AsyncMock()
+    channel = Channel(id="C12345", name="general", configs={"default": DEFAULT_CONFIG.copy()})
+    user = User("U12345", "test", "Test User", "Testers")
+
+    with patch('hutbot.messaging.send_message') as mock_send_message:
+        await set_reply_message(app, channel, "default", "Hi {{unknown}}", user, "")
+
+        assert channel.configs["default"]["reply_message"] == "Anybody?"
+        sent_message = mock_send_message.call_args.args[3]
+        assert "unsupported template variable(s) `{{unknown}}`" in sent_message
+        assert "`{{user}}`" in sent_message
+        assert "`{{message_link}}`" in sent_message
+
+
+
+@pytest.mark.asyncio
+async def test_schedule_reply_renders_template_variables():
+    app = AsyncMock()
+    app.client.chat_getPermalink.return_value = {"permalink": "https://slack.test/message"}
+    app.client.chat_postMessage.return_value = {"ts": "1234.1"}
+    channel = Channel(id="C12345", name="general", configs={})
+    user = User("U12345", "test", "Test User", "Testers")
+    config = DEFAULT_CONFIG.copy()
+    config["wait_time"] = 0
+    config["reply_message"] = (
+        "Hi {{user}} ({{user_name}}) from {{team}} in {{channel}}/{{channel_name}}. "
+        "Config={{config}} Wait={{wait_minutes}} Ts={{timestamp}} "
+        "Message={{message}} Link={{message_link}}"
+    )
+
+    with patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "alerts", user, "Original text", "1234.1")
+
+    app.client.chat_postMessage.assert_awaited_once_with(
+        channel="C12345",
+        text="Hi <@U12345> (Test User) from Testers in #general/general. Config=alerts Wait=0 Ts=1234.1 Message=Original text Link=https://slack.test/message",
+        mrkdwn=True,
+        thread_ts="1234.1",
+    )
+
+
+
+def test_render_reply_message_template_datetime_args_override_config():
+    import hutbot
+    config = {
+        **DEFAULT_CONFIG.copy(),
+        "date_format": "%d.%m.%Y",
+        "time_format": "%H:%M",
+        "datetime_timezone": "Europe/Berlin",
+    }
+    variables = hutbot.opsgenie.get_opsgenie_placeholder_variables(config)
+    raw_key = "__opsgenie_current_start_datetime_raw"
+    variables[raw_key] = "2026-04-26T08:00:00Z"
+
+    rendered = hutbot.templating.render_reply_message_template(
+        "{{opsgenie_current_start_datetime(format='02.01.2006 15:04', timezone='UTC', locale='en_US')}}",
+        variables,
+        config,
+    )
+
+    assert rendered == "26.04.2026 08:00"
+
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_rejects_unknown_template_variable():
+    _seed_user_caches()
+    app = _ui_app()
+    payload = {"reply_message": "Hello {{not_a_var}}"}
+
+    cfg, errors = await validate_config_payload(payload, app)
+
+    assert cfg is None
+    assert "reply_message" in errors
+
+
+def test_render_date_time_and_datetime_from_the_message_timestamp():
+    import hutbot
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "time_format": "%H:%M", "datetime_timezone": "Europe/Berlin"}
+    variables = {"__timestamp_raw": "1786453297.645799"}
+
+    rendered = hutbot.templating.render_reply_message_template(
+        "{{date}} / {{time}} / {{datetime}}", variables, config,
+    )
+
+    assert rendered == "11.08.2026 / 15:01 / 11.08.2026 15:01"
+
+
+def test_date_time_variables_take_format_timezone_and_locale_arguments():
+    import hutbot
+    config = {**DEFAULT_CONFIG.copy(), "datetime_timezone": "Europe/Berlin"}
+    variables = {"__timestamp_raw": "1786453297.645799"}
+
+    rendered = hutbot.templating.render_reply_message_template(
+        "{{datetime(tz='Asia/Tokyo')}} | {{date(lc='de_DE', fmt='%A, %d %B %Y')}} | {{time(fmt='15:04')}}",
+        variables,
+        config,
+    )
+
+    assert rendered == "Tue, 11 Aug 2026 22:01 | Dienstag, 11 August 2026 | 15:01"
+    assert hutbot.templating.validate_template_expressions("{{date(tz='Asia/Tokyo')}}") == ""
+    assert "does not support arguments" in hutbot.templating.validate_template_expressions("{{user(tz='Asia/Tokyo')}}")
+
+
+def test_date_time_variables_are_supported_and_listed():
+    import hutbot
+    assert hutbot.templating.validate_template_expressions("{{date}} {{time}} {{datetime}}") == ""
+    assert {"date", "time", "datetime"} <= hutbot.constants.SUPPORTED_TEMPLATE_VARIABLES
+
+
+@pytest.mark.asyncio
+async def test_build_template_variables_stands_in_now_without_a_message_timestamp():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={})
+    user = User("U1", "dave", "Dave", "T")
+
+    variables = await hutbot.templating.build_reply_template_variables(
+        app, "tok", channel, DEFAULT_CONFIG.copy(), "default", user, "", "", "",
+    )
+
+    assert variables["timestamp"]
+    assert float(variables["timestamp"]) > 0
+    assert variables["date"] and variables["time"] and variables["datetime"]
+    assert variables["__timestamp_raw"] == variables["timestamp"]
+
+
+@pytest.mark.asyncio
+async def test_build_template_variables_keeps_a_real_message_timestamp():
+    import hutbot
+    app = AsyncMock()
+    channel = Channel(id="C1", name="davetest", configs={})
+    user = User("U1", "dave", "Dave", "T")
+    config = {**DEFAULT_CONFIG.copy(), "date_format": "%d.%m.%Y", "datetime_timezone": "Europe/Berlin"}
+
+    variables = await hutbot.templating.build_reply_template_variables(
+        app, "tok", channel, config, "default", user, "hi", "1786453297.645799", "link",
+    )
+
+    assert variables["timestamp"] == "1786453297.645799"
+    assert variables["date"] == "11.08.2026"
+    assert variables["time"] == "15:01"
diff --git a/tests/test_textutil.py b/tests/test_textutil.py
new file mode 100644
index 0000000..127afa1
--- /dev/null
+++ b/tests/test_textutil.py
@@ -0,0 +1,63 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+def test_get_env_var_decoding_and_passthrough(monkeypatch):
+    encoded = base64.b64encode(b"hello world").decode("utf-8")
+    monkeypatch.setenv("MY_ENV_VAR", encoded)
+    assert get_env_var("MY_ENV_VAR") == "hello world"
+    monkeypatch.setenv("MY_ENV_VAR_PLAIN", "plain value")
+    assert get_env_var("MY_ENV_VAR_PLAIN") == "plain value"
+
+
+
+def test_extract_message_text_prefers_top_level_text():
+    event = {
+        "text": "Top-level text",
+        "attachments": [{"text": "Attachment text"}],
+    }
+
+    assert extract_message_text(event) == "Top-level text"
+
+
+
+def test_extract_message_text_extracts_attachment_text():
+    event = {
+        "text": "",
+        "attachments": [{
+            "text": "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
+        }],
+    }
+
+    assert extract_message_text(event) == "Alerts: \n       - 1 removeQueueItemForAbortedOrder temporal executions needs operating."
+
+
+
+def test_extract_message_text_includes_attachment_title_and_text():
+    event = {
+        "text": "",
+        "attachments": [{
+            "title": "[FIRING:1] FailedTemporalExecutions",
+            "text": "Alerts: temporal executions need operating.",
+            "fallback": "Noisy fallback",
+        }],
+    }
+
+    assert extract_message_text(event) == "[FIRING:1] FailedTemporalExecutions\nAlerts: temporal executions need operating."
+
+
+
+def test_extract_message_text_uses_fallback_only_without_cleaner_attachment_text():
+    event = {
+        "text": "",
+        "attachments": [{
+            "fallback": "[FIRING:1] FailedTemporalExecutions noisy fallback",
+        }],
+    }
+
+    assert extract_message_text(event) == "[FIRING:1] FailedTemporalExecutions noisy fallback"
+
+
+
+def test_extract_message_text_handles_missing_attachments():
+    assert extract_message_text({"text": ""}) == ""
diff --git a/tests/test_webui_backend.py b/tests/test_webui_backend.py
new file mode 100644
index 0000000..9dd023a
--- /dev/null
+++ b/tests/test_webui_backend.py
@@ -0,0 +1,294 @@
+from tests._common import *  # noqa: F401,F403
+
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_accepts_good_config():
+    _seed_user_caches()
+    app = _ui_app()
+    payload = {
+        "enabled": True,
+        "trigger": "schedule",
+        "cron": "0 9 * * 1-5",
+        "reply_message": "Hi {{user}} in {{channel}}",
+        "action": "post-channel",
+        "action_target": "C0123ABCD",
+        "included_teams": ["Platform"],
+        "hours": ["09:00", "17:00"],
+        "opsgenie_priority": "p2",
+        "wait_time": 600,
+        "escalation_timeout": 300,
+        "escalation_kind": "config",
+        "escalation_target": "alarm",
+        "buttons": [
+            {"label": "Snooze", "action": "delay", "value": "10"},
+            {"label": "Note", "action": "ack", "value": "Some message"},
+        ],
+    }
+
+    cfg, errors = await validate_config_payload(payload, app)
+
+    assert errors == {}
+    assert cfg is not None
+    assert cfg["trigger"] == "cron"
+    assert cfg["cron"] == "0 9 * * 1-5"
+    # action "post-channel" normalizes to "post_channel" with target preserved.
+    assert cfg["action"] == "post_channel"
+    assert cfg["action_target"] == "C0123ABCD"
+    # template vars stay intact.
+    assert cfg["reply_message"] == "Hi {{user}} in {{channel}}"
+    assert cfg["included_teams"] == ["Platform"]
+    assert cfg["excluded_teams"] == []
+    assert cfg["hours"] == ["09:00", "17:00"]
+    # priority lowercased input is uppercased.
+    assert cfg["opsgenie_priority"] == "P2"
+    # wait_time/escalation_timeout stay in seconds.
+    assert cfg["wait_time"] == 600
+    assert cfg["escalation_timeout"] == 300
+    assert cfg["escalation_kind"] == "config"
+    assert cfg["escalation_target"] == "alarm"
+    assert cfg["buttons"] == [
+        {"label": "Snooze", "action": "delay", "value": "10"},
+        {"label": "Note", "action": "ack", "value": "Some message"},
+    ]
+    # the Slack client is never touched when caches are seeded and there are no @mentions.
+    app.client.users_list.assert_not_called()
+
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_collects_field_errors():
+    _seed_user_caches()
+    app = _ui_app()
+    payload = {
+        "reply_message": "",
+        "trigger": "bogus",
+        "cron": "nope",
+        "wait_time": 0,
+        "datetime_timezone": "Mars/Phobos",
+        "opsgenie_priority": "P9",
+        "included_teams": ["Platform"],
+        "excluded_teams": ["Support"],
+        "pattern": "(",
+        "hours": ["09:00"],
+        "action": "dm_user",
+        "action_target": "",
+        "buttons": [
+            {"label": "", "action": "ack", "value": ""},
+            {"label": "Snooze", "action": "delay", "value": "9999"},
+        ],
+    }
+
+    cfg, errors = await validate_config_payload(payload, app)
+
+    assert cfg is None
+    for field in ("reply_message", "trigger", "cron", "wait_time",
+                  "datetime_timezone", "opsgenie_priority", "included_teams",
+                  "pattern", "hours", "action_target"):
+        assert field in errors, f"expected an error for {field}, got {sorted(errors)}"
+    assert any(key.startswith("buttons") for key in errors), f"expected a buttons.* error, got {sorted(errors)}"
+
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_rejects_unknown_team():
+    _seed_user_caches()
+    app = _ui_app()
+    payload = {"reply_message": "Hello", "included_teams": ["Nope"]}
+
+    cfg, errors = await validate_config_payload(payload, app)
+
+    assert cfg is None
+    assert "included_teams" in errors
+    assert "Nope" in errors["included_teams"]
+
+
+
+@pytest.mark.asyncio
+async def test_is_user_in_channel_true_false():
+    hutbot.state._channel_members_cache = {}
+    app = _ui_app()
+    app.client.conversations_members = AsyncMock(return_value={
+        "members": ["U1", "U2"],
+        "response_metadata": {"next_cursor": ""},
+    })
+
+    assert await is_user_in_channel(app, "C1", "U1") is True
+    assert await is_user_in_channel(app, "C1", "U9") is False
+    # empty user id short-circuits to False.
+    assert await is_user_in_channel(app, "C1", "") is False
+
+
+
+@pytest.mark.asyncio
+async def test_list_user_config_channels_filters_by_membership():
+    hutbot.state._channel_members_cache = {}
+    hutbot.state.channel_config = {"C1": {"default": {}}, "C2": {"default": {}}}
+    app = _ui_app()
+
+    async def members_side_effect(channel=None, cursor=None, limit=None):
+        members = ["U1"] if channel == "C1" else ["U7"]
+        return {"members": members, "response_metadata": {"next_cursor": ""}}
+
+    async def info_side_effect(channel=None):
+        return {"channel": {"name": f"name-{channel}"}}
+
+    app.client.conversations_members = AsyncMock(side_effect=members_side_effect)
+    app.client.conversations_info = AsyncMock(side_effect=info_side_effect)
+
+    user = hutbot.models.User(id="U1", name="someuser", real_name="X", team="Platform")
+    channels = await list_user_config_channels(app, user)
+
+    assert channels == [{"id": "C1", "name": "name-C1"}]
+
+
+
+@pytest.mark.asyncio
+async def test_ui_create_config_rejects_bad_name_and_duplicate(monkeypatch):
+    hutbot.state.channel_config = {}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    # bad name (space not allowed by the name pattern)
+    ok, msg = await hutbot.webui_backend.ui_create_config(app, "C1", "bad name")
+    assert ok is False and msg
+
+    # good name succeeds and seeds from DEFAULT_CONFIG
+    ok, msg = await hutbot.webui_backend.ui_create_config(app, "C1", "my-rule")
+    assert ok is True
+    assert hutbot.state.channel_config["C1"]["my-rule"]["reply_message"] == hutbot.constants.DEFAULT_CONFIG["reply_message"]
+    hutbot.persistence.save_configuration.assert_awaited()
+
+    # duplicate is rejected
+    ok, msg = await hutbot.webui_backend.ui_create_config(app, "C1", "my-rule")
+    assert ok is False and "already exists" in msg
+
+
+@pytest.mark.asyncio
+async def test_ui_apply_config_requires_valid_existing_target(monkeypatch):
+    _seed_user_caches()
+    hutbot.state.channel_config = {"C1": {"existing": DEFAULT_CONFIG.copy()}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+    payload = {"reply_message": "Updated"}
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "bad name", payload)
+    assert ok is False and "name" in errors
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "deleted", payload)
+    assert ok is False and errors == {"name": "That rule no longer exists."}
+    assert "deleted" not in hutbot.state.channel_config["C1"]
+    hutbot.persistence.save_configuration.assert_not_awaited()
+
+
+
+@pytest.mark.asyncio
+async def test_ui_delete_config_refuses_default(monkeypatch):
+    hutbot.state.channel_config = {"C1": {"default": {}, "my-rule": {}}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    ok, msg = await hutbot.webui_backend.ui_delete_config(app, "C1", "default")
+    assert ok is False and msg
+    assert "default" in hutbot.state.channel_config["C1"]
+
+    ok, msg = await hutbot.webui_backend.ui_delete_config(app, "C1", "my-rule")
+    assert ok is True
+    assert "my-rule" not in hutbot.state.channel_config["C1"]
+
+
+@pytest.mark.asyncio
+async def test_get_user_by_email_strict_rejects_username_fallback():
+    # Regression (F4): UI auth must match on exact email only; the lenient resolver
+    # (used for OpsGenie / rule targets) still falls back to the username local-part.
+    app = AsyncMock()
+    alice = User("U1", "alice", "Alice", "Team")
+    hutbot.state.user_email_cache["alice@corp.example"] = alice
+    hutbot.state.user_id_cache["alice"] = alice
+    with patch('hutbot.slackcache.update_user_cache', new=AsyncMock()):
+        assert (await hutbot.slackcache.get_user_by_email_strict(app, "alice@corp.example")).id == "U1"
+        # external address whose local-part matches a Slack username is NOT authorized
+        assert (await hutbot.slackcache.get_user_by_email_strict(app, "alice@external.example")).id is None
+        # contrast: the lenient resolver still falls back to the username (the flagged behavior)
+        assert (await hutbot.slackcache.get_user_by_email(app, "alice@external.example")).id == "U1"
+
+
+# ----- Per-instance naming -----
+
+def test_ui_meta_exposes_bot_name_and_slash_command():
+    with patch('hutbot.state.bot_name', 'Hutbot (DEV)'), \
+         patch('hutbot.state.slash_command', '/hutbot_dev'):
+        meta = ui_meta()
+    assert meta['bot_name'] == 'Hutbot (DEV)'
+    assert meta['slash_command'] == '/hutbot_dev'
+
+
+@pytest.mark.asyncio
+async def test_ui_apply_config_keeps_the_automatic_disable_reason(monkeypatch):
+    _seed_user_caches()
+    hutbot.state.channel_config = {"C1": {"rule": {**DEFAULT_CONFIG.copy(), "enabled": False,
+                                                   "disabled_reason": DISABLED_REASON_REMOVED}}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+    app = _ui_app()
+
+    # Editing a rule that stays disabled keeps the marker...
+    ok, errors = await hutbot.webui_backend.ui_apply_config(app, "C1", "rule", {"reply_message": "Updated", "enabled": False})
+    assert ok is True and errors == {}
+    assert hutbot.state.channel_config["C1"]["rule"]["disabled_reason"] == DISABLED_REASON_REMOVED
+
+    # ...explicitly enabling a draft loaded after removal clears the marker.
+    ok, errors = await hutbot.webui_backend.ui_apply_config(
+        app, "C1", "rule",
+        {"reply_message": "Updated", "enabled": True, "disabled_reason": DISABLED_REASON_REMOVED},
+    )
+    assert ok is True and errors == {}
+    assert hutbot.state.channel_config["C1"]["rule"]["disabled_reason"] == ""
+
+
+@pytest.mark.asyncio
+async def test_ui_apply_config_stale_save_cannot_undo_removal_disable(monkeypatch):
+    _seed_user_caches()
+    stale_payload = {**DEFAULT_CONFIG.copy(), "reply_message": "Updated in stale editor"}
+    hutbot.state.channel_config = {"C1": {"rule": {
+        **DEFAULT_CONFIG.copy(),
+        "enabled": False,
+        "disabled_reason": DISABLED_REASON_REMOVED,
+    }}}
+    monkeypatch.setattr(hutbot.persistence, "save_configuration", AsyncMock())
+
+    ok, errors = await hutbot.webui_backend.ui_apply_config(_ui_app(), "C1", "rule", stale_payload)
+
+    assert ok is True and errors == {}
+    config = hutbot.state.channel_config["C1"]["rule"]
+    assert config["reply_message"] == "Updated in stale editor"
+    assert config["enabled"] is False
+    assert config["disabled_reason"] == DISABLED_REASON_REMOVED
+
+
+@pytest.mark.asyncio
+async def test_validate_config_payload_stores_escalation_as_one_setting():
+    _seed_user_caches()
+    app = _ui_app()
+    base = {
+        "reply_message": "Hi", "wait_time": 600, "trigger": "message", "action": "reply",
+        "buttons": [{"label": "Yes", "action": "ack", "value": ""}],
+    }
+
+    # Half a setting is stored as switched off, not as a timer with nothing to fire.
+    cfg, errors = await validate_config_payload({**base, "escalation_timeout": 300}, app)
+    assert errors == {}
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 0, "escalation_kind": "button", "escalation_target": "Yes"}, app)
+    assert errors == {}
+    assert (cfg["escalation_timeout"], cfg["escalation_kind"], cfg["escalation_target"]) == (0, "none", "")
+
+    # A kind with a timeout but no target is an error, not a silent no-op.
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 300, "escalation_kind": "config", "escalation_target": ""}, app)
+    assert errors == {"escalation_target": "Pick a button label or a rule to escalate to."}
+
+    cfg, errors = await validate_config_payload(
+        {**base, "escalation_timeout": 300, "escalation_kind": "nonsense", "escalation_target": "x"}, app)
+    assert errors == {"escalation_kind": "Escalation must be none, button or config."}
diff --git a/webui.py b/webui.py
new file mode 100644
index 0000000..0d24e9a
--- /dev/null
+++ b/webui.py
@@ -0,0 +1,227 @@
+"""Config web UI for Hutbot.
+
+A small aiohttp application served by the same process as the bot. It lets a
+Keycloak-authenticated user edit the Hutbot rule configuration for the channels
+they belong to. The bot wires up a :class:`WebUIContext` with closures over its
+live state and validation, so this module stays free of bot internals.
+
+The authenticated identity is read from a trusted reverse-proxy header
+(default ``X-Forwarded-Email``); the pod is only reachable through that proxy,
+so the header is trusted. See the README for the proxy/header setup.
+"""
+
+import os
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable
+
+from aiohttp import web
+
+try:  # pragma: no cover - logging is best-effort if employee_list is unavailable
+    from employee_list import log, log_error
+except Exception:  # pragma: no cover
+    def log(*args, **kwargs):
+        pass
+
+    def log_error(*args, **kwargs):
+        pass
+
+STATIC_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "webui_static")
+
+# Everything the UI needs is same-origin and bundled, so we can lock the page
+# down hard. No inline scripts/styles — index.html links app.js and styles.css.
+_CSP = (
+    "default-src 'self'; "
+    "img-src 'self' data:; "
+    "style-src 'self'; "
+    "script-src 'self'; "
+    "font-src 'self'; "
+    "connect-src 'self'; "
+    "base-uri 'none'; "
+    "form-action 'none'; "
+    "frame-ancestors 'none'"
+)
+
+
+@dataclass
+class WebUIContext:
+    """Bridge to the live bot. Async fields return coroutines; sync ones return values."""
+
+    user_header: str
+    resolve_user: Callable[[str], Awaitable[Any]]
+    list_channels: Callable[[Any], Awaitable[list]]
+    is_member: Callable[[str, str], Awaitable[bool]]
+    get_configs: Callable[[str], dict]
+    apply_config: Callable[[str, str, dict], Awaitable[tuple]]
+    create_config: Callable[[str, str], Awaitable[tuple]]
+    delete_config: Callable[[str, str], Awaitable[tuple]]
+    meta: Callable[[], dict]
+    # Name of the instance behind this UI, for user-facing text (e.g. "Hutbot (DEV)").
+    bot_name: str = "Hutbot"
+
+
+def _ctx(request) -> WebUIContext:
+    return request.app["ctx"]
+
+
+def _forbidden(message: str = "You don't have access to this."):
+    return web.json_response({"error": message}, status=403)
+
+
+async def _current_user(request):
+    """Resolve the proxy-supplied identity to a Slack user. Returns (user, email)."""
+    ctx = _ctx(request)
+    email = (request.headers.get(ctx.user_header) or "").strip()
+    if not email:
+        return None, ""
+    # Some proxies send a comma-separated list; the first value is the user's.
+    email = email.split(",")[0].strip()
+    user = await ctx.resolve_user(email)
+    if not user or not getattr(user, "id", None):
+        return None, email
+    return user, email
+
+
+async def _require_member(request):
+    """Authorize a channel route. Returns (user, channel_id) or (None, error_response)."""
+    user, _ = await _current_user(request)
+    if not user:
+        return None, _forbidden(f"Sign in with your Slack-linked account to manage {_ctx(request).bot_name}.")
+    channel_id = request.match_info["cid"]
+    if not await _ctx(request).is_member(channel_id, user.id):
+        return None, _forbidden("You're not a member of that channel.")
+    return user, channel_id
+
+
+async def handle_healthz(request):
+    return web.Response(text="ok")
+
+
+async def handle_index(request):
+    index = os.path.join(STATIC_DIR, "index.html")
+    if not os.path.exists(index):
+        return web.Response(status=404, text="Config UI assets are missing.")
+    return web.FileResponse(index)
+
+
+async def handle_me(request):
+    user, email = await _current_user(request)
+    if not user:
+        return _forbidden(f"Sign in with your Slack-linked account to manage {_ctx(request).bot_name}.")
+    return web.json_response({
+        "email": email,
+        "slack_user_id": user.id,
+        "name": user.name,
+        "real_name": user.real_name,
+        "team": user.team,
+    })
+
+
+async def handle_meta(request):
+    user, _ = await _current_user(request)
+    if not user:
+        return _forbidden()
+    return web.json_response(_ctx(request).meta())
+
+
+async def handle_channels(request):
+    user, _ = await _current_user(request)
+    if not user:
+        return _forbidden()
+    channels = await _ctx(request).list_channels(user)
+    return web.json_response({"channels": channels})
+
+
+async def handle_get_configs(request):
+    user, result = await _require_member(request)
+    if not user:
+        return result
+    return web.json_response({"configs": _ctx(request).get_configs(result)})
+
+
+async def handle_put_config(request):
+    user, result = await _require_member(request)
+    if not user:
+        return result
+    channel_id = result
+    name = request.match_info["name"]
+    try:
+        payload = await request.json()
+    except Exception:
+        return web.json_response({"error": "The request body wasn't valid JSON."}, status=400)
+    ok, errors = await _ctx(request).apply_config(channel_id, name, payload)
+    if not ok:
+        return web.json_response({"errors": errors}, status=422)
+    return web.json_response({"ok": True, "config": _ctx(request).get_configs(channel_id).get(name)})
+
+
+async def handle_post_config(request):
+    user, result = await _require_member(request)
+    if not user:
+        return result
+    channel_id = result
+    try:
+        payload = await request.json()
+    except Exception:
+        return web.json_response({"error": "The request body wasn't valid JSON."}, status=400)
+    name = str((payload or {}).get("name") or "").strip()
+    ok, error = await _ctx(request).create_config(channel_id, name)
+    if not ok:
+        return web.json_response({"error": error}, status=409)
+    return web.json_response(
+        {"ok": True, "name": name, "config": _ctx(request).get_configs(channel_id).get(name)},
+        status=201,
+    )
+
+
+async def handle_delete_config(request):
+    user, result = await _require_member(request)
+    if not user:
+        return result
+    channel_id = result
+    name = request.match_info["name"]
+    ok, error = await _ctx(request).delete_config(channel_id, name)
+    if not ok:
+        status = 403 if "can't" in error.lower() else 404
+        return web.json_response({"error": error}, status=status)
+    return web.json_response({"ok": True})
+
+
+@web.middleware
+async def _security_headers(request, handler):
+    try:
+        response = await handler(request)
+    except web.HTTPException as exc:
+        response = exc
+    response.headers["Content-Security-Policy"] = _CSP
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    response.headers["X-Frame-Options"] = "DENY"
+    response.headers["Referrer-Policy"] = "no-referrer"
+    return response
+
+
+def create_app(ctx: WebUIContext) -> web.Application:
+    app = web.Application(middlewares=[_security_headers])
+    app["ctx"] = ctx
+    app.router.add_get("/healthz", handle_healthz)
+    app.router.add_get("/", handle_index)
+    app.router.add_get("/api/me", handle_me)
+    app.router.add_get("/api/meta", handle_meta)
+    app.router.add_get("/api/channels", handle_channels)
+    app.router.add_get("/api/channels/{cid}/configs", handle_get_configs)
+    app.router.add_post("/api/channels/{cid}/configs", handle_post_config)
+    app.router.add_put("/api/channels/{cid}/configs/{name}", handle_put_config)
+    app.router.add_delete("/api/channels/{cid}/configs/{name}", handle_delete_config)
+    if os.path.isdir(STATIC_DIR):
+        app.router.add_static("/static/", path=STATIC_DIR, name="static", show_index=False)
+    return app
+
+
+async def start_web_ui(ctx: WebUIContext, host: str, port: int) -> web.AppRunner:
+    """Bind the UI to host:port on the running event loop and return its runner."""
+    app = create_app(ctx)
+    runner = web.AppRunner(app)
+    await runner.setup()
+    site = web.TCPSite(runner, host, port)
+    await site.start()
+    log(f"Config UI listening on http://{host}:{port} (user header: {ctx.user_header})")
+    return runner
diff --git a/webui_static/app.js b/webui_static/app.js
new file mode 100644
index 0000000..916da5b
--- /dev/null
+++ b/webui_static/app.js
@@ -0,0 +1,643 @@
+"use strict";
+
+/* Hutbot — Watch Desk. Vanilla JS, no build, no external deps.
+   Talks to the same-origin API; the bot resolves the proxy header to a user. */
+
+// ---------- tiny DOM helper ----------
+function h(tag, attrs, ...kids) {
+  const node = document.createElement(tag);
+  if (attrs) {
+    for (const [k, v] of Object.entries(attrs)) {
+      if (v == null || v === false) continue;
+      if (k === "class") node.className = v;
+      else if (k === "text") node.textContent = v;
+      else if (k.startsWith("on") && typeof v === "function") node.addEventListener(k.slice(2), v);
+      else if (k === "value") node.value = v;
+      else if (k === "checked" || k === "disabled" || k === "selected" || k === "hidden") node[k] = !!v;
+      else node.setAttribute(k, v);
+    }
+  }
+  for (const kid of kids.flat()) {
+    if (kid == null || kid === false) continue;
+    node.append(kid.nodeType ? kid : document.createTextNode(String(kid)));
+  }
+  return node;
+}
+const $ = (sel, root = document) => root.querySelector(sel);
+
+// ---------- branding ----------
+// Instances (prod / dev) run under different names; /api/meta carries the live one.
+let botName = "Hutbot";
+
+function applyBranding(name) {
+  if (!name) return;
+  botName = name;
+  document.title = `${name} · Watch Desk`;
+  const brand = $(".brand-name");
+  if (brand) brand.textContent = name.toLowerCase();
+}
+
+// ---------- state ----------
+const state = {
+  meta: null,
+  channels: [],
+  channelId: null,
+  configs: {},   // name -> server config (source of truth)
+  drafts: {},    // name -> editable copy
+  openName: null,
+  errors: {},    // name -> { field: message }
+};
+
+// ---------- labels ----------
+const TRIGGER_LABEL = { message: "Message (classic)", cron: "Cron schedule", manual: "Manual" };
+const TRIGGER_SHORT = { message: "message", cron: "cron", manual: "manual" };
+const ACTION_LABEL = { reply: "Reply in thread", dm_user: "Direct message", group_dm: "Group DM", post_channel: "Post to channel" };
+const ACTION_SHORT = { reply: "reply", dm_user: "dm", group_dm: "group dm", post_channel: "post" };
+const CONDITION_LABEL = { "": "None (always)", outlook_calendar: "Outlook calendar" };
+const BTN_ACTION_LABEL = { config: "Run rule", ack: "Acknowledge / post text", delay: "Delay timer" };
+const ESCALATION_LABEL = { none: "Never escalate; buttons stay open", button: "Auto-press a button", config: "Run another rule" };
+const TARGET_HINT = { dm_user: "A @user (id, name, or email)", group_dm: "A @usergroup handle", post_channel: "A channel ID like C0123ABCD" };
+// Set by the bot itself when it is removed from a channel (see DISABLED_REASON_REMOVED).
+const DISABLED_REASON_LABEL = { removed_from_channel: "Disabled — the bot was removed from this channel" };
+
+// ---------- api ----------
+async function api(method, path, body) {
+  const opts = { method, headers: {} };
+  if (body !== undefined) { opts.headers["Content-Type"] = "application/json"; opts.body = JSON.stringify(body); }
+  const res = await fetch(path, opts);
+  let data = null;
+  try { data = await res.json(); } catch (_) { /* empty body */ }
+  return { ok: res.ok, status: res.status, data };
+}
+
+// ---------- toasts ----------
+function toast(message, isError = false) {
+  const node = h("div", { class: "toast" + (isError ? " error" : "") }, h("span", { class: "dot" }), h("span", { text: message }));
+  $("#toasts").append(node);
+  setTimeout(() => { node.style.opacity = "0"; node.style.transition = "opacity 300ms ease"; setTimeout(() => node.remove(), 320); }, isError ? 6000 : 3200);
+}
+
+// ---------- boot ----------
+async function boot() {
+  const me = await api("GET", "/api/me");
+  if (me.status === 403) return fatal("You're signed in, but we couldn't match you to a Slack account. Ask an admin to check your Slack ↔ directory mapping.");
+  if (!me.ok) return fatal(`Couldn't reach ${botName}. Try reloading in a moment.`);
+
+  const [meta, channels] = await Promise.all([api("GET", "/api/meta"), api("GET", "/api/channels")]);
+  if (!meta.ok || !channels.ok) return fatal("Couldn't load your configuration. Try reloading in a moment.");
+
+  state.meta = meta.data;
+  applyBranding(state.meta.bot_name);
+  state.channels = channels.data.channels || [];
+  document.getElementById("app").setAttribute("aria-busy", "false");
+  renderIdentity(me.data);
+  renderChannels();
+
+  if (state.channels.length) selectChannel(state.channels[0].id);
+  else renderEmptyStage();
+}
+
+function fatal(message) {
+  $("#stage").replaceChildren(h("div", { class: "stage-empty" }, h("strong", { text: "Can't load the watch desk" }), message));
+  document.getElementById("app").setAttribute("aria-busy", "false");
+}
+
+// ---------- rail ----------
+function initials(name) {
+  const parts = (name || "").trim().split(/\s+/).filter(Boolean);
+  if (!parts.length) return "?";
+  return (parts[0][0] + (parts[1] ? parts[1][0] : "")).toUpperCase();
+}
+
+function renderIdentity(me) {
+  const box = $("#identity");
+  box.hidden = false;
+  $("#identity-avatar").textContent = initials(me.real_name || me.name);
+  $("#identity-name").textContent = me.real_name || me.name || me.email;
+  const team = me.team && me.team !== "<unknown>" ? me.team : "";
+  $("#identity-meta").textContent = [team, me.email].filter(Boolean).join(" · ");
+}
+
+function renderChannels() {
+  const nav = $("#channels");
+  nav.replaceChildren(h("div", { class: "channels-eyebrow", text: "Your channels" }));
+  if (!state.channels.length) { nav.append(h("div", { class: "rail-empty", text: "No channels yet." })); return; }
+  for (const ch of state.channels) {
+    nav.append(h("button", {
+      class: "channel-btn",
+      "aria-current": ch.id === state.channelId ? "true" : "false",
+      onclick: () => selectChannel(ch.id),
+    }, h("span", { class: "channel-hash", text: "#" }), h("span", { text: ch.name })));
+  }
+}
+
+// ---------- stage ----------
+function renderEmptyStage() {
+  $("#stage").replaceChildren(h("div", { class: "stage-empty" },
+    h("strong", { text: "Nothing to watch yet" }),
+    `You can manage a channel here once ${botName} has a configuration in it and you're a member.`));
+}
+
+async function selectChannel(channelId) {
+  state.channelId = channelId;
+  state.openName = null;
+  state.errors = {};
+  renderChannels();
+  const stage = $("#stage");
+  stage.replaceChildren(h("div", { class: "stage-loading", text: "Loading rules…" }));
+
+  const res = await api("GET", `/api/channels/${encodeURIComponent(channelId)}/configs`);
+  if (state.channelId !== channelId) return;
+  if (!res.ok) { stage.replaceChildren(h("div", { class: "stage-empty" }, h("strong", { text: "Couldn't load this channel" }), res.data?.error || "Try another channel.")); return; }
+  state.configs = res.data.configs || {};
+  state.drafts = {};
+  renderRules();
+}
+
+function channelName() {
+  const ch = state.channels.find((c) => c.id === state.channelId);
+  return ch ? ch.name : state.channelId;
+}
+
+function sortedNames() {
+  return Object.keys(state.configs).sort((a, b) => {
+    if (a === state.meta.default_config_name) return -1;
+    if (b === state.meta.default_config_name) return 1;
+    return a.localeCompare(b);
+  });
+}
+
+function renderRules() {
+  const stage = $("#stage");
+  const head = h("div", { class: "stage-head" },
+    h("div", {}, h("div", { class: "stage-eyebrow", text: "Channel" }),
+      h("h1", { class: "stage-title" }, h("span", { class: "hash", text: "#" }), channelName())),
+    h("div", { id: "newrule-slot" }, newRuleButton()));
+  const rules = h("div", { class: "rules", id: "rules" });
+  for (const name of sortedNames()) rules.append(renderCard(name));
+  stage.replaceChildren(head, rules);
+}
+
+function newRuleButton() {
+  return h("button", { class: "btn-newrule", onclick: openNewRuleForm }, h("span", { text: "+" }), "New rule");
+}
+
+function openNewRuleForm() {
+  const slot = $("#newrule-slot");
+  const input = h("input", { type: "text", placeholder: "rule-name", "aria-label": "New rule name" });
+  const submit = async () => {
+    const name = input.value.trim();
+    if (!name) return;
+    const res = await api("POST", `/api/channels/${encodeURIComponent(state.channelId)}/configs`, { name });
+    if (!res.ok) return toast(res.data?.error || "Couldn't create that rule.", true);
+    state.configs[name] = res.data.config;
+    state.openName = name;
+    renderRules();
+    toast(`Created rule “${name}”.`);
+  };
+  const form = h("div", { class: "newrule-form" }, input,
+    h("button", { class: "btn primary", onclick: submit }, "Create"),
+    h("button", { class: "btn ghost", onclick: () => slot.replaceChildren(newRuleButton()) }, "Cancel"));
+  input.addEventListener("keydown", (e) => { if (e.key === "Enter") submit(); if (e.key === "Escape") slot.replaceChildren(newRuleButton()); });
+  slot.replaceChildren(form);
+  input.focus();
+}
+
+// ---------- card (collapsed header + body) ----------
+function renderCard(name) {
+  const cfg = state.configs[name];
+  const isOpen = state.openName === name;
+  const card = h("div", { class: "card" + (isOpen ? " open" : "") + (cfg.enabled ? "" : " dim"), "data-name": name });
+
+  const head = h("button", { class: "card-head", onclick: () => toggleCard(name) },
+    lampFor(cfg), cardIdBlock(name, cfg), pipelineFor(cfg), tagsFor(cfg),
+    h("span", { class: "card-chevron", "aria-hidden": "true", text: "⌄" }));
+
+  const bodyInner = h("div", { class: "card-body-inner" });
+  if (isOpen) bodyInner.append(renderEditor(name));
+  const body = h("div", { class: "card-body-wrap" }, h("div", { class: "card-body" }, bodyInner));
+  card.append(head, body);
+  return card;
+}
+
+function lampFor(cfg) {
+  let cls = "lamp";
+  if (!cfg.enabled) cls += " off";
+  else if (cfg.opsgenie || cfg.escalation_timeout > 0) cls += " escalating";
+  const title = !cfg.enabled
+    ? (DISABLED_REASON_LABEL[cfg.disabled_reason] || "Disabled")
+    : (cfg.opsgenie || cfg.escalation_timeout > 0) ? "Active · can escalate" : "Active";
+  return h("span", { class: cls, title, role: "img", "aria-label": title });
+}
+
+function cardIdBlock(name, cfg) {
+  const nameNode = h("span", { class: "card-name", text: name });
+  if (name === state.meta.default_config_name) nameNode.append(h("span", { class: "default-tag", text: "default" }));
+  return h("span", { class: "card-id" }, nameNode);
+}
+
+function pipelineFor(cfg) {
+  const condText = cfg.trigger === "cron" && cfg.condition === "outlook_calendar"
+    ? (cfg.condition_negate ? "no outlook" : "outlook") : "—";
+  const chip = (kind, text, muted) => h("span", { class: "pipe-chip" + (muted ? " muted" : "") },
+    h("span", { class: "pipe-kind", text: kind }), text);
+  return h("span", { class: "pipeline" },
+    chip("on", TRIGGER_SHORT[cfg.trigger] || cfg.trigger),
+    h("span", { class: "pipe-sep", text: "›" }),
+    chip("when", condText, condText === "—"),
+    h("span", { class: "pipe-sep", text: "›" }),
+    chip("do", ACTION_SHORT[cfg.action] || cfg.action));
+}
+
+function tagsFor(cfg) {
+  const tags = h("span", { class: "card-tags" });
+  if (!cfg.enabled) tags.append(h("span", { class: "tag off", text: "off" }));
+  const btnCount = (cfg.buttons || []).length;
+  if (btnCount) tags.append(h("span", { class: "tag", text: btnCount === 1 ? "1 button" : `${btnCount} buttons` }));
+  if (cfg.opsgenie) tags.append(h("span", { class: "tag opsgenie", text: `OpsGenie ${cfg.opsgenie_priority || ""}`.trim() }));
+  return tags;
+}
+
+function toggleCard(name) {
+  if (state.openName === name) { state.openName = null; renderRules(); return; }
+  state.openName = name;
+  state.errors[name] = {};
+  state.drafts[name] = JSON.parse(JSON.stringify(state.configs[name]));
+  renderRules();
+}
+
+// ---------- editor ----------
+function draft() { return state.drafts[state.openName]; }
+function errs() { return state.errors[state.openName] || {}; }
+function isDirty(name) { return JSON.stringify(state.drafts[name]) !== JSON.stringify(state.configs[name]); }
+
+function set(field, value) { draft()[field] = value; liveRefresh(); }
+
+function liveRefresh() {
+  // Update the collapsed header (lamp/pipeline/tags) and the apply bar without
+  // disturbing focus in text inputs.
+  const name = state.openName;
+  const card = $(`.card[data-name="${cssEscape(name)}"]`);
+  if (!card) return;
+  const cfg = state.drafts[name];
+  card.classList.toggle("dim", !cfg.enabled);
+  // Replace only the header's children — the .card-head button keeps its
+  // original click handler from renderCard, so we must not re-bind here.
+  $(".card-head", card).replaceChildren(
+    lampFor(cfg), cardIdBlock(name, cfg), pipelineFor(cfg), tagsFor(cfg),
+    h("span", { class: "card-chevron", "aria-hidden": "true", text: "⌄" }));
+  refreshApplyBar();
+}
+
+function structuralRefresh() {
+  const card = $(`.card[data-name="${cssEscape(state.openName)}"]`);
+  if (card) $(".card-body-inner", card).replaceChildren(renderEditor(state.openName));
+  liveRefresh();
+}
+
+function cssEscape(s) { return (window.CSS && CSS.escape) ? CSS.escape(s) : s.replace(/["\\]/g, "\\$&"); }
+
+function fieldErr(field) { return errs()[field]; }
+
+// section + field builders -------------------------------------------------
+function section(title, badge, ...rows) {
+  const t = h("div", { class: "section-title" }, title);
+  if (badge) t.append(h("span", { class: "badge", text: badge }));
+  return h("div", { class: "section" }, t, ...rows);
+}
+function grid(...fields) { return h("div", { class: "grid" }, ...fields); }
+
+function field(labelText, control, { hint, error, wide } = {}) {
+  const f = h("div", { class: "field" + (wide ? " wide" : "") }, h("label", { class: "field-label", text: labelText }), control);
+  if (hint) f.append(h("div", { class: "hint", text: hint }));
+  if (error) f.append(h("div", { class: "err", text: error }));
+  if (error && control.classList) control.classList.add("invalid");
+  return f;
+}
+
+function textInput(field_, { mono, placeholder } = {}) {
+  return h("input", { type: "text", class: mono ? "mono" : "", value: draft()[field_] ?? "", placeholder: placeholder || "",
+    oninput: (e) => set(field_, e.target.value) });
+}
+function selectInput(field_, options, labels, onAfter) {
+  const sel = h("select", { onchange: (e) => { draft()[field_] = e.target.value; (onAfter || liveRefresh)(); } });
+  for (const opt of options) sel.append(h("option", { value: opt, selected: draft()[field_] === opt }, labels ? (labels[opt] ?? opt) : opt));
+  return sel;
+}
+function toggleInput(field_, text, { amber, onAfter } = {}) {
+  const input = h("input", { type: "checkbox", checked: !!draft()[field_], onchange: (e) => { draft()[field_] = e.target.checked; (onAfter || liveRefresh)(); } });
+  return h("label", { class: "toggle" + (amber ? " amber" : "") }, input, h("span", { class: "track" }), h("span", { class: "toggle-text", text }));
+}
+function minutesInput(field_) {
+  const cur = Math.round((draft()[field_] || 0) / 60);
+  return h("input", { type: "number", min: "0", max: "1440", value: cur,
+    oninput: (e) => { const m = parseInt(e.target.value, 10); draft()[field_] = isNaN(m) ? 0 : m * 60; liveRefresh(); } });
+}
+
+function renderEditor(name) {
+  const cfg = draft();
+  const e = errs();
+  const wrap = h("div", {});
+
+  // — Status & trigger —
+  const triggerRows = [grid(
+    field("This rule is", h("div", {}, toggleInput("enabled", cfg.enabled ? "Active" : "Disabled", { onAfter: () => { liveRefresh(); structuralRefreshLabelOnly(); } })),
+      { hint: !cfg.enabled && DISABLED_REASON_LABEL[cfg.disabled_reason] ? "The bot disabled this rule when it was removed from this channel." : "" }),
+    field("Trigger", selectInput("trigger", state.meta.triggers, TRIGGER_LABEL, structuralRefresh), { hint: triggerHint(cfg.trigger) }),
+  )];
+  if (cfg.trigger === "message") {
+    triggerRows.push(grid(field("Reminder delay (minutes)", minutesInput("wait_time"),
+      { hint: "How long to wait for a reply before nudging.", error: fieldErr("wait_time") })));
+  }
+  if (cfg.trigger === "cron") {
+    triggerRows.push(grid(
+      field("Cron schedule", textInput("cron", { mono: true, placeholder: "0 9 * * 1-5" }),
+        { hint: "5-field cron, in the Date & time timezone below.", error: fieldErr("cron") }),
+    ));
+  }
+  wrap.append(section("Status & trigger", null, ...triggerRows));
+
+  // — Condition (schedule only) —
+  if (cfg.trigger === "cron") {
+    const condRows = [grid(field("Condition", selectInput("condition", state.meta.conditions, CONDITION_LABEL, structuralRefresh),
+      { hint: "Gate the schedule on an Outlook calendar entry." }))];
+    if (cfg.condition === "outlook_calendar") {
+      condRows.push(grid(
+        field("Subject matches", textInput("outlook_subject_pattern", { mono: true, placeholder: "regex" }), { error: fieldErr("outlook_subject_pattern") }),
+        field("Body matches", textInput("outlook_body_pattern", { mono: true, placeholder: "regex" }), { error: fieldErr("outlook_body_pattern") }),
+      ));
+      condRows.push(h("div", { class: "toggles-row" }, toggleInput("condition_negate", "Fire when no matching entry exists")));
+    }
+    wrap.append(section("Condition", "cron", ...condRows));
+  }
+
+  // — Action —
+  const actionRows = [grid(field("Action", selectInput("action", state.meta.actions, ACTION_LABEL, structuralRefresh), { hint: ACTION_LABEL[cfg.action] }))];
+  if (cfg.action !== "reply") {
+    actionRows[0].append(field("Target", textInput("action_target", { mono: true }), { hint: TARGET_HINT[cfg.action], error: fieldErr("action_target") }));
+  }
+  wrap.append(section("Action", null, ...actionRows));
+
+  // — Message —
+  wrap.append(section("Message", null, messageField()));
+
+  // — Filters (message trigger) —
+  if (cfg.trigger === "message") wrap.append(filtersSection());
+
+  // — Buttons —
+  wrap.append(buttonsSection());
+
+  // — OpsGenie —
+  wrap.append(opsgenieSection());
+
+  // — Formatting (advanced) —
+  wrap.append(formattingSection());
+
+  // — Apply bar —
+  wrap.append(applyBar(name));
+  return wrap;
+}
+
+// enabled toggle text needs a relabel without a full structural rebuild
+function structuralRefreshLabelOnly() {
+  const card = $(`.card[data-name="${cssEscape(state.openName)}"]`);
+  if (!card) return;
+  const txt = $(".section .toggle .toggle-text", card);
+  if (txt) txt.textContent = draft().enabled ? "Active" : "Disabled";
+}
+
+function triggerHint(t) {
+  if (t === "message") return "Watches channel messages and nudges if unanswered.";
+  if (t === "cron") return "Fires on a cron schedule.";
+  return "Only runs when a button or another rule calls it.";
+}
+
+function messageField() {
+  const e = errs();
+  const ta = h("textarea", { class: "mono", value: draft().reply_message ?? "", oninput: (ev) => set("reply_message", ev.target.value) });
+  if (fieldErr("reply_message")) ta.classList.add("invalid");
+  const wrap = h("div", { class: "field wide" }, h("label", { class: "field-label", text: "Message body" }), ta);
+  if (fieldErr("reply_message")) wrap.append(h("div", { class: "err", text: fieldErr("reply_message") }));
+  else wrap.append(h("div", { class: "hint", text: "Supports {{variables}}. Click a variable to insert it." }));
+
+  const bar = h("div", { class: "varbar" }, h("div", { class: "varbar-label", text: "Insert variable" }));
+  const chips = h("div", { class: "chipset" });
+  for (const v of state.meta.template_variables) {
+    chips.append(h("button", { class: "chip var", type: "button", onclick: () => insertVar(ta, v) }, `{{${v}}}`));
+  }
+  bar.append(chips);
+  wrap.append(bar);
+  return wrap;
+}
+
+function insertVar(ta, v) {
+  const token = `{{${v}}}`;
+  const start = ta.selectionStart ?? ta.value.length;
+  const end = ta.selectionEnd ?? ta.value.length;
+  ta.value = ta.value.slice(0, start) + token + ta.value.slice(end);
+  ta.focus();
+  ta.selectionStart = ta.selectionEnd = start + token.length;
+  set("reply_message", ta.value);
+}
+
+function filtersSection() {
+  const cfg = draft();
+  const rows = [];
+  rows.push(grid(
+    field("Only react to messages matching", textInput("pattern", { mono: true, placeholder: "regex (blank = all)" }), { error: fieldErr("pattern") }),
+    h("div", { class: "field" }, h("label", { class: "field-label", text: "Options" }),
+      h("div", { class: "toggles-row" },
+        toggleInput("pattern_case_sensitive", "Case-sensitive"),
+        toggleInput("include_bots", "Include bot messages"),
+        toggleInput("only_work_days", "Weekdays only"))),
+  ));
+
+  // work hours
+  const hours = Array.isArray(cfg.hours) && cfg.hours.length === 2 ? cfg.hours : ["", ""];
+  const startI = h("input", { type: "time", value: hours[0], onchange: (e) => setHours(e.target.value, null) });
+  const endI = h("input", { type: "time", value: hours[1], onchange: (e) => setHours(null, e.target.value) });
+  const hoursField = h("div", { class: "field" }, h("label", { class: "field-label", text: "Active hours (blank = all day)" }),
+    h("div", { class: "hours-row" }, startI, h("span", { class: "hint", text: "to" }), endI));
+  if (fieldErr("hours")) hoursField.append(h("div", { class: "err", text: fieldErr("hours") }));
+
+  // team filter
+  rows.push(grid(hoursField, teamFilterField()));
+  return section("Filters", "message", ...rows);
+}
+
+function setHours(start, end) {
+  const cfg = draft();
+  const cur = Array.isArray(cfg.hours) && cfg.hours.length === 2 ? cfg.hours.slice() : ["", ""];
+  if (start !== null) cur[0] = start;
+  if (end !== null) cur[1] = end;
+  cfg.hours = (cur[0] && cur[1]) ? cur : (!cur[0] && !cur[1] ? [] : cur);
+  liveRefresh();
+}
+
+function teamFilterField() {
+  const cfg = draft();
+  const mode = cfg.included_teams.length ? "only" : cfg.excluded_teams.length ? "except" : "all";
+  const seg = h("div", { class: "segmented", role: "group", "aria-label": "Team filter" });
+  const modes = [["all", "All teams"], ["only", "Only these"], ["except", "Except these"]];
+  for (const [m, label] of modes) {
+    seg.append(h("button", { type: "button", "aria-pressed": mode === m ? "true" : "false", onclick: () => setTeamMode(m) }, label));
+  }
+  const f = h("div", { class: "field" }, h("label", { class: "field-label", text: "Team filter" }), seg);
+  if (mode !== "all") {
+    const active = mode === "only" ? cfg.included_teams : cfg.excluded_teams;
+    const chips = h("div", { class: "chipset mt-sm" });
+    if (!state.meta.teams.length) chips.append(h("span", { class: "hint", text: "No teams known yet." }));
+    for (const team of state.meta.teams) {
+      const on = active.includes(team);
+      chips.append(h("button", { type: "button", class: "chip", "aria-pressed": on ? "true" : "false", onclick: () => toggleTeam(mode, team) }, team));
+    }
+    f.append(chips);
+  }
+  if (fieldErr("included_teams")) f.append(h("div", { class: "err", text: fieldErr("included_teams") }));
+  if (fieldErr("excluded_teams")) f.append(h("div", { class: "err", text: fieldErr("excluded_teams") }));
+  return f;
+}
+
+function setTeamMode(mode) {
+  const cfg = draft();
+  if (mode === "all") { cfg.included_teams = []; cfg.excluded_teams = []; }
+  else if (mode === "only") { cfg.included_teams = cfg.included_teams.length ? cfg.included_teams : cfg.excluded_teams; cfg.excluded_teams = []; }
+  else { cfg.excluded_teams = cfg.excluded_teams.length ? cfg.excluded_teams : cfg.included_teams; cfg.included_teams = []; }
+  structuralRefresh();
+}
+function toggleTeam(mode, team) {
+  const key = mode === "only" ? "included_teams" : "excluded_teams";
+  const list = draft()[key];
+  const i = list.indexOf(team);
+  if (i >= 0) list.splice(i, 1); else list.push(team);
+  structuralRefresh();
+}
+
+function buttonsSection() {
+  const cfg = draft();
+  const rows = h("div", { class: "btn-rows" });
+  const buttons = cfg.buttons || [];
+  if (!buttons.length) rows.append(h("div", { class: "btn-empty", text: "No buttons. Add one to make this message interactive." }));
+  buttons.forEach((btn, i) => rows.append(buttonRow(btn, i)));
+
+  const add = h("button", { class: "add-row", type: "button", onclick: () => { cfg.buttons = buttons.concat([{ label: "", action: "ack", value: "" }]); structuralRefresh(); } }, "+ Add button");
+
+  // Escalation is one setting: minutes + what to escalate to. Picking "Never" hides
+  // the rest, so the form cannot produce a timer with nothing to fire.
+  const escalationKinds = ["none", "button", "config"];
+  const meta = grid(
+    field("If nobody presses", selectInput("escalation_kind", escalationKinds, ESCALATION_LABEL, structuralRefresh),
+      { hint: ESCALATION_LABEL[cfg.escalation_kind || "none"], error: fieldErr("escalation_kind") }),
+  );
+  if (cfg.escalation_kind === "button" || cfg.escalation_kind === "config") {
+    meta.append(field("After (minutes)", minutesInput("escalation_timeout"), { error: fieldErr("escalation_timeout") }));
+    meta.append(field(cfg.escalation_kind === "button" ? "Button to press" : "Rule to run",
+      textInput("escalation_target", { mono: cfg.escalation_kind === "config" }),
+      { hint: cfg.escalation_kind === "button" ? "A button label above." : "Another rule's name.", error: fieldErr("escalation_target") }));
+  }
+
+  return section("Buttons", null, rows, add, meta);
+}
+
+function buttonRow(btn, i) {
+  const labelI = h("input", { type: "text", value: btn.label || "", placeholder: "Label", oninput: (e) => { btn.label = e.target.value; liveRefresh(); } });
+  const actionSel = h("select", { onchange: (e) => { btn.action = e.target.value; structuralRefresh(); } });
+  for (const a of state.meta.button_actions) actionSel.append(h("option", { value: a, selected: btn.action === a }, BTN_ACTION_LABEL[a] || a));
+  const onValue = (e) => { btn.value = e.target.value; liveRefresh(); };
+  let valueControl;
+  if (btn.action === "delay") valueControl = h("input", { type: "number", min: "1", max: "1440", value: btn.value || "", placeholder: "Minutes", oninput: onValue });
+  else if (btn.action === "config") valueControl = h("input", { type: "text", class: "mono", value: btn.value || "", placeholder: "Rule name", oninput: onValue });
+  else valueControl = h("input", { type: "text", value: btn.value || "", placeholder: "Optional message to post", oninput: onValue });
+  const remove = h("div", { class: "drop" }, h("button", { class: "icon-btn", type: "button", title: "Remove button", "aria-label": "Remove button", onclick: () => { draft().buttons.splice(i, 1); structuralRefresh(); } }, "×"));
+  const row = h("div", { class: "btn-row" }, labelI, actionSel, valueControl, remove);
+  if (fieldErr(`buttons.${i}`)) { row.classList.add("has-error"); row.append(h("div", { class: "err row-err", text: fieldErr(`buttons.${i}`) })); }
+  return row;
+}
+
+function opsgenieSection() {
+  const cfg = draft();
+  const rows = [h("div", { class: "toggles-row" }, toggleInput("opsgenie", "Page OpsGenie when this rule runs", { amber: true, onAfter: structuralRefresh }))];
+  if (cfg.opsgenie) {
+    if (!state.meta.opsgenie_configured) rows.push(h("div", { class: "hint opsgenie-warn", text: "OpsGenie isn't configured on the server — alerts won't be delivered until it is." }));
+    rows.push(grid(
+      field("Schedule name", textInput("opsgenie_schedule_name"), { error: fieldErr("opsgenie_schedule_name") }),
+      field("Priority", selectInput("opsgenie_priority", state.meta.opsgenie_priorities, null), {}),
+    ));
+    const ta = h("textarea", { class: "mono", value: cfg.opsgenie_message ?? "", placeholder: "Blank = the original message", oninput: (e) => set("opsgenie_message", e.target.value) });
+    if (fieldErr("opsgenie_message")) ta.classList.add("invalid");
+    const msg = h("div", { class: "field wide" }, h("label", { class: "field-label", text: "Alert text" }), ta);
+    if (fieldErr("opsgenie_message")) msg.append(h("div", { class: "err", text: fieldErr("opsgenie_message") }));
+    else msg.append(h("div", { class: "hint", text: "Supports {{variables}}." }));
+    rows.push(msg);
+  }
+  return section("OpsGenie", cfg.opsgenie ? "escalation" : null, ...rows);
+}
+
+function formattingSection() {
+  const cfg = draft();
+  const body = h("div", { class: "pt-sm" }, grid(
+    field("Date format", textInput("date_format", { mono: true, placeholder: "%a, %d %b %Y" })),
+    field("Time format", textInput("time_format", { mono: true, placeholder: "%H:%M" })),
+    field("Timezone", textInput("datetime_timezone", { mono: true, placeholder: "Europe/Berlin" }), { hint: "IANA name; also counts work days/hours. Blank = server local time.", error: fieldErr("datetime_timezone") }),
+    field("Locale", textInput("datetime_locale", { mono: true, placeholder: "de_DE" }), { hint: "Blank = the instance default. Only de has translations.", error: fieldErr("datetime_locale") }),
+  ), h("div", { class: "toggles-row mt-md" }, toggleInput("debug", "Verbose debug logging")));
+  const details = h("details", { class: "section formatting" }, h("summary", { class: "section-title summary-toggle", text: "Date & time formatting" }), body);
+  return details;
+}
+
+function applyBar(name) {
+  const dirty = isDirty(name);
+  const bar = h("div", { class: "applybar", "data-applybar": "1" });
+  if (dirty) { bar.append(h("span", { class: "dirty-dot" }), h("span", { class: "status", text: "Unsaved changes" })); }
+  else bar.append(h("span", { class: "status", text: "All changes applied" }));
+  bar.append(h("span", { class: "spacer" }));
+  if (name !== state.meta.default_config_name) {
+    bar.append(h("button", { class: "btn danger-text", onclick: () => deleteRule(name) }, "Delete rule"));
+  }
+  bar.append(h("button", { class: "btn ghost", disabled: !dirty, onclick: () => revertRule(name) }, "Revert"));
+  bar.append(h("button", { class: "btn primary", disabled: !dirty, onclick: () => applyRule(name) }, "Apply changes"));
+  return bar;
+}
+
+function refreshApplyBar() {
+  const card = $(`.card[data-name="${cssEscape(state.openName)}"]`);
+  if (!card) return;
+  const old = $('[data-applybar]', card);
+  if (old) old.replaceWith(applyBar(state.openName));
+}
+
+function revertRule(name) {
+  state.drafts[name] = JSON.parse(JSON.stringify(state.configs[name]));
+  state.errors[name] = {};
+  structuralRefresh();
+  toast("Reverted to the applied configuration.");
+}
+
+async function applyRule(name) {
+  const res = await api("PUT", `/api/channels/${encodeURIComponent(state.channelId)}/configs/${encodeURIComponent(name)}`, state.drafts[name]);
+  if (res.status === 422) {
+    state.errors[name] = res.data.errors || {};
+    structuralRefresh();
+    toast("Some fields need fixing — see the highlights.", true);
+    return;
+  }
+  if (!res.ok) { toast(res.data?.error || "Couldn't apply changes.", true); return; }
+  state.configs[name] = res.data.config;
+  state.drafts[name] = JSON.parse(JSON.stringify(res.data.config));
+  state.errors[name] = {};
+  structuralRefresh();
+  toast(`Applied “${name}”.`);
+}
+
+async function deleteRule(name) {
+  if (!window.confirm(`Delete rule “${name}”? This can't be undone.`)) return;
+  const res = await api("DELETE", `/api/channels/${encodeURIComponent(state.channelId)}/configs/${encodeURIComponent(name)}`);
+  if (!res.ok) { toast(res.data?.error || "Couldn't delete that rule.", true); return; }
+  delete state.configs[name];
+  delete state.drafts[name];
+  state.openName = null;
+  renderRules();
+  toast(`Deleted “${name}”.`);
+}
+
+boot();
diff --git a/webui_static/index.html b/webui_static/index.html
new file mode 100644
index 0000000..d5baf19
--- /dev/null
+++ b/webui_static/index.html
@@ -0,0 +1,46 @@
+<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Hutbot · Watch Desk</title>
+  <link rel="icon" href="data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 32 32'%3E%3Cpath d='M6 23h20v3H6z' fill='%230e7c7b'/%3E%3Cpath d='M11 23c0-5 1-12 5-12s5 7 5 12' fill='none' stroke='%230e7c7b' stroke-width='2.4'/%3E%3Ccircle cx='16' cy='13' r='1.7' fill='%23c97a14'/%3E%3C/svg%3E">
+  <link rel="stylesheet" href="/static/styles.css">
+</head>
+<body>
+<div class="app" id="app" aria-busy="true">
+  <aside class="rail" id="rail">
+    <div class="brand">
+      <svg class="brand-mark" viewBox="0 0 32 32" aria-hidden="true" focusable="false">
+        <path d="M6 23h20v3H6z"/>
+        <path d="M11 23c0-5 1-12 5-12s5 7 5 12" fill="none" stroke-width="2.4"/>
+        <circle class="brand-eye" cx="16" cy="13" r="1.7"/>
+      </svg>
+      <div class="brand-text">
+        <span class="brand-name">hutbot</span>
+        <span class="brand-sub">watch desk</span>
+      </div>
+    </div>
+
+    <div class="identity" id="identity" hidden>
+      <span class="identity-avatar" id="identity-avatar" aria-hidden="true"></span>
+      <span class="identity-body">
+        <span class="identity-name" id="identity-name"></span>
+        <span class="identity-meta" id="identity-meta"></span>
+      </span>
+      <span class="on-watch" title="On watch">on watch</span>
+    </div>
+
+    <nav class="channels" id="channels" aria-label="Your channels"></nav>
+  </aside>
+
+  <main class="stage" id="stage">
+    <div class="stage-loading" id="stage-loading">Loading your watch desk…</div>
+  </main>
+</div>
+
+<div class="toasts" id="toasts" aria-live="polite" aria-atomic="false"></div>
+
+<script src="/static/app.js" defer></script>
+</body>
+</html>
diff --git a/webui_static/styles.css b/webui_static/styles.css
new file mode 100644
index 0000000..e8392c6
--- /dev/null
+++ b/webui_static/styles.css
@@ -0,0 +1,402 @@
+/* Hutbot — Watch Desk. A calm instrument panel for channel watch-rules.
+   Teal is the single action color; amber is reserved for escalation (OpsGenie,
+   button timeout); the trigger>condition>action pipeline strip is the signature. */
+
+:root {
+  --bg: #eef1f4;
+  --bg-grain: #e7ebef;
+  --surface: #ffffff;
+  --surface-sunk: #f4f6f9;
+  --ink: #12161d;
+  --ink-soft: #424b59;
+  --ink-mute: #6b7686;
+  --hairline: #dce2e9;
+  --hairline-strong: #c7d0da;
+
+  --teal: #0e7c7b;
+  --teal-deep: #0a5f5e;
+  --teal-wash: #e2f0ef;
+  --amber: #c97a14;
+  --amber-wash: #f8ecd8;
+  --green: #16a572;
+  --red: #c0392b;
+  --red-wash: #f8e4e1;
+
+  --mono: ui-monospace, "JetBrains Mono", "Cascadia Code", "SF Mono", Menlo, Consolas, monospace;
+  --sans: -apple-system, BlinkMacSystemFont, "Segoe UI", system-ui, Roboto, Helvetica, Arial, sans-serif;
+
+  --rail-w: 288px;
+  --radius: 13px;
+  --radius-sm: 8px;
+  --shadow: 0 1px 2px rgba(18, 22, 29, 0.05), 0 6px 22px rgba(18, 22, 29, 0.06);
+  --shadow-lift: 0 2px 6px rgba(18, 22, 29, 0.08), 0 16px 40px rgba(18, 22, 29, 0.12);
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: var(--sans);
+  color: var(--ink);
+  background:
+    radial-gradient(120% 80% at 100% 0%, rgba(14, 124, 123, 0.05), transparent 60%),
+    var(--bg);
+  -webkit-font-smoothing: antialiased;
+  text-rendering: optimizeLegibility;
+  line-height: 1.45;
+}
+
+button { font-family: inherit; cursor: pointer; }
+:focus-visible { outline: 2.5px solid var(--teal); outline-offset: 2px; border-radius: 4px; }
+
+/* ---------- App shell ---------- */
+.app {
+  display: grid;
+  grid-template-columns: var(--rail-w) minmax(0, 1fr);
+  min-height: 100vh;
+}
+
+.rail {
+  position: sticky;
+  top: 0;
+  align-self: start;
+  height: 100vh;
+  display: flex;
+  flex-direction: column;
+  gap: 18px;
+  padding: 22px 18px;
+  background: linear-gradient(180deg, #11161e, #161d28);
+  color: #e7ecf2;
+  border-right: 1px solid #0c1117;
+}
+
+.brand { display: flex; align-items: center; gap: 11px; padding: 2px 4px 4px; }
+.brand-mark { width: 34px; height: 34px; flex: none; }
+.brand-mark path[fill="none"] { stroke: #6fe3d6; }
+.brand-mark path:not([fill="none"]) { fill: #e7ecf2; }
+.brand-eye { fill: #c97a14; }
+.brand-text { display: flex; flex-direction: column; line-height: 1.1; }
+.brand-name { font-weight: 700; font-size: 18px; letter-spacing: -0.01em; }
+.brand-sub {
+  font-size: 10.5px; letter-spacing: 0.22em; text-transform: uppercase;
+  color: #7e8a99;
+}
+
+.identity {
+  display: flex; align-items: center; gap: 10px;
+  padding: 11px 12px;
+  background: rgba(255, 255, 255, 0.04);
+  border: 1px solid rgba(255, 255, 255, 0.07);
+  border-radius: var(--radius-sm);
+}
+.identity-avatar {
+  width: 34px; height: 34px; flex: none; border-radius: 9px;
+  display: grid; place-items: center;
+  font-weight: 700; font-size: 13px; color: #06302f;
+  background: linear-gradient(150deg, #6fe3d6, #2bb1a4);
+}
+.identity-body { display: flex; flex-direction: column; min-width: 0; flex: 1; }
+.identity-name { font-weight: 600; font-size: 14px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.identity-meta { font-size: 12px; color: #8b97a6; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+.on-watch {
+  font-size: 9.5px; letter-spacing: 0.12em; text-transform: uppercase;
+  color: #6fe3d6; border: 1px solid rgba(111, 227, 214, 0.35);
+  padding: 3px 6px; border-radius: 999px; white-space: nowrap;
+}
+
+.channels { display: flex; flex-direction: column; gap: 2px; overflow-y: auto; margin: 0 -4px; padding: 0 4px; }
+.channels-eyebrow {
+  font-size: 10.5px; letter-spacing: 0.18em; text-transform: uppercase;
+  color: #7e8a99; padding: 6px 10px 4px;
+}
+.channel-btn {
+  display: flex; align-items: center; gap: 8px;
+  width: 100%; text-align: left;
+  padding: 9px 11px; border: 1px solid transparent; border-radius: var(--radius-sm);
+  background: transparent; color: #cdd5df; font-size: 14px;
+  transition: background 120ms ease, color 120ms ease;
+}
+.channel-btn:hover { background: rgba(255, 255, 255, 0.05); color: #fff; }
+.channel-btn[aria-current="true"] {
+  background: rgba(111, 227, 214, 0.12);
+  border-color: rgba(111, 227, 214, 0.28);
+  color: #fff;
+}
+.channel-hash { color: #6fe3d6; font-weight: 700; }
+.channel-count {
+  margin-left: auto; font-size: 11px; color: #8b97a6;
+  font-variant-numeric: tabular-nums;
+}
+.rail-empty { color: #8b97a6; font-size: 13px; padding: 8px 10px; }
+
+/* ---------- Stage ---------- */
+.stage { padding: 30px clamp(20px, 4vw, 52px) 80px; min-width: 0; }
+.stage-loading, .stage-empty {
+  color: var(--ink-mute); font-size: 15px; padding: 80px 8px; text-align: center;
+}
+.stage-empty strong { color: var(--ink); display: block; font-size: 17px; margin-bottom: 6px; }
+
+.stage-head {
+  display: flex; align-items: flex-end; justify-content: space-between;
+  gap: 16px; margin-bottom: 20px; flex-wrap: wrap;
+}
+.stage-eyebrow {
+  font-size: 11px; letter-spacing: 0.16em; text-transform: uppercase; color: var(--ink-mute);
+}
+.stage-title { font-size: 27px; font-weight: 700; letter-spacing: -0.02em; margin: 2px 0 0; }
+.stage-title .hash { color: var(--teal); }
+.btn-newrule {
+  display: inline-flex; align-items: center; gap: 7px;
+  background: var(--surface); color: var(--teal-deep);
+  border: 1px solid var(--hairline-strong); border-radius: 999px;
+  padding: 9px 15px; font-weight: 600; font-size: 13.5px;
+  box-shadow: var(--shadow); transition: border-color 120ms ease, transform 80ms ease;
+}
+.btn-newrule:hover { border-color: var(--teal); }
+.btn-newrule:active { transform: translateY(1px); }
+.btn-newrule span { font-size: 17px; line-height: 0; margin-top: -2px; }
+
+.newrule-form { display: flex; gap: 8px; align-items: center; }
+.newrule-form input {
+  font-family: var(--mono); font-size: 13px;
+  border: 1px solid var(--hairline-strong); border-radius: 999px;
+  padding: 8px 14px; width: 200px; background: var(--surface);
+}
+
+/* ---------- Rule cards ---------- */
+.rules { display: flex; flex-direction: column; gap: 14px; max-width: 920px; }
+
+.card {
+  background: var(--surface);
+  border: 1px solid var(--hairline);
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+  overflow: hidden;
+  transition: box-shadow 160ms ease, border-color 160ms ease;
+}
+.card.open { box-shadow: var(--shadow-lift); border-color: var(--hairline-strong); }
+.card.dim .card-name { color: var(--ink-mute); }
+
+.card-head {
+  display: flex; align-items: center; gap: 14px;
+  width: 100%; text-align: left; background: transparent; border: 0;
+  padding: 16px 18px;
+}
+.card-head:hover { background: var(--surface-sunk); }
+
+.lamp {
+  width: 11px; height: 11px; border-radius: 50%; flex: none;
+  background: var(--green);
+  box-shadow: 0 0 0 4px rgba(22, 165, 114, 0.14);
+}
+.lamp.off { background: var(--hairline-strong); box-shadow: 0 0 0 4px rgba(199, 208, 218, 0.22); }
+.lamp.escalating {
+  background: var(--amber);
+  box-shadow: 0 0 0 4px rgba(201, 122, 20, 0.16);
+  animation: lamp-pulse 2.2s ease-in-out infinite;
+}
+@keyframes lamp-pulse { 0%, 100% { box-shadow: 0 0 0 4px rgba(201, 122, 20, 0.10); } 50% { box-shadow: 0 0 0 7px rgba(201, 122, 20, 0.20); } }
+
+.card-id { min-width: 0; display: flex; flex-direction: column; gap: 3px; }
+.card-name { font-weight: 650; font-size: 15.5px; letter-spacing: -0.01em; }
+.card-name .default-tag {
+  font-size: 9.5px; letter-spacing: 0.1em; text-transform: uppercase;
+  color: var(--ink-mute); border: 1px solid var(--hairline-strong);
+  padding: 1px 5px; border-radius: 4px; margin-left: 7px; vertical-align: 1px;
+}
+
+/* Signature: trigger > condition > action pipeline */
+.pipeline { display: flex; align-items: center; gap: 6px; flex-wrap: wrap; }
+.pipe-chip {
+  font-size: 11.5px; font-weight: 600; letter-spacing: 0.01em;
+  padding: 3px 9px; border-radius: 6px;
+  background: var(--surface-sunk); border: 1px solid var(--hairline);
+  color: var(--ink-soft); white-space: nowrap;
+}
+.pipe-chip.muted { color: var(--ink-mute); background: transparent; border-style: dashed; }
+.pipe-chip .pipe-kind {
+  font-size: 8.5px; letter-spacing: 0.13em; text-transform: uppercase;
+  color: var(--ink-mute); display: block; margin-bottom: -1px;
+}
+.pipe-sep { color: var(--hairline-strong); font-size: 13px; }
+
+.card-tags { margin-left: auto; display: flex; align-items: center; gap: 7px; flex-wrap: wrap; justify-content: flex-end; }
+.tag {
+  font-size: 11px; font-weight: 600; padding: 3px 8px; border-radius: 999px;
+  background: var(--surface-sunk); color: var(--ink-soft); border: 1px solid var(--hairline);
+}
+.tag.opsgenie { background: var(--amber-wash); color: var(--amber); border-color: transparent; }
+.tag.off { background: transparent; color: var(--ink-mute); }
+.card-chevron { color: var(--ink-mute); transition: transform 200ms ease; flex: none; }
+.card.open .card-chevron { transform: rotate(180deg); }
+
+/* Expanding editor body via grid-rows trick (no max-height guessing) */
+.card-body-wrap { display: grid; grid-template-rows: 0fr; transition: grid-template-rows 220ms ease; }
+.card.open .card-body-wrap { grid-template-rows: 1fr; }
+.card-body { overflow: hidden; }
+.card-body-inner { border-top: 1px solid var(--hairline); padding: 6px 18px 0; }
+
+/* ---------- Editor sections ---------- */
+.section { border-bottom: 1px solid var(--hairline); padding: 16px 0; }
+.section:last-of-type { border-bottom: 0; }
+.section-title {
+  font-size: 11px; letter-spacing: 0.14em; text-transform: uppercase;
+  color: var(--ink-mute); margin: 0 0 13px; display: flex; align-items: center; gap: 8px;
+}
+.section-title .badge {
+  font-size: 9px; color: var(--amber); border: 1px solid var(--amber);
+  border-radius: 4px; padding: 0 4px; letter-spacing: 0.08em;
+}
+
+.grid { display: grid; grid-template-columns: repeat(2, minmax(0, 1fr)); gap: 14px 18px; }
+.field { display: flex; flex-direction: column; gap: 6px; min-width: 0; }
+.field.wide { grid-column: 1 / -1; }
+.field > label, .field-label {
+  font-size: 12.5px; font-weight: 600; color: var(--ink-soft);
+}
+.field .hint { font-size: 11.5px; color: var(--ink-mute); }
+.field .err { font-size: 11.5px; color: var(--red); font-weight: 600; }
+
+input[type="text"], input[type="number"], input[type="time"], select, textarea {
+  font-family: var(--sans); font-size: 13.5px; color: var(--ink);
+  background: var(--surface); border: 1px solid var(--hairline-strong);
+  border-radius: var(--radius-sm); padding: 9px 11px; width: 100%;
+  transition: border-color 120ms ease, box-shadow 120ms ease;
+}
+input:hover, select:hover, textarea:hover { border-color: var(--ink-mute); }
+input:focus, select:focus, textarea:focus {
+  outline: none; border-color: var(--teal); box-shadow: 0 0 0 3px var(--teal-wash);
+}
+input.invalid, textarea.invalid, select.invalid { border-color: var(--red); box-shadow: 0 0 0 3px var(--red-wash); }
+textarea { resize: vertical; min-height: 70px; line-height: 1.5; }
+.mono, textarea.mono, input.mono { font-family: var(--mono); font-size: 12.5px; background: var(--surface-sunk); }
+select { appearance: none; background-image: linear-gradient(45deg, transparent 50%, var(--ink-mute) 50%), linear-gradient(135deg, var(--ink-mute) 50%, transparent 50%); background-position: right 14px center, right 9px center; background-size: 5px 5px, 5px 5px; background-repeat: no-repeat; padding-right: 30px; }
+
+/* Toggle switch */
+.toggle { display: flex; align-items: center; gap: 10px; cursor: pointer; user-select: none; }
+.toggle input { position: absolute; opacity: 0; width: 0; height: 0; }
+.toggle .track {
+  width: 38px; height: 22px; border-radius: 999px; background: var(--hairline-strong);
+  position: relative; flex: none; transition: background 140ms ease;
+}
+.toggle .track::after {
+  content: ""; position: absolute; top: 2px; left: 2px; width: 18px; height: 18px;
+  border-radius: 50%; background: #fff; box-shadow: 0 1px 2px rgba(0,0,0,0.25);
+  transition: transform 140ms ease;
+}
+.toggle input:checked + .track { background: var(--teal); }
+.toggle input:checked + .track::after { transform: translateX(16px); }
+.toggle input:focus-visible + .track { outline: 2.5px solid var(--teal); outline-offset: 2px; }
+.toggle.amber input:checked + .track { background: var(--amber); }
+.toggle .toggle-text { font-size: 13.5px; font-weight: 600; color: var(--ink-soft); }
+
+.toggles-row { display: flex; flex-wrap: wrap; gap: 16px 26px; }
+
+/* Segmented control (team filter mode) */
+.segmented { display: inline-flex; background: var(--surface-sunk); border: 1px solid var(--hairline-strong); border-radius: 999px; padding: 3px; }
+.segmented button {
+  border: 0; background: transparent; color: var(--ink-soft);
+  font-size: 12.5px; font-weight: 600; padding: 6px 13px; border-radius: 999px;
+}
+.segmented button[aria-pressed="true"] { background: var(--surface); color: var(--teal-deep); box-shadow: var(--shadow); }
+
+/* Chips (teams, template vars) */
+.chipset { display: flex; flex-wrap: wrap; gap: 7px; }
+.chip {
+  font-size: 12.5px; padding: 5px 11px; border-radius: 999px;
+  background: var(--surface); border: 1px solid var(--hairline-strong); color: var(--ink-soft);
+  transition: all 110ms ease;
+}
+.chip[aria-pressed="true"] { background: var(--teal); border-color: var(--teal); color: #fff; }
+.chip.var { font-family: var(--mono); font-size: 11.5px; background: var(--surface-sunk); }
+.chip.var:hover { border-color: var(--teal); color: var(--teal-deep); }
+.varbar { margin-top: 8px; }
+.varbar-label { font-size: 11px; color: var(--ink-mute); margin-bottom: 6px; }
+
+/* Buttons editor */
+.btn-rows { display: flex; flex-direction: column; gap: 9px; }
+.btn-row {
+  display: grid; grid-template-columns: minmax(0, 1.1fr) 130px minmax(0, 1.4fr) 34px;
+  gap: 9px; align-items: center;
+}
+.btn-row .drop { display: grid; place-items: center; }
+.icon-btn {
+  width: 32px; height: 32px; border-radius: 8px; border: 1px solid var(--hairline-strong);
+  background: var(--surface); color: var(--ink-mute); font-size: 16px; line-height: 0;
+  display: grid; place-items: center; transition: all 110ms ease;
+}
+.icon-btn:hover { border-color: var(--red); color: var(--red); background: var(--red-wash); }
+.add-row {
+  align-self: flex-start; margin-top: 4px;
+  background: transparent; border: 1px dashed var(--hairline-strong); color: var(--ink-soft);
+  border-radius: var(--radius-sm); padding: 8px 14px; font-size: 13px; font-weight: 600;
+}
+.add-row:hover { border-color: var(--teal); color: var(--teal-deep); }
+.btn-empty { font-size: 13px; color: var(--ink-mute); padding: 2px 0 4px; }
+
+/* Apply bar */
+.applybar {
+  position: sticky; bottom: 0; z-index: 2;
+  display: flex; align-items: center; gap: 12px;
+  margin: 0 -18px; padding: 13px 18px;
+  background: linear-gradient(180deg, rgba(255,255,255,0.4), var(--surface) 40%);
+  border-top: 1px solid var(--hairline);
+  backdrop-filter: blur(4px);
+}
+.applybar .dirty-dot { width: 8px; height: 8px; border-radius: 50%; background: var(--amber); flex: none; }
+.applybar .status { font-size: 12.5px; color: var(--ink-mute); }
+.applybar .spacer { flex: 1; }
+.btn {
+  border-radius: var(--radius-sm); font-weight: 650; font-size: 13.5px;
+  padding: 9px 18px; border: 1px solid transparent; transition: all 110ms ease;
+}
+.btn.primary { background: var(--teal); color: #fff; }
+.btn.primary:hover { background: var(--teal-deep); }
+.btn.primary:disabled { background: var(--hairline-strong); color: #fff; cursor: not-allowed; }
+.btn.ghost { background: transparent; color: var(--ink-soft); border-color: var(--hairline-strong); }
+.btn.ghost:hover { border-color: var(--ink-mute); }
+.btn.ghost:disabled { color: var(--ink-mute); cursor: not-allowed; opacity: 0.55; }
+.btn.danger-text { background: transparent; color: var(--red); border-color: transparent; padding: 9px 10px; }
+.btn.danger-text:hover { background: var(--red-wash); }
+
+/* helper classes (kept here so the CSP can forbid inline style attributes) */
+.hours-row { display: flex; gap: 8px; align-items: center; }
+.mt-sm { margin-top: 10px; }
+.mt-md { margin-top: 12px; }
+.pt-sm { padding-top: 6px; }
+.opsgenie-warn { margin: -4px 0 8px; color: var(--amber); }
+.summary-toggle { cursor: pointer; }
+.formatting summary { list-style: none; }
+.formatting summary::-webkit-details-marker { display: none; }
+.formatting summary::before { content: "▸ "; color: var(--ink-mute); }
+.formatting[open] summary::before { content: "▾ "; }
+.btn-row.has-error { outline: 2px solid var(--red); outline-offset: 3px; border-radius: 8px; }
+.btn-row .row-err { grid-column: 1 / -1; }
+
+/* ---------- Toasts ---------- */
+.toasts { position: fixed; right: 20px; bottom: 20px; display: flex; flex-direction: column; gap: 10px; z-index: 50; }
+.toast {
+  display: flex; align-items: flex-start; gap: 10px;
+  background: var(--ink); color: #f1f4f8;
+  padding: 12px 15px; border-radius: 10px; box-shadow: var(--shadow-lift);
+  font-size: 13.5px; max-width: 360px;
+  animation: toast-in 200ms ease;
+}
+.toast .dot { width: 8px; height: 8px; border-radius: 50%; margin-top: 5px; flex: none; background: var(--green); }
+.toast.error .dot { background: #ff6b5e; }
+.toast.error { background: #2a1614; }
+@keyframes toast-in { from { transform: translateY(10px); opacity: 0; } to { transform: none; opacity: 1; } }
+
+/* ---------- Responsive ---------- */
+@media (max-width: 820px) {
+  .app { grid-template-columns: 1fr; }
+  .rail { position: static; height: auto; flex-direction: column; }
+  .channels { max-height: 220px; }
+  .grid { grid-template-columns: 1fr; }
+  .btn-row { grid-template-columns: 1fr 1fr; grid-auto-rows: auto; }
+  .btn-row .drop { justify-self: end; }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *, *::before, *::after { animation-duration: 0.001ms !important; transition-duration: 0.001ms !important; }
+}