diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
index 20ca13d..921e11e 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:
@@ -36,4 +60,4 @@ jobs:
           push: true
           tags: |
             ghcr.io/mittwald/hutbot:latest
-            ghcr.io/mittwald/hutbot:${{ github.ref_name }}
\ No newline at end of file
+            ghcr.io/mittwald/hutbot:${{ github.ref_name }}
diff --git a/.gitignore b/.gitignore
index 6ea8b91..f38c313 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@ employees.json
 .env
 .codex
 scheduled_replies.json
+button_states.json
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..d83d117 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,168 @@ Opsgenie alert priority defaults to `P4` and can be configured per channel confi
 /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 <message|schedule|manual>`)
+  - `message` — the classic behavior (matches channel messages by pattern/teams/hours).
+  - `schedule` — fires on a cron schedule. Set it with `set cron "<expr>"` (5-field cron, e.g.
+    `0 9 * * 1-5`) and optionally `set schedule-timezone <IANA tz>`.
+  - `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 `schedule` 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 <reply|dm-user|group-dm|post-channel>`) decide what the
+  rule does, using `reply_message` (with the usual `{{variables}}`) as the body.
+  - `reply` — post in the rule's channel.
+  - `dm-user` — DM a single user. Set the recipient with `set target <@user>`.
+  - `group-dm` — open one group DM (mpim) with all members of a Slack user group and post once.
+    Set the group with `set target <@usergroup>` (Slack caps a group DM at 8 members).
+  - `post-channel` — post to another channel. Set it with `set target <#channel>`.
+
+- **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:
+  - `/hutbot [config] add button "<label>" config <config>` — run another config (a `manual` rule).
+  - `/hutbot [config] add button "<label>" ack [text]` — acknowledge/dismiss: stop the escalation and
+    optionally post `text`.
+  - `/hutbot [config] add button "<label>" message <text>` — post a fixed message.
+  - `/hutbot [config] add button "<label>" delay <minutes>` — delay the escalation by N minutes.
+  - `/hutbot [config] clear buttons`
+  - `/hutbot [config] set button-timeout <minutes>` — escalate if no button is pressed in time, then
+    either `set default-button "<label>"` (auto-press that button) or `set button-timeout-target
+    <config>` (run that config). Pending escalations survive restarts.
+  - A bare `add button "<label>" <config>` (no action keyword) is still treated as `config <config>`.
+  - 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.
+
+- **"Need help?" example** — a question that defaults to "Yes" if ignored:
+  ```bash
+  /hutbot helpcheck set message Need help?
+  /hutbot helpcheck add button "Yes" message "Here's the help doc: …"
+  /hutbot helpcheck add button "No" ack
+  /hutbot helpcheck set button-timeout 5
+  /hutbot helpcheck set default-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 button-timeout — 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 button-timeout 5
+  /hutbot incident set button-timeout-target page-oncall   # escalate if ignored
+  # 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).
+
+## 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**
@@ -81,7 +243,14 @@ Opsgenie alert priority defaults to `P4` and can be configured per channel confi
      - `message.im`
      - `message.mpim`
 
-6. **Add Slash Command**
+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.
+
+7. **Add Slash Command**
 
    - Go to **"Slash Commands"**.
    - Click **"Create New Command"**.
@@ -89,7 +258,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,7 +270,7 @@ 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)
@@ -198,3 +367,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:
+
+- `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`.
+
+### 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/bot.py b/bot.py
deleted file mode 100644
index d93b8a4..0000000
--- a/bot.py
+++ /dev/null
@@ -1,2416 +0,0 @@
-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
-
-    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)
-
-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)
-
-    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..df2a8ff 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
+version: 0.1.3
 appVersion: "latest"
\ No newline at end of file
diff --git a/charts/hutbot/templates/deployment.yaml b/charts/hutbot/templates/deployment.yaml
index 60bc75c..26ece39 100644
--- a/charts/hutbot/templates/deployment.yaml
+++ b/charts/hutbot/templates/deployment.yaml
@@ -25,16 +25,53 @@ spec:
           envFrom:
             - secretRef:
                 name: {{ .Release.Name }}-secret
-          {{- if .Values.persistence.enabled }}
+          {{- if .Values.ui.enabled }}
+          ports:
+            - name: http
+              containerPort: {{ .Values.ui.port }}
+          {{- end }}
+          {{- if or .Values.persistence.enabled .Values.ui.enabled }}
           env:
+            {{- 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 }}
+          {{- 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 }}
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..e47f550 100644
--- a/charts/hutbot/values.yaml
+++ b/charts/hutbot/values.yaml
@@ -22,6 +22,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/hutbot/__init__.py b/hutbot/__init__.py
new file mode 100644
index 0000000..59d32fa
--- /dev/null
+++ b/hutbot/__init__.py
@@ -0,0 +1,8 @@
+"""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``).
+"""
+
+__version__ = "1.0.0"
diff --git a/hutbot/__main__.py b/hutbot/__main__.py
new file mode 100644
index 0000000..be3e9cd
--- /dev/null
+++ b/hutbot/__main__.py
@@ -0,0 +1,76 @@
+"""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 state
+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")
+    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)
+        state.bot_user_id = (await app.client.auth_test())["user_id"]
+        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..41a17b4
--- /dev/null
+++ b/hutbot/actions.py
@@ -0,0 +1,177 @@
+"""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,
+    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='hutbot', real_name='Hutbot', 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_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='hutbot', real_name='Hutbot', 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() or (config.get('forward_channel') or '')
+    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)
+
+
+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)
+    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 not posted:
+        return None
+    if 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.get('ts', ''))
+    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..e441061
--- /dev/null
+++ b/hutbot/buttons.py
@@ -0,0 +1,324 @@
+"""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_MESSAGE,
+    BUTTON_ACTION_PREFIX,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ESCALATION_NONE,
+)
+from .models import User
+
+
+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],
+        })
+    return [
+        {"type": "section", "text": {"type": "mrkdwn", "text": text}},
+        {"type": "actions", "block_id": f"{BUTTON_ACTION_PREFIX}:{config_name}", "elements": elements},
+    ]
+
+
+def _escalation_kind(config: dict) -> tuple[str, str]:
+    """Decide what a buttoned message escalates to if no button is pressed in time."""
+    default_button = config.get('default_button') or ''
+    if default_button and _find_button_index(config, default_button) is not None:
+        return ESCALATION_BUTTON, default_button
+    target = config.get('button_timeout_target') or ''
+    if target:
+        return ESCALATION_CONFIG, 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('button_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) -> 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 in (BUTTON_ACTION_MESSAGE, BUTTON_ACTION_ACK):
+        # message posts the configured text; ack just dismisses (optional text).
+        if value:
+            await messaging._post_message(app, posted_channel_id, value, 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)
+        await _strip_buttons(app, posted_channel_id, message_ts, entry)
+    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)
+        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 = state.pending_buttons.get(key)
+        if entry:
+            log(f"No button pressed on message {key[1]} within timeout; escalating.")
+            await _run_escalation(app, opsgenie_token, entry)
+    except asyncio.CancelledError:
+        return
+    except Exception as e:
+        log_error(f"Escalation task failed for message {key[1]}:", e)
+    finally:
+        # Only the task that currently owns this key may clear it. A `delay` press
+        # cancels this task and stores a *fresh* timer under the same key; without
+        # this guard, our cancelled-task cleanup would run during the reschedule's
+        # flush await and clobber the rescheduled escalation so it never fires.
+        entry = state.pending_buttons.get(key)
+        owner = entry.get('task') if entry else None
+        if entry is None or owner is None or owner is asyncio.current_task():
+            state.pending_buttons.pop(key, None)
+            state._button_states_cache.pop(key, None)
+            await persistence.flush_button_cache()
+
+
+async def cancel_pending_button(posted_channel_id: str, message_ts: str) -> None:
+    key = (posted_channel_id, message_ts)
+    entry = state.pending_buttons.pop(key, None)
+    state._button_states_cache.pop(key, None)
+    if entry:
+        if entry.get('task'):
+            entry['task'].cancel()
+        await persistence.flush_button_cache()
+
+
+async def reschedule_escalation(app: AsyncApp, opsgenie_token: str, posted_channel_id: str, message_ts: str, minutes: int) -> bool:
+    key = (posted_channel_id, message_ts)
+    entry = state.pending_buttons.get(key)
+    if not entry:
+        log_warning(f"No pending escalation to delay for message {message_ts}.")
+        return False
+    if entry.get('task'):
+        entry['task'].cancel()
+    extra = minutes * 60
+    record = {k: v for k, v in entry.items() if k != 'task'}
+    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.")
+
+
+async def _strip_buttons(app: AsyncApp, posted_channel_id: str, message_ts: str, entry: dict | None) -> None:
+    """Remove the interactive buttons from a handled message so a stale later click
+    can't fire an action against a since-edited config. Best-effort."""
+    posted_text = (entry or {}).get('posted_text')
+    if not posted_text or not posted_channel_id or not message_ts:
+        return
+    try:
+        await app.client.chat_update(
+            channel=posted_channel_id,
+            ts=message_ts,
+            text=posted_text,
+            blocks=[{"type": "section", "text": {"type": "mrkdwn", "text": posted_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')
+
+    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)
+    entry = state.pending_buttons.get((posted_channel_id, message_ts))
+    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)
+        return
+
+    # Every other button stops the pending escalation, 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 cancel_pending_button(posted_channel_id, message_ts)
+    await dispatch_button_action(app, opsgenie_token, channel, posted_channel_id, message_ts, buttons[index], run_context)
+    await _strip_buttons(app, posted_channel_id, message_ts, entry)
diff --git a/hutbot/buttonutil.py b/hutbot/buttonutil.py
new file mode 100644
index 0000000..305e5a6
--- /dev/null
+++ b/hutbot/buttonutil.py
@@ -0,0 +1,28 @@
+"""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, tolerating the legacy {label, target} form."""
+    action = button.get('action') or BUTTON_ACTION_CONFIG
+    if action == BUTTON_ACTION_CONFIG:
+        value = button.get('value') or button.get('target') or ''
+    else:
+        value = button.get('value', '') or ''
+    return action, value
+
+
+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..fbd2ac6
--- /dev/null
+++ b/hutbot/commands/dispatch.py
@@ -0,0 +1,158 @@
+"""Command dispatch: match a slash-command string and run the matching handler."""
+
+from slack_bolt.async_app import AsyncApp
+
+from .. import state
+from .. import messaging
+from .. import opsgenie
+from ..constants import CONFIG_NAME_PATTERN, DEFAULT_CONFIG_NAME
+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)):
+        wait_time_minutes = int(strip_quotes(match.group("wait_time")))
+        await setters.set_wait_time(app, channel, config_name, wait_time_minutes, 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 (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 (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_FORWARD_CHANNEL_PATTERN.match(command_text)):
+        channel_ref = strip_quotes(match.group("channel"))
+        await setters.set_forward_channel(app, channel, config_name, channel_ref, user, thread_ts)
+    elif patterns.CLEAR_FORWARD_CHANNEL_PATTERN.match(command_text):
+        await setters.clear_forward_channel(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"), user, thread_ts)
+    elif (match := patterns.SET_CRON_PATTERN.match(command_text)):
+        await setters.set_schedule_cron(app, channel, config_name, match.group("cron"), user, thread_ts)
+    elif (match := patterns.SET_SCHEDULE_TIMEZONE_PATTERN.match(command_text)):
+        await setters.set_schedule_timezone(app, channel, config_name, match.group("tz"), 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"), user, thread_ts)
+    elif (match := patterns.SET_TARGET_PATTERN.match(command_text)):
+        await setters.set_action_target(app, channel, config_name, 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_DEFAULT_BUTTON_PATTERN.match(command_text):
+        await setters.clear_default_button(app, channel, config_name, user, thread_ts)
+    elif (match := patterns.SET_DEFAULT_BUTTON_PATTERN.match(command_text)):
+        await setters.set_default_button(app, channel, config_name, match.group("label"), user, thread_ts)
+    elif (match := patterns.SET_BUTTON_TIMEOUT_TARGET_PATTERN.match(command_text)):
+        await setters.set_button_timeout_target(app, channel, config_name, match.group("target"), user, thread_ts)
+    elif (match := patterns.SET_BUTTON_TIMEOUT_PATTERN.match(command_text)):
+        await setters.set_button_timeout(app, channel, config_name, match.group("minutes"), 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
+
+
+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
+
+    # 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 messaging.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 messaging.send_message(app, channel, user, "Huh? :thinking_face: Maybe type `/hutbot 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..6750c38
--- /dev/null
+++ b/hutbot/commands/info.py
@@ -0,0 +1,206 @@
+"""Read-only slash-command handlers: lists, team lookup, and config display."""
+
+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 ..buttonutil import normalize_button
+from ..constants import (
+    ACTION_REPLY,
+    DEFAULT_DATE_FORMAT,
+    DEFAULT_TIME_FORMAT,
+    ESCALATION_BUTTON,
+    ESCALATION_CONFIG,
+    ID_PATTERN,
+    TRIGGER_MESSAGE,
+    TRIGGER_SCHEDULE,
+)
+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
+
+    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 = opsgenie.get_opsgenie_priority(config)
+        replies_enabled = config.get('enabled', True)
+        trigger = config.get('trigger', TRIGGER_MESSAGE)
+        action = config.get('action', ACTION_REPLY)
+
+        rows = [
+            ("Trigger",            trigger),
+            ("OpsGenie",           ('enabled' if opsgenie_enabled else 'disabled') + ('' if state.opsgenie_configured else ' (not configured)')),
+            ("OpsGenie schedule",  opsgenie_schedule_name),
+            ("OpsGenie priority",  opsgenie_priority),
+            ("OpsGenie message",   config.get('opsgenie_message') or '<original message>'),
+            ("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>'),
+        ]
+
+        if trigger == TRIGGER_SCHEDULE:
+            rows.append(("Cron", config.get('schedule_cron') or '<None>'))
+            rows.append(("Schedule timezone", config.get('schedule_timezone') or '<server local>'))
+        condition = config.get('condition') or ''
+        if condition:
+            negate = ' (negated)' if config.get('condition_negate') else ''
+            rows.append(("Condition", f"{condition}{negate}"))
+            if config.get('outlook_subject_pattern'):
+                rows.append(("Outlook subject", config.get('outlook_subject_pattern')))
+            if config.get('outlook_body_pattern'):
+                rows.append(("Outlook body", config.get('outlook_body_pattern')))
+        if action != ACTION_REPLY:
+            rows.append(("Action", action))
+            rows.append(("Action target", config.get('action_target') or '<None>'))
+        config_buttons = config.get('buttons') or []
+        if config_buttons:
+            def _button_label(b):
+                action, value = normalize_button(b)
+                return f"{b.get('label')} → {action}" + (f":{value}" if value else "")
+            rows.append(("Buttons", [_button_label(b) for b in config_buttons]))
+            button_timeout_minutes = (config.get('button_timeout') or 0) // 60
+            if button_timeout_minutes:
+                kind, target = buttons._escalation_kind(config)
+                if kind == ESCALATION_BUTTON:
+                    escalates_to = f"auto-press `{target}`"
+                elif kind == ESCALATION_CONFIG:
+                    escalates_to = f"run `{target}`"
+                else:
+                    escalates_to = "nothing"
+                rows.append(("Button timeout", f"{button_timeout_minutes} minutes → {escalates_to}"))
+            if config.get('default_button'):
+                rows.append(("Default button", config.get('default_button')))
+        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 messaging.send_message(app, channel, user, message, thread_ts)
diff --git a/hutbot/commands/patterns.py b/hutbot/commands/patterns.py
new file mode 100644
index 0000000..ae710a2
--- /dev/null
+++ b/hutbot/commands/patterns.py
@@ -0,0 +1,59 @@
+"""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)
+
+
+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>.+)')
+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$')
+SET_TRIGGER_PATTERN = create_command_pattern(r'set\s+trigger\s+(?P<trigger>.+)')
+SET_CRON_PATTERN = create_command_pattern(r'set\s+(schedule[_ -]?)?cron\s+(?P<cron>.+)')
+SET_SCHEDULE_TIMEZONE_PATTERN = create_command_pattern(r'set\s+schedule[_ -]?(time)?zone\s+(?P<tz>.+)')
+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')
+SET_ACTION_PATTERN = create_command_pattern(r'set\s+action\s+(?P<action>.+)')
+SET_TARGET_PATTERN = create_command_pattern(r'set\s+target\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?')
+SET_BUTTON_TIMEOUT_TARGET_PATTERN = create_command_pattern(r'set\s+button[_ -]?timeout[_ -]?target\s+(?P<target>.+)')
+SET_BUTTON_TIMEOUT_PATTERN = create_command_pattern(r'set\s+button[_ -]?timeout\s+(?P<minutes>.+)')
+CLEAR_DEFAULT_BUTTON_PATTERN = create_command_pattern(r'(clear|unset|remove)\s+default[_ -]?button')
+SET_DEFAULT_BUTTON_PATTERN = create_command_pattern(r'set\s+default[_ -]?button\s+(?P<label>.+)')
+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..d8aa43c
--- /dev/null
+++ b/hutbot/commands/setters.py
@@ -0,0 +1,599 @@
+"""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 ..buttonutil import _find_button_index
+from ..constants import (
+    ACTIONS,
+    BUTTON_ACTION_CONFIG,
+    BUTTON_ACTION_DELAY,
+    BUTTON_ACTION_MESSAGE,
+    BUTTON_ACTIONS,
+    CONDITION_NONE,
+    CONDITION_OUTLOOK,
+    CONDITIONS,
+    DEFAULT_CONFIG,
+    DEFAULT_CONFIG_NAME,
+    ID_PATTERN,
+    OPSGENIE_PRIORITIES,
+    SUPPORTED_TEMPLATE_VARIABLES,
+    TRIGGER_MESSAGE,
+    TRIGGER_SCHEDULE,
+    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]
+
+
+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
+    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 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()
+    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_forward_channel(app: AsyncApp, channel, config_name: str, channel_ref: str, 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 messaging.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 messaging.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 persistence.save_configuration()
+    await messaging.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, config_name: str, user, thread_ts: str = "") -> None:
+    if config_name in channel.configs:
+        channel.configs[config_name].pop('forward_channel', None)
+        await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Forward channel* cleared 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, "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 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_minutes: int, 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 messaging.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 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 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, user, thread_ts: str = "") -> None:
+    value = strip_quotes(value).strip().lower()
+    value = {'msg': TRIGGER_MESSAGE, 'cron': TRIGGER_SCHEDULE, 'scheduled': TRIGGER_SCHEDULE}.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
+    _ensure_config(channel, config_name)['trigger'] = value
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Trigger* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_schedule_cron(app: AsyncApp, channel, config_name: str, cron_expr: str, user, thread_ts: str = "") -> None:
+    cron_expr = strip_quotes(cron_expr).strip()
+    if not cron_expr:
+        await messaging.send_message(app, channel, user, "Invalid *cron* expression. Must be non-empty.", thread_ts)
+        return
+    if croniter is not None and not croniter.is_valid(cron_expr):
+        await messaging.send_message(app, channel, user, f"Invalid *cron* expression: `{cron_expr}`. Use 5-field cron, e.g. `0 9 * * 1-5`.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['schedule_cron'] = cron_expr
+    await persistence.save_configuration()
+    note = "" if croniter is not None else " (not validated — `croniter` not installed)"
+    await messaging.send_message(app, channel, user, f"*Cron schedule* set to `{cron_expr}` in configuration `{config_name}`{note}.", thread_ts)
+
+
+async def set_schedule_timezone(app: AsyncApp, channel, config_name: str, tz_name: str, user, thread_ts: str = "") -> None:
+    tz_name = strip_quotes(tz_name).strip()
+    if tz_name:
+        try:
+            ZoneInfo(tz_name)
+        except ZoneInfoNotFoundError:
+            await messaging.send_message(app, channel, user, f"Unknown timezone: `{tz_name}`. Use an IANA name, e.g. `Europe/Berlin`.", thread_ts)
+            return
+    _ensure_config(channel, config_name)['schedule_timezone'] = tz_name
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Schedule timezone* set to `{tz_name or '<server local>'}` 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, user, thread_ts: str = "") -> None:
+    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
+    _ensure_config(channel, config_name)['action'] = value
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Action* set to `{value}` in configuration `{config_name}`.", thread_ts)
+
+
+async def set_action_target(app: AsyncApp, channel, config_name: str, target: str, user, thread_ts: str = "") -> None:
+    target = strip_quotes(target).strip()
+    if not target:
+        await messaging.send_message(app, channel, user, "Invalid *target*. Must be non-empty.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['action_target'] = target
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"*Action target* set to `{target}` 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 either "<action> [arg]" or a bare config name (back-compat).
+    spec = spec.strip()
+    parts = spec.split(None, 1)
+    first = parts[0].lower() if parts else ""
+    if first in BUTTON_ACTIONS:
+        action = first
+        value = strip_quotes(parts[1]).strip() if len(parts) > 1 else ""
+    else:
+        action = BUTTON_ACTION_CONFIG
+        value = strip_quotes(spec).strip()
+
+    if action in (BUTTON_ACTION_CONFIG, BUTTON_ACTION_MESSAGE) and not value:
+        what = "a configuration name" if action == BUTTON_ACTION_CONFIG else "a message"
+        await messaging.send_message(app, channel, user, f"Invalid *button*. `{action}` needs {what}.", thread_ts)
+        return
+    if action == BUTTON_ACTION_DELAY:
+        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 set_default_button(app: AsyncApp, channel, config_name: str, label: str, user, thread_ts: str = "") -> None:
+    label = strip_quotes(label).strip()
+    if not label:
+        await messaging.send_message(app, channel, user, "Invalid *default button*. Must reference a button label.", thread_ts)
+        return
+    config = _ensure_config(channel, config_name)
+    config['default_button'] = label
+    await persistence.save_configuration()
+    warning = "" if _find_button_index(config, label) is not None else f" :warning: (no button labelled `{label}` yet)"
+    await messaging.send_message(app, channel, user, f"*Default button* (auto-pressed on timeout) set to `{label}` in configuration `{config_name}`{warning}.", thread_ts)
+
+
+async def clear_default_button(app: AsyncApp, channel, config_name: str, user, thread_ts: str = "") -> None:
+    _ensure_config(channel, config_name)['default_button'] = ''
+    await persistence.save_configuration()
+    await messaging.send_message(app, channel, user, f"Cleared *default button* in configuration `{config_name}`.", thread_ts)
+
+
+async def set_button_timeout(app: AsyncApp, channel, config_name: str, minutes_str: str, user, thread_ts: str = "") -> None:
+    try:
+        minutes = int(strip_quotes(minutes_str).strip())
+    except ValueError:
+        await messaging.send_message(app, channel, user, "Invalid *button timeout*. Must be a number of minutes between 0 and 1440.", thread_ts)
+        return
+    if minutes < 0 or minutes > 1440:
+        await messaging.send_message(app, channel, user, "Invalid *button timeout*. Must be between 0 and 1440 minutes.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['button_timeout'] = minutes * 60
+    await persistence.save_configuration()
+    label = f"`{minutes}` minutes" if minutes else "disabled"
+    await messaging.send_message(app, channel, user, f"*Button timeout* set to {label} in configuration `{config_name}`.", thread_ts)
+
+
+async def set_button_timeout_target(app: AsyncApp, channel, config_name: str, target: str, user, thread_ts: str = "") -> None:
+    target = strip_quotes(target).strip()
+    if not target:
+        await messaging.send_message(app, channel, user, "Invalid *button timeout target*. Must reference a configuration name.", thread_ts)
+        return
+    _ensure_config(channel, config_name)['button_timeout_target'] = target
+    await persistence.save_configuration()
+    warning = "" if target in channel.configs else f" :warning: (configuration `{target}` does not exist yet)"
+    await messaging.send_message(app, channel, user, f"*Button timeout target* set to `{target}` 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
+    await messaging.send_message(app, channel, user, f"Running configuration `{config_name}` now…", thread_ts)
+    await actions.run_action(app, opsgenie_token, channel, config, config_name, context={'channel_id': channel.id, 'user': user})
+
+
+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..a95206f
--- /dev/null
+++ b/hutbot/constants.py
@@ -0,0 +1,149 @@
+"""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'
+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_SCHEDULE = "schedule"
+TRIGGER_MANUAL = "manual"
+TRIGGERS = {TRIGGER_MESSAGE, TRIGGER_SCHEDULE, 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}
+
+BUTTON_ACTION_PREFIX = "hutbot_btn"
+
+# What a button does when pressed.
+BUTTON_ACTION_CONFIG = "config"    # run another named config (an OpsGenie alert is just such a config)
+BUTTON_ACTION_ACK = "ack"          # acknowledge/dismiss (cancel escalation), optional ack text
+BUTTON_ACTION_MESSAGE = "message"  # post a fixed inline message
+BUTTON_ACTION_DELAY = "delay"      # delay the pending escalation by N minutes
+BUTTON_ACTIONS = {BUTTON_ACTION_CONFIG, BUTTON_ACTION_ACK, BUTTON_ACTION_MESSAGE, 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,
+    "forward_channel": "",
+    "enabled": True,
+    # Trigger: how the rule starts. "message" keeps the classic behavior.
+    "trigger": TRIGGER_MESSAGE,
+    "schedule_cron": "",
+    "schedule_timezone": "",
+    # Condition: optional gate evaluated when a schedule 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": [],
+    "button_timeout": 0,
+    "button_timeout_target": "",
+    "default_button": "",  # label of the button to auto-press if none is pressed in time
+}
+
+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'])
+
+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>"
diff --git a/hutbot/datetimefmt.py b/hutbot/datetimefmt.py
new file mode 100644
index 0000000..7652a27
--- /dev/null
+++ b/hutbot/datetimefmt.py
@@ -0,0 +1,247 @@
+"""Date/time parsing, formatting, locale handling, and work-hours helpers."""
+
+import re
+import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+from employee_list import log_error, log_warning
+
+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() -> 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 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 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_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 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..b8a4811
--- /dev/null
+++ b/hutbot/messaging.py
@@ -0,0 +1,243 @@
+"""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 .constants import ID_PATTERN, MENTION_PATTERN, SUPPORTED_TEMPLATE_VARIABLES
+from .models import Channel, User
+from .textutil import log_debug
+
+
+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:
+    update_text = (
+        "Hi! :wave: I am *Hutbot* :palm_up_hand::tophat: Here's what's :new::\n\n"
+        "> :robot_face: *Triggers, actions & buttons*\n>\n"
+        "> Rules can now run on a `schedule` (cron), DM a user or group, post to a channel, and carry interactive buttons (with an auto-press default + timeout escalation). See `/hutbot help`.\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 opsgenie-message <text>", "Template for the alert text (default: the message)."),
+        ("/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] set trigger <message|schedule|manual>", "Set how the rule starts."),
+        ("/hutbot [config] set cron <expr>", "Set the cron schedule, e.g. 0 9 * * 1-5."),
+        ("/hutbot [config] set schedule-timezone <tz>", "Set the cron timezone (IANA name)."),
+        ("/hutbot [config] set condition <none|outlook>", "Gate a schedule on a condition."),
+        ("/hutbot [config] set outlook-subject <regex>", "Match Outlook event subject (stub)."),
+        ("/hutbot [config] set outlook-body <regex>", "Match Outlook event body (stub)."),
+        ("/hutbot [config] enable negate", "Invert the condition (e.g. no matching event)."),
+        ("/hutbot [config] disable negate", "Stop inverting the condition."),
+        ("/hutbot [config] set action <reply|dm-user|group-dm|post-channel>", "Set what the rule does."),
+        ("/hutbot [config] set target <@user|@group|#channel>", "Set the action recipient."),
+        ("/hutbot [config] add button \"<label>\" config <config>", "Button runs another config (e.g. an alert config)."),
+        ("/hutbot [config] add button \"<label>\" ack [text]", "Button acknowledges/dismisses (stops escalation)."),
+        ("/hutbot [config] add button \"<label>\" message <text>", "Button posts a fixed message."),
+        ("/hutbot [config] add button \"<label>\" delay <minutes>", "Button delays the escalation."),
+        ("/hutbot [config] clear buttons", "Remove all buttons."),
+        ("/hutbot [config] set button-timeout <minutes>", "Escalate if no button is pressed in time."),
+        ("/hutbot [config] set button-timeout-target <config>", "Config to run on button timeout."),
+        ("/hutbot [config] set default-button \"<label>\"", "Auto-press this button on timeout."),
+        ("/hutbot [config] run", "Run this configuration's action now."),
+        ("/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)
diff --git a/hutbot/models.py b/hutbot/models.py
new file mode 100644
index 0000000..04d635e
--- /dev/null
+++ b/hutbot/models.py
@@ -0,0 +1,21 @@
+"""Data types shared across the package: namedtuples + template expression."""
+
+import collections
+from dataclasses import dataclass
+
+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'])
+
+
+@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..09e70e7
--- /dev/null
+++ b/hutbot/opsgenie.py
@@ -0,0 +1,424 @@
+"""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 .constants import (
+    DEFAULT_CONFIG,
+    DEFAULT_OPSGENIE_PRIORITY,
+    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, "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 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}'
+    }
+    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)
+
+
+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..7dc3330
--- /dev/null
+++ b/hutbot/persistence.py
@@ -0,0 +1,118 @@
+"""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, ... } }
+        is_flat_config = any(k in constants.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 = {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
+            # Normalize legacy {label, target} buttons to {label, action, value}.
+            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..842e6d8
--- /dev/null
+++ b/hutbot/routing.py
@@ -0,0 +1,255 @@
+"""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 .constants import BUTTON_ACTION_PREFIX, 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
+
+    actor_is_bot = False
+    user = None
+    if user_id:
+        user = await slackcache.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 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():
+            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]):
+            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(),
+        }
+        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]
+
+
+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.command("/hutbot")
+    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..e5ba788
--- /dev/null
+++ b/hutbot/scheduling.py
@@ -0,0 +1,157 @@
+"""Scheduled replies (deferred message reminders) and the cron-trigger scheduler."""
+
+import asyncio
+import datetime
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+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 actions
+from . import persistence
+from .constants import SCHEDULER_INTERVAL, TRIGGER_SCHEDULE
+from .models import ScheduledReply
+
+try:
+    from croniter import croniter
+except ImportError:  # pragma: no cover - dependency optional at runtime
+    croniter = None
+
+
+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) -> 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
+    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 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,
+        })
+        reply_message = (posted or {}).get('text', '')
+        forward_channel_id = config.get('forward_channel')
+        if forward_channel_id and reply_message:
+            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)
+        # 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 _resolve_schedule_timezone(config: dict):
+    tz_name = config.get('schedule_timezone') or config.get('datetime_timezone') or ''
+    if tz_name:
+        try:
+            return ZoneInfo(tz_name)
+        except ZoneInfoNotFoundError:
+            log_warning(f"Unknown schedule timezone '{tz_name}'; using server local time.")
+    return None
+
+
+def _cron_due(cron_expr: str, config: dict, last: datetime.datetime, now: datetime.datetime) -> bool:
+    tz = _resolve_schedule_timezone(config)
+    base = last.astimezone(tz) if tz else last.astimezone()
+    current = now.astimezone(tz) if tz else now.astimezone()
+    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_SCHEDULE:
+                continue
+            if not config.get('enabled', True):
+                continue
+            cron_expr = config.get('schedule_cron') or ''
+            if not cron_expr:
+                continue
+            if croniter is not None and not croniter.is_valid(cron_expr):
+                log_warning(f"Schedule '{config_name}' in channel {channel_id} has invalid cron '{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"Schedule '{config_name}' in #{channel.name} fired but condition not met.")
+                continue
+            log(f"Schedule '{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"Schedule '{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())
+        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))
+        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..b99a047
--- /dev/null
+++ b/hutbot/slackcache.py
@@ -0,0 +1,275 @@
+"""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_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:
+    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 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..0a263cb
--- /dev/null
+++ b/hutbot/state.py
@@ -0,0 +1,68 @@
+"""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
+
+# 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
+
+# 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, opsgenie_configured
+    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
+    opsgenie_configured = False
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..e14ea68
--- /dev/null
+++ b/hutbot/templating.py
@@ -0,0 +1,236 @@
+"""Parsing and rendering of ``{{variable}}`` reply-message templates."""
+
+from slack_bolt.async_app import AsyncApp
+
+from . import datetimefmt
+from . import opsgenie
+from .constants import (
+    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:
+            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 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')
+    opsgenie_template_variables = {}
+    if include_opsgenie:
+        opsgenie_template_variables = await opsgenie.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),
+    }
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..84900d1
--- /dev/null
+++ b/hutbot/webui_backend.py
@@ -0,0 +1,416 @@
+"""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_DELAY,
+    BUTTON_ACTION_MESSAGE,
+    BUTTON_ACTIONS,
+    CONDITION_NONE,
+    CONDITION_OUTLOOK,
+    CONDITIONS,
+    CONFIG_NAME_PATTERN,
+    DEFAULT_CONFIG,
+    DEFAULT_CONFIG_NAME,
+    DEFAULT_OPSGENIE_PRIORITY,
+    OPSGENIE_PRIORITIES,
+    SUPPORTED_TEMPLATE_VARIABLES,
+    TEAM_UNKNOWN,
+    TRIGGER_MESSAGE,
+    TRIGGER_SCHEDULE,
+    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 ``button_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
+
+    # button_timeout (stored as seconds; 0..1440 minutes, 0 = disabled)
+    try:
+        button_timeout = int(get('button_timeout'))
+    except (TypeError, ValueError):
+        errors['button_timeout'] = "Button timeout must be a number."
+    else:
+        if button_timeout < 0 or button_timeout > 86400:
+            errors['button_timeout'] = "Button timeout must be between 0 and 1440 minutes."
+        else:
+            cfg['button_timeout'] = button_timeout
+
+    # 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'] = ""
+
+    sched_tz = str(get('schedule_timezone') or "").strip()
+    if sched_tz:
+        try:
+            ZoneInfo(sched_tz)
+            cfg['schedule_timezone'] = sched_tz
+        except ZoneInfoNotFoundError:
+            errors['schedule_timezone'] = f"Unknown timezone `{sched_tz}`. Use an IANA name, e.g. Europe/Berlin."
+    else:
+        cfg['schedule_timezone'] = ""
+
+    cron_expr = str(get('schedule_cron') or "").strip()
+    if cron_expr and croniter is not None and not croniter.is_valid(cron_expr):
+        errors['schedule_cron'] = "Invalid cron expression. Use 5 fields, e.g. `0 9 * * 1-5`."
+    else:
+        cfg['schedule_cron'] = cron_expr
+
+    trigger = str(get('trigger') or TRIGGER_MESSAGE).strip().lower()
+    trigger = {'msg': TRIGGER_MESSAGE, 'cron': TRIGGER_SCHEDULE, 'scheduled': TRIGGER_SCHEDULE}.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}"
+
+    forward_channel = str(get('forward_channel') or "").strip()
+    if forward_channel and not re.match(r'^C[A-Z0-9]+$', forward_channel):
+        errors['forward_channel'] = "Use a Slack channel ID like `C0123ABCD`."
+    else:
+        cfg['forward_channel'] = forward_channel
+
+    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 in (BUTTON_ACTION_CONFIG, BUTTON_ACTION_MESSAGE) and not value:
+                what = "a configuration name" if button_action == BUTTON_ACTION_CONFIG else "a message"
+                errors[f'buttons.{i}'] = f"`{button_action}` button needs {what}."
+                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
+
+    cfg['button_timeout_target'] = str(get('button_timeout_target') or "").strip()
+    cfg['default_button'] = str(get('default_button') or "").strip()
+
+    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)."""
+    clean, errors = await validate_config_payload(payload, app, channel_id)
+    if errors:
+        return False, errors
+    async with state._config_write_lock:
+        state.channel_config.setdefault(channel_id, {})[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.match(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,
+    }
+
+
+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,
+    )
+    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..289586a
--- /dev/null
+++ b/tests/_common.py
@@ -0,0 +1,76 @@
+"""Shared imports, helpers, and hutbot module aliases for the test suite."""
+
+import os
+import json
+import base64
+import tempfile
+import asyncio
+import datetime
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock, 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 DEFAULT_CONFIG
+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,
+)
+from hutbot.webui_backend import (
+    validate_config_payload, list_user_config_channels, ui_create_config, ui_delete_config,
+)
+from hutbot.commands.dispatch import process_command
+from hutbot.commands.setters import (
+    set_work_hours, set_pattern, set_reply_message,
+    set_forward_channel, clear_forward_channel, 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
+
+
+__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..0c8220b
--- /dev/null
+++ b/tests/test_actions.py
@@ -0,0 +1,150 @@
+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", channel, user)
+        assert channel.configs["default"]["action"] == "dm_user"
+        await process_command(app, "set action group-dm", 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"
+
+
+
+# ----- 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..258ac57
--- /dev/null
+++ b/tests/test_buttons.py
@@ -0,0 +1,418 @@
+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" approve-flow', channel, user)
+        # Bare target ⇒ config action (back-compat).
+        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" message "See the wiki"', 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": "message", "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_normalizes_legacy_buttons():
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["buttons"] = [{"label": "Old", "target": "legacy-flow"}]
+    config = {"C12345": {"default": cfg}}
+    migrated = await migrate_and_apply_defaults(AsyncMock(), config)
+    assert migrated["C12345"]["default"]["buttons"] == [{"label": "Old", "action": "config", "value": "legacy-flow"}]
+
+
+
+@pytest.mark.asyncio
+async def test_set_button_timeout_minutes_to_seconds():
+    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 button-timeout 15", channel, user)
+        assert channel.configs["default"]["button_timeout"] == 900
+        await process_command(app, "set button-timeout-target escalate", channel, user)
+        assert channel.configs["default"]["button_timeout_target"] == "escalate"
+
+
+
+# ----- 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}
+
+
+
+@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["button_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})}
+    with patch('hutbot.buttons.cancel_pending_button', new=AsyncMock()) as cancel, \
+         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)
+    cancel.assert_awaited_once_with("C12345", "10.1")
+    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})}
+    with patch('hutbot.buttons.cancel_pending_button', new=AsyncMock()) as cancel, \
+         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)
+    cancel.assert_awaited_once_with("C12345", "10.1")
+    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.buttons.cancel_pending_button', 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})}
+    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.buttons.cancel_pending_button', new=AsyncMock()) as cancel, \
+         patch('hutbot.buttons.reschedule_escalation', new=AsyncMock()) as resched:
+        await hutbot.buttons.handle_button_press(app, "token", body, action)
+    resched.assert_awaited_once_with(app, "token", "C12345", "10.1", 3)
+    cancel.assert_not_awaited()  # delay reschedules, does not cancel
+
+
+
+@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["button_timeout"] = 3600
+    config["button_timeout_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_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["button_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_set_default_button_command():
+    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 default-button "Yes"', channel, user)
+        assert channel.configs["default"]["default_button"] == "Yes"
+        await process_command(app, "clear default-button", channel, user)
+        assert channel.configs["default"]["default_button"] == ""
+
+
+
+def test_escalation_kind_prefers_default_button():
+    cfg = DEFAULT_CONFIG.copy()
+    cfg["buttons"] = [{"label": "Yes", "action": "message", "value": "Help text"}]
+    cfg["default_button"] = "Yes"
+    cfg["button_timeout_target"] = "some-config"  # default button still wins
+    assert hutbot.buttons._escalation_kind(cfg) == (hutbot.constants.ESCALATION_BUTTON, "Yes")
+    # Unknown default-button label falls back to the config target.
+    cfg["default_button"] = "Nope"
+    assert hutbot.buttons._escalation_kind(cfg) == (hutbot.constants.ESCALATION_CONFIG, "some-config")
+
+
+
+@pytest.mark.asyncio
+async def test_escalation_task_auto_presses_default_button():
+    app = AsyncMock()
+    src = DEFAULT_CONFIG.copy()
+    src["buttons"] = [
+        {"label": "Yes", "action": "message", "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["button_timeout"] = 3600
+    config["button_timeout_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
+    assert kw["ts"] == "10.1" and kw["text"] == "Approve?"
diff --git a/tests/test_commands_info.py b/tests/test_commands_info.py
new file mode 100644
index 0000000..1d2f2b0
--- /dev/null
+++ b/tests/test_commands_info.py
@@ -0,0 +1,224 @@
+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"},
+        "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 = 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('hutbot.messaging.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_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 = 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_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 = 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_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('hutbot.persistence.save_configuration'), patch('hutbot.messaging.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_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('hutbot.messaging.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('hutbot.messaging.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_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 = 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('hutbot.messaging.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_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" message "Here is the help doc"', ch, u)
+        await process_command(app, 'add button "No" ack', ch, u)
+        await process_command(app, 'set button-timeout 5', ch, u)
+        await process_command(app, 'set default-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
diff --git a/tests/test_commands_setters.py b/tests/test_commands_setters.py
new file mode 100644
index 0000000..73f2686
--- /dev/null
+++ b/tests/test_commands_setters.py
@@ -0,0 +1,284 @@
+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_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 schedule", channel, user)
+        assert channel.configs["default"]["trigger"] == "schedule"
+        await process_command(app, "set trigger bogus", channel, user)
+        assert channel.configs["default"]["trigger"] == "schedule"  # unchanged
+        assert "Invalid *trigger*" in send.call_args_list[-1].args[3]
diff --git a/tests/test_datetimefmt.py b/tests/test_datetimefmt.py
new file mode 100644
index 0000000..a2d84b7
--- /dev/null
+++ b/tests/test_datetimefmt.py
@@ -0,0 +1,28 @@
+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"
diff --git a/tests/test_opsgenie.py b/tests/test_opsgenie.py
new file mode 100644
index 0000000..d1143cb
--- /dev/null
+++ b/tests/test_opsgenie.py
@@ -0,0 +1,808 @@
+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
diff --git a/tests/test_persistence.py b/tests/test_persistence.py
new file mode 100644
index 0000000..7e600cf
--- /dev/null
+++ b/tests/test_persistence.py
@@ -0,0 +1,68 @@
+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_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 == {}
diff --git a/tests/test_routing.py b/tests/test_routing.py
new file mode 100644
index 0000000..8764db0
--- /dev/null
+++ b/tests/test_routing.py
@@ -0,0 +1,349 @@
+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_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('hutbot.persistence.save_configuration'), patch('hutbot.messaging.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('hutbot.messaging.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('hutbot.messaging.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('hutbot.persistence.save_configuration'), patch('hutbot.messaging.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_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('hutbot.persistence.save_configuration'), patch('hutbot.messaging.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('hutbot.persistence.save_configuration'), patch('hutbot.messaging.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_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
diff --git a/tests/test_scheduling.py b/tests/test_scheduling.py
new file mode 100644
index 0000000..91f2604
--- /dev/null
+++ b/tests/test_scheduling.py
@@ -0,0 +1,304 @@
+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
+
+
+
+@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"}
+    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(), "wait_time": 0, "reply_message": "Anybody?", "forward_channel": "CFWDCHAN"}
+
+    with patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
+
+    # The reply itself + the forward both post; assert the forward call is present.
+    app.client.chat_postMessage.assert_any_await(
+        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"}
+    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(), "wait_time": 0, "reply_message": "Anybody?"}
+
+    with patch('hutbot.persistence.flush_replies_cache', new=AsyncMock()):
+        await schedule_reply(app, "token", channel, config, "default", user, "Help needed", "1234.1")
+
+    # Only the reply is posted (to the originating channel), no forward.
+    app.client.chat_postMessage.assert_awaited_once_with(channel="C12345", text="Anybody?", mrkdwn=True, thread_ts="1234.1")
+
+
+
+@pytest.mark.asyncio
+async def test_set_schedule_cron_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 cron 0 9 * * 1-5", channel, user)
+        assert channel.configs["default"]["schedule_cron"] == "0 9 * * 1-5"
+        await process_command(app, "set cron not a cron", channel, user)
+        assert channel.configs["default"]["schedule_cron"] == "0 9 * * 1-5"  # unchanged
+        assert "Invalid *cron*" in send.call_args_list[-1].args[3]
+
+
+
+# ----- Scheduler -----
+
+@pytest.mark.asyncio
+async def test_scheduler_tick_fires_due_schedule_when_condition_met():
+    app = AsyncMock()
+    sched = DEFAULT_CONFIG.copy()
+    sched["trigger"] = "schedule"
+    sched["schedule_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"] = "schedule"
+    sched["schedule_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
diff --git a/tests/test_templating.py b/tests/test_templating.py
new file mode 100644
index 0000000..1118b45
--- /dev/null
+++ b/tests/test_templating.py
@@ -0,0 +1,125 @@
+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
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..596be4d
--- /dev/null
+++ b/tests/test_webui_backend.py
@@ -0,0 +1,192 @@
+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",
+        "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,
+        "button_timeout": 300,
+        "buttons": [
+            {"label": "Snooze", "action": "delay", "value": "10"},
+            {"label": "Note", "action": "message", "value": "Some message"},
+        ],
+    }
+
+    cfg, errors = await validate_config_payload(payload, app)
+
+    assert errors == {}
+    assert cfg is not None
+    assert cfg["trigger"] == "schedule"
+    assert cfg["schedule_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/button_timeout stay in seconds.
+    assert cfg["wait_time"] == 600
+    assert cfg["button_timeout"] == 300
+    assert cfg["buttons"] == [
+        {"label": "Snooze", "action": "delay", "value": "10"},
+        {"label": "Note", "action": "message", "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",
+        "schedule_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", "schedule_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_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"
diff --git a/webui.py b/webui.py
new file mode 100644
index 0000000..c9b230e
--- /dev/null
+++ b/webui.py
@@ -0,0 +1,225 @@
+"""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]
+
+
+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("Sign in with your Slack-linked account to manage Hutbot.")
+    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("Sign in with your Slack-linked account to manage Hutbot.")
+    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..df05d17
--- /dev/null
+++ b/webui_static/app.js
@@ -0,0 +1,619 @@
+"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);
+
+// ---------- 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)", schedule: "Schedule (cron)", manual: "Manual" };
+const TRIGGER_SHORT = { message: "message", schedule: "schedule", 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", message: "Post message", delay: "Delay timer" };
+const TARGET_HINT = { dm_user: "A @user (id, name, or email)", group_dm: "A @usergroup handle", post_channel: "A channel ID like C0123ABCD" };
+
+// ---------- 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 Hutbot. 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;
+  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 Hutbot 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 (!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.button_timeout > 0) cls += " escalating";
+  const title = !cfg.enabled ? "Disabled" : (cfg.opsgenie || cfg.button_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 === "schedule" && 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(); } }))),
+    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 === "schedule") {
+    triggerRows.push(grid(
+      field("Cron schedule", textInput("schedule_cron", { mono: true, placeholder: "0 9 * * 1-5" }), { hint: "5-field cron.", error: fieldErr("schedule_cron") }),
+      field("Schedule timezone", textInput("schedule_timezone", { mono: true, placeholder: "Europe/Berlin" }), { hint: "IANA name; blank = server local.", error: fieldErr("schedule_timezone") }),
+    ));
+  }
+  wrap.append(section("Status & trigger", null, ...triggerRows));
+
+  // — Condition (schedule only) —
+  if (cfg.trigger === "schedule") {
+    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", "schedule", ...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") }));
+  } else {
+    actionRows[0].append(field("Forward replies to (optional)", textInput("forward_channel", { mono: true, placeholder: "C0123ABCD" }),
+      { hint: "Channel ID to also post the reply into.", error: fieldErr("forward_channel") }));
+  }
+  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 === "schedule") 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: "message", value: "" }]); structuralRefresh(); } }, "+ Add button");
+
+  const meta = grid(
+    field("Escalate if no button pressed (minutes)", minutesInput("button_timeout"), { hint: "0 = no timeout.", error: fieldErr("button_timeout") }),
+    field("On timeout, auto-press button", textInput("default_button"), { hint: "A button label above (optional)." }),
+  );
+  meta.append(field("…or run this rule on timeout", textInput("button_timeout_target", { mono: true }), { hint: "Another rule's name (optional)." }));
+
+  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 === "ack") valueControl = h("input", { type: "text", value: btn.value || "", placeholder: "Optional message on dismiss", oninput: onValue });
+  else 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: "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" }), { error: fieldErr("datetime_timezone") }),
+    field("Locale", textInput("datetime_locale", { mono: true, placeholder: "de_DE" }), { 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; }
+}